Jan 23, 2025 · Dec 18, 2024 · Dec 30, 2024 · Dec 30, 2024 · Dec 31, 2024 · Dec 31, 2024
diff --git a/.cspell.json b/.cspell.json
    "noninteractive",
    "Nrwl",
    "nullish",
    "nullishness",
    "nx",
    "nx's",
    "onboarded",
    "redeclared",
    "reimplement",
    "resync",
    "ronami",
    "Ronen",
    "Ribaudo",
    "ROADMAP",
    "Romain",
    "ronami",
    "Ronen",
    "Rosenwasser",
    "ruleset",
    "rulesets",
diff --git a/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx b/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx

 - An `||` operator with `??`
 - An `||=` operator with `??=`
 - Ternary expressions (`?:`) that are equivalent to `||` or `??` with `??`

 :::caution
 This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.

 const foo: string | null = 'bar';
 foo !== null ? foo : 'a string';
 foo ? foo : 'a string';
 foo === null ? 'a string' : foo;
 !foo ? 'a string' : foo;
 ```

 Correct code for `ignoreTernaryTests: false`:
 const foo: string | null = 'bar';
 foo ?? 'a string';
 foo ?? 'a string';
 foo ?? 'a string';
 foo ?? 'a string';
 ```

 ### `ignoreConditionalTests`
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
  getParserServices,
  getTypeName,
  getTypeOfPropertyOfName,
  getValueOfLiteralType,
  isAlwaysNullish,
  isArrayMethodCallWithPredicate,
  isIdentifier,
  isNullableType,
  isPossiblyFalsy,
  isPossiblyNullish,
  isPossiblyTruthy,
  isTypeAnyType,
  isTypeFlagSet,
  isTypeUnknownType,
  findTypeGuardAssertedArgument,
 } from '../util/assertionFunctionUtils';

 // Truthiness utilities
 // #region
 const valueIsPseudoBigInt = (
  value: number | string | ts.PseudoBigInt,
 ): value is ts.PseudoBigInt => {
  return typeof value === 'object';
 };

 const getValueOfLiteralType = (
  type: ts.LiteralType,
 ): bigint | number | string => {
  if (valueIsPseudoBigInt(type.value)) {
    return pseudoBigIntToBigInt(type.value);
  }
  return type.value;
 };

 const isTruthyLiteral = (type: ts.Type): boolean =>
  tsutils.isTrueLiteralType(type) ||
  (type.isLiteral() && !!getValueOfLiteralType(type));

 const isPossiblyFalsy = (type: ts.Type): boolean =>
  tsutils
    .unionTypeParts(type)
    // Intersections like `string & {}` can also be possibly falsy,
    // requiring us to look into the intersection.
    .flatMap(type => tsutils.intersectionTypeParts(type))
    // PossiblyFalsy flag includes literal values, so exclude ones that
    // are definitely truthy
    .filter(t => !isTruthyLiteral(t))
    .some(type => isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));

 const isPossiblyTruthy = (type: ts.Type): boolean =>
  tsutils
    .unionTypeParts(type)
    .map(type => tsutils.intersectionTypeParts(type))
    .some(intersectionParts =>
      // It is possible to define intersections that are always falsy,
      // like `"" & { __brand: string }`.
      intersectionParts.every(type => !tsutils.isFalsyType(type)),
    );

 // Nullish utilities
 const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
 const isNullishType = (type: ts.Type): boolean =>
  isTypeFlagSet(type, nullishFlag);

 const isPossiblyNullish = (type: ts.Type): boolean =>
  tsutils.unionTypeParts(type).some(isNullishType);

 const isAlwaysNullish = (type: ts.Type): boolean =>
  tsutils.unionTypeParts(type).every(isNullishType);

 function toStaticValue(
  type: ts.Type,
 ):
  return undefined;
 }

 function pseudoBigIntToBigInt(value: ts.PseudoBigInt): bigint {
  return BigInt((value.negative ? '-' : '') + value.base10Value);
 }

 const BOOL_OPERATORS = new Set([
  '<',
  '>',
      return left >= right;
  }
 }

 // #endregion

 export type Options = [
Original file line number	Diff line number	Diff line change
Expand Up		@@ -141,6 +141,7 @@
		"noninteractive",
		"Nrwl",
		"nullish",
		"nullishness",
		"nx",
		"nx's",
		"onboarded",
Expand All		@@ -167,11 +168,11 @@
		"redeclared",
		"reimplement",
		"resync",
		"ronami",
		"Ronen",
		"Ribaudo",
		"ROADMAP",
		"Romain",
		"ronami",
		"Ronen",
		"Rosenwasser",
		"ruleset",
		"rulesets",
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -16,6 +16,7 @@ This rule reports when you may consider replacing:

		- An `\|\|` operator with `??`
		- An `\|\|=` operator with `??=`
		- Ternary expressions (`?:`) that are equivalent to `\|\|` or `??` with `??`

		:::caution
		This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.
Expand All		@@ -42,7 +43,9 @@ foo === undefined ? 'a string' : foo;

		const foo: string \| null = 'bar';
		foo !== null ? foo : 'a string';
		foo ? foo : 'a string';
		foo === null ? 'a string' : foo;
		!foo ? 'a string' : foo;
		```

		Correct code for `ignoreTernaryTests: false`:
Expand All		@@ -61,6 +64,8 @@ foo ?? 'a string';
		const foo: string \| null = 'bar';
		foo ?? 'a string';
		foo ?? 'a string';
		foo ?? 'a string';
		foo ?? 'a string';
		```

		### `ignoreConditionalTests`
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -11,9 +11,14 @@ import {
		getParserServices,
		getTypeName,
		getTypeOfPropertyOfName,
		getValueOfLiteralType,
		isAlwaysNullish,
		isArrayMethodCallWithPredicate,
		isIdentifier,
		isNullableType,
		isPossiblyFalsy,
		isPossiblyNullish,
		isPossiblyTruthy,
		isTypeAnyType,
		isTypeFlagSet,
		isTypeUnknownType,
Expand All		@@ -25,59 +30,7 @@ import {
		findTypeGuardAssertedArgument,
		} from '../util/assertionFunctionUtils';

		// Truthiness utilities
		// #region
		const valueIsPseudoBigInt = (
		value: number \| string \| ts.PseudoBigInt,
		): value is ts.PseudoBigInt => {
		return typeof value === 'object';
		};

		const getValueOfLiteralType = (
		type: ts.LiteralType,
		): bigint \| number \| string => {
		if (valueIsPseudoBigInt(type.value)) {
		return pseudoBigIntToBigInt(type.value);
		}
		return type.value;
		};

		const isTruthyLiteral = (type: ts.Type): boolean =>
		tsutils.isTrueLiteralType(type) \|\|
		(type.isLiteral() && !!getValueOfLiteralType(type));

		const isPossiblyFalsy = (type: ts.Type): boolean =>
		tsutils
		.unionTypeParts(type)
		// Intersections like `string & {}` can also be possibly falsy,
		// requiring us to look into the intersection.
		.flatMap(type => tsutils.intersectionTypeParts(type))
		// PossiblyFalsy flag includes literal values, so exclude ones that
		// are definitely truthy
		.filter(t => !isTruthyLiteral(t))
		.some(type => isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));

		const isPossiblyTruthy = (type: ts.Type): boolean =>
		tsutils
		.unionTypeParts(type)
		.map(type => tsutils.intersectionTypeParts(type))
		.some(intersectionParts =>
		// It is possible to define intersections that are always falsy,
		// like `"" & { __brand: string }`.
		intersectionParts.every(type => !tsutils.isFalsyType(type)),
		);

		// Nullish utilities
		const nullishFlag = ts.TypeFlags.Undefined \| ts.TypeFlags.Null;
		const isNullishType = (type: ts.Type): boolean =>
		isTypeFlagSet(type, nullishFlag);

		const isPossiblyNullish = (type: ts.Type): boolean =>
		tsutils.unionTypeParts(type).some(isNullishType);

		const isAlwaysNullish = (type: ts.Type): boolean =>
		tsutils.unionTypeParts(type).every(isNullishType);

		function toStaticValue(
		type: ts.Type,
		):
Expand All		@@ -100,10 +53,6 @@ function toStaticValue(
		return undefined;
		}

		function pseudoBigIntToBigInt(value: ts.PseudoBigInt): bigint {
		return BigInt((value.negative ? '-' : '') + value.base10Value);
		}

		const BOOL_OPERATORS = new Set([
		'<',
		'>',
Expand DownExpand Up		@@ -151,7 +100,6 @@ function booleanComparison(
		return left >= right;
		}
		}

		// #endregion

		export type Options = [
Expand Down