@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/nonNullAssertedOptionalChains.js

@@ -0,0 +1,69 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/nonNullAssertedOptionalChains.ts
+function containsOptionalChain(node) {
+	let current = node;
+	let foundNonOptionalAccess = false;
+	while (true) {
+		if (ts$1.isParenthesizedExpression(current)) return !foundNonOptionalAccess && isOptionalChainRoot(current.expression);
+		if (ts$1.isNonNullExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isPropertyAccessExpression(current) || ts$1.isElementAccessExpression(current) || ts$1.isCallExpression(current)) {
+			if (current.questionDotToken) return true;
+			foundNonOptionalAccess = true;
+			current = current.expression;
+			continue;
+		}
+		return false;
+	}
+}
+function isNonNullExpressionContinued(node) {
+	if (ts$1.isParenthesizedExpression(node.expression)) return false;
+	if (ts$1.isPropertyAccessExpression(node.parent) || ts$1.isElementAccessExpression(node.parent) || ts$1.isCallExpression(node.parent)) return node.parent.expression === node;
+	return false;
+}
+function isOptionalChainRoot(node) {
+	let current = node;
+	while (true) {
+		if (ts$1.isNonNullExpression(current) || ts$1.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isPropertyAccessExpression(current) || ts$1.isElementAccessExpression(current) || ts$1.isCallExpression(current)) return Boolean(current.questionDotToken);
+		return false;
+	}
+}
+var nonNullAssertedOptionalChains_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-null assertions on optional chain expressions.",
+		id: "nonNullAssertedOptionalChains",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { nonNullOptionalChain: {
+		primary: "Non-null assertions are unsafe on optional chain expressions because they can still return undefined.",
+		secondary: ["Optional chain expressions (`?.`) return `undefined` when the left side is `null` or `undefined`.", "Applying a non-null assertion (`!`) doesn't change the runtime behavior and can mask potential bugs."],
+		suggestions: ["Remove the non-null assertion."]
+	} },
+	setup(context) {
+		return { visitors: { NonNullExpression: (node, { sourceFile }) => {
+			if (!containsOptionalChain(node.expression) || isNonNullExpressionContinued(node)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				message: "nonNullOptionalChain",
+				range,
+				suggestions: [{
+					id: "removeNonNullAssertion",
+					range,
+					text: node.expression.getText(sourceFile)
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { nonNullAssertedOptionalChains_default as default };
+
+//# sourceMappingURL=nonNullAssertedOptionalChains.js.map

package/lib/rules/nonNullAssertionPlacement.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.";
+    readonly id: "nonNullAssertionPlacement";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "confusingAssign" | "confusingEqual" | "confusingOperator", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullAssertionPlacement.d.ts.map

package/lib/rules/nonNullAssertionPlacement.js

@@ -0,0 +1,94 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/nonNullAssertionPlacement.ts
+function endsWithNonNullAssertion(node, sourceFile) {
+	return node.getLastToken(sourceFile)?.kind === SyntaxKind.ExclamationToken;
+}
+const confusingOperatorTexts = new Map([
+	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
+	[SyntaxKind.EqualsEqualsToken, "=="],
+	[SyntaxKind.EqualsToken, "="],
+	[SyntaxKind.InKeyword, "in"],
+	[SyntaxKind.InstanceOfKeyword, "instanceof"]
+]);
+var nonNullAssertionPlacement_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.",
+		id: "nonNullAssertionPlacement",
+		presets: ["stylisticStrict"]
+	},
+	messages: {
+		confusingAssign: {
+			primary: "Non-null assertion before assignment (`a! = b`) looks similar to not-equals (`a != b`).",
+			secondary: ["This placement creates visual confusion between the assignment `=` and the not-equals operator `!=`.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
+			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
+		},
+		confusingEqual: {
+			primary: "Non-null assertion before equality test (`a! == b`) looks similar to strict not-equals (`a !== b`).",
+			secondary: ["This placement creates visual confusion between the equality operators and the not-equals operators.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
+			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
+		},
+		confusingOperator: {
+			primary: "Non-null assertion before `{{ operator }}` operator (`a! {{ operator }} b`) might be misread as `!(a {{ operator }} b)`.",
+			secondary: ["This placement creates visual confusion that could suggest the entire expression is being negated.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
+			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
+		}
+	},
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			const operatorText = confusingOperatorTexts.get(node.operatorToken.kind);
+			if (!operatorText || !endsWithNonNullAssertion(node.left, sourceFile)) return;
+			const range = {
+				begin: node.left.end - 1,
+				end: node.left.end
+			};
+			const leftText = node.left.getText(sourceFile);
+			const innerExpression = node.left.kind === SyntaxKind.NonNullExpression && node.left.expression;
+			const suggestions = [...innerExpression ? [{
+				id: "removeAssertion",
+				range: {
+					begin: node.left.getStart(sourceFile),
+					end: node.left.end
+				},
+				text: innerExpression.getText(sourceFile)
+			}] : [], {
+				id: "wrapInParentheses",
+				range: {
+					begin: node.left.getStart(sourceFile),
+					end: node.left.end
+				},
+				text: `(${leftText})`
+			}];
+			switch (node.operatorToken.kind) {
+				case SyntaxKind.EqualsToken:
+					context.report({
+						message: "confusingAssign",
+						range,
+						suggestions
+					});
+					break;
+				case SyntaxKind.InKeyword:
+				case SyntaxKind.InstanceOfKeyword:
+					context.report({
+						data: { operator: operatorText },
+						message: "confusingOperator",
+						range,
+						suggestions
+					});
+					break;
+				default:
+					context.report({
+						message: "confusingEqual",
+						range,
+						suggestions
+					});
+					break;
+			}
+		} } };
+	}
+});
+//#endregion
+export { nonNullAssertionPlacement_default as default };
+
+//# sourceMappingURL=nonNullAssertionPlacement.js.map

package/lib/rules/nonNullableTypeAssertions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports type assertions that can be replaced with non-null assertions.";
+    readonly id: "nonNullableTypeAssertions";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNonNullAssertion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullableTypeAssertions.d.ts.map

package/lib/rules/nonNullableTypeAssertions.js

@@ -0,0 +1,78 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/nonNullableTypeAssertions.ts
+function couldBeNullish(type) {
+	if (type.flags & ts.TypeFlags.TypeParameter) {
+		const constraint = type.getConstraint();
+		return constraint === void 0 || couldBeNullish(constraint);
+	}
+	if (tsutils.isUnionType(type)) return type.types.some(couldBeNullish);
+	return (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
+}
+function getTypesIfNotLoose(node, typeChecker) {
+	const type = typeChecker.getTypeAtLocation(node);
+	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
+	return tsutils.unionConstituents(type);
+}
+function isConstAssertion(node, sourceFile) {
+	return node.type.kind === ts.SyntaxKind.TypeReference && node.type.typeName.kind === ts.SyntaxKind.Identifier && node.type.typeName.getText(sourceFile) === "const";
+}
+function needsParentheses(expression) {
+	switch (expression.kind) {
+		case ts.SyntaxKind.ArrowFunction:
+		case ts.SyntaxKind.AwaitExpression:
+		case ts.SyntaxKind.BinaryExpression:
+		case ts.SyntaxKind.ConditionalExpression:
+		case ts.SyntaxKind.PrefixUnaryExpression:
+		case ts.SyntaxKind.YieldExpression: return true;
+		default: return false;
+	}
+}
+function sameTypeWithoutNullish(assertedTypes, originalTypes) {
+	const nonNullishOriginalTypes = originalTypes.filter((type) => (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0);
+	if (nonNullishOriginalTypes.length === originalTypes.length) return false;
+	for (const assertedType of assertedTypes) if (couldBeNullish(assertedType) || !nonNullishOriginalTypes.includes(assertedType)) return false;
+	for (const originalType of nonNullishOriginalTypes) if (!assertedTypes.includes(originalType)) return false;
+	return true;
+}
+var nonNullableTypeAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports type assertions that can be replaced with non-null assertions.",
+		id: "nonNullableTypeAssertions",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferNonNullAssertion: {
+		primary: "Use a non-null assertion (`!`) instead of an explicit type assertion.",
+		secondary: ["When the only difference between the original and asserted type is nullability, a non-null assertion is more concise.", "Non-null assertions clearly communicate that you're asserting the value is not null or undefined."],
+		suggestions: ["Replace the type assertion with a `!` assertion."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile, typeChecker }) {
+			if (isConstAssertion(node, sourceFile)) return;
+			const originalTypes = getTypesIfNotLoose(node.expression, typeChecker);
+			if (!originalTypes) return;
+			const assertedTypes = getTypesIfNotLoose(node.type, typeChecker);
+			if (!assertedTypes || !sameTypeWithoutNullish(assertedTypes, originalTypes)) return;
+			const expressionText = node.expression.getText(sourceFile);
+			const replacement = needsParentheses(node.expression) ? `(${expressionText})!` : `${expressionText}!`;
+			context.report({
+				fix: {
+					range: getTSNodeRange(node, sourceFile),
+					text: replacement
+				},
+				message: "preferNonNullAssertion",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		return { visitors: {
+			AsExpression: checkNode,
+			TypeAssertionExpression: checkNode
+		} };
+	}
+});
+//#endregion
+export { nonNullableTypeAssertions_default as default };
+
+//# sourceMappingURL=nonNullableTypeAssertions.js.map

package/lib/rules/nonOctalDecimalEscapes.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
     readonly id: "nonOctalDecimalEscapes";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedEscape", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedEscape", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=nonOctalDecimalEscapes.d.ts.map

package/lib/rules/nonOctalDecimalEscapes.js

@@ -1,57 +1,48 @@
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/nonOctalDecimalEscapes.ts
 const nonOctalDecimalEscapePattern = /\\[89]/g;
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
-        id: "nonOctalDecimalEscapes",
-        preset: "logical",
-    },
-    messages: {
-        unexpectedEscape: {
-            primary: "Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.",
-            secondary: [
-                "Non-octal decimal escape sequences \\8 and \\9 are legacy features that are treated as identity escapes (the same as the literal digits).",
-                "They are optional in the ECMAScript specification and not supported in strict mode in all environments.",
-                "Use the literal digits directly instead.",
-            ],
-            suggestions: [
-                "Remove the backslash to use the literal digit.",
-                "If an escape sequence is needed, use a Unicode escape like \\u0038 or \\u0039.",
-            ],
-        },
-    },
-    setup(context) {
-        function checkNode(node) {
-            const text = node.getText(context.sourceFile);
-            const matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
-            for (const match of matches) {
-                // Ignore escapes where the backslash itself is escaped (e.g. "\\\\8" -> literal "\\8").
-                // Count the number of consecutive backslashes immediately before the match.
-                const matchIndex = match.index;
-                let backslashesBefore = 0;
-                for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) {
-                    backslashesBefore++;
-                }
-                // If there is an odd number of backslashes before this one, the backslash is escaped
-                // and should not be treated as an escape sequence.
-                if (backslashesBefore % 2 === 1) {
-                    continue;
-                }
-                const start = node.getStart(context.sourceFile) + matchIndex;
-                context.report({
-                    message: "unexpectedEscape",
-                    range: {
-                        begin: start,
-                        end: start + match[0].length,
-                    },
-                });
-            }
-        }
-        return {
-            visitors: {
-                NoSubstitutionTemplateLiteral: checkNode,
-                StringLiteral: checkNode,
-            },
-        };
-    },
+var nonOctalDecimalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
+		id: "nonOctalDecimalEscapes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpectedEscape: {
+		primary: "Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.",
+		secondary: [
+			"Non-octal decimal escape sequences \\8 and \\9 are legacy features that are treated as identity escapes (the same as the literal digits).",
+			"They are optional in the ECMAScript specification and not supported in strict mode in all environments.",
+			"Use the literal digits directly instead."
+		],
+		suggestions: ["Remove the backslash to use the literal digit.", "If an escape sequence is needed, use a Unicode escape like \\u0038 or \\u0039."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			const text = node.getText(sourceFile);
+			const matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
+			for (const match of matches) {
+				const matchIndex = match.index;
+				let backslashesBefore = 0;
+				for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) backslashesBefore++;
+				if (backslashesBefore % 2 === 1) continue;
+				const start = node.getStart(sourceFile) + matchIndex;
+				context.report({
+					message: "unexpectedEscape",
+					range: {
+						begin: start,
+						end: start + match[0].length
+					}
+				});
+			}
+		}
+		return { visitors: {
+			NoSubstitutionTemplateLiteral: checkNode,
+			StringLiteral: checkNode
+		} };
+	}
 });
+//#endregion
+export { nonOctalDecimalEscapes_default as default };
+
+//# sourceMappingURL=nonOctalDecimalEscapes.js.map

package/lib/rules/nullishCheckStyle.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces consistent equality operator usage when comparing with null or undefined.";
+    readonly id: "nullishCheckStyle";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLooseNull" | "preferLooseNullish" | "preferLooseUndefined" | "preferStrictNullish", {
+    readonly looseNullishComparisonStyle: z.ZodDefault<z.ZodEnum<{
+        "prefer-null": "prefer-null";
+        "prefer-undefined": "prefer-undefined";
+        ignore: "ignore";
+    }>>;
+    readonly nullishComparisonStrictness: z.ZodDefault<z.ZodEnum<{
+        ignore: "ignore";
+        "double-equals": "double-equals";
+        "triple-equals": "triple-equals";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=nullishCheckStyle.d.ts.map

package/lib/rules/nullishCheckStyle.js

@@ -0,0 +1,144 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isNullishLiteral, isUndefinedIdentifier, toEqualityOperator, toLooseOperator, toStrictOperator } from "./utils/equalityOperators.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { isNullKeyword } from "ts-api-utils";
+import { z } from "zod/v4";
+//#region src/rules/nullishCheckStyle.ts
+var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces consistent equality operator usage when comparing with null or undefined.",
+		id: "nullishCheckStyle"
+	},
+	messages: {
+		preferLooseNull: {
+			primary: "Compare with 'null' rather than 'undefined'.",
+			secondary: ["`x == null` and `x == undefined` are equivalent to each other; both check `x === null || x === undefined`.", "Use `x == null` since it is shorter."],
+			suggestions: ["Replace 'undefined' with 'null'."]
+		},
+		preferLooseNullish: {
+			primary: "Use loose equality ('{{ looseOperator }}') for nullish comparisons.",
+			secondary: ["When checking for nullish values (null or undefined), loose equality is more concise.", "`x == null` checks for both null and undefined, equivalent to `x === null || x === undefined`."],
+			suggestions: ["Replace '{{ strictOperator }}' with '{{ looseOperator }}'."]
+		},
+		preferLooseUndefined: {
+			primary: "Compare with 'undefined' rather than 'null'.",
+			secondary: ["`x == null` and `x == undefined` are equivalent to each other; both check `x === null || x === undefined`.", "Use `x == undefined`."],
+			suggestions: ["Replace 'null' with 'undefined'."]
+		},
+		preferStrictNullish: {
+			primary: "Use strict equality ('{{ strictOperator }}') for nullish comparisons.",
+			secondary: ["When nullish comparison strictness is set to 'strict', use strict equality operators for nullish comparisons."],
+			suggestions: ["Replace '{{ looseOperator }}' with '{{ strictOperator }}'."]
+		}
+	},
+	options: {
+		looseNullishComparisonStyle: z.enum([
+			"prefer-null",
+			"prefer-undefined",
+			"ignore"
+		]).default("prefer-null"),
+		nullishComparisonStrictness: z.enum([
+			"double-equals",
+			"triple-equals",
+			"ignore"
+		]).default("double-equals")
+	},
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { options, sourceFile }) => {
+			const operator = toEqualityOperator(node.operatorToken.kind);
+			if (operator == null) return;
+			const leftIsNullish = isNullishLiteral(node.left);
+			if (leftIsNullish === isNullishLiteral(node.right)) return;
+			const isLooseComparison = operator === "==" || operator === "!=";
+			if (options.nullishComparisonStrictness === "double-equals" && !isLooseComparison) {
+				const looseOperator = toLooseOperator(operator);
+				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
+				context.report({
+					data: {
+						looseOperator,
+						strictOperator: operator
+					},
+					message: "preferLooseNullish",
+					range: leftIsNullish ? {
+						begin: node.left.getStart(sourceFile),
+						end: operatorRange.end
+					} : {
+						begin: operatorRange.begin,
+						end: node.right.getEnd()
+					},
+					suggestions: [{
+						id: "useLooseOperator",
+						range: operatorRange,
+						text: looseOperator
+					}]
+				});
+				return;
+			}
+			if (options.nullishComparisonStrictness === "triple-equals" && isLooseComparison) {
+				const strictOperator = toStrictOperator(operator);
+				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
+				context.report({
+					data: {
+						looseOperator: operator,
+						strictOperator
+					},
+					message: "preferStrictNullish",
+					range: leftIsNullish ? {
+						begin: node.left.getStart(sourceFile),
+						end: operatorRange.end
+					} : {
+						begin: operatorRange.begin,
+						end: node.right.getEnd()
+					},
+					suggestions: [{
+						id: "useStrictOperator",
+						range: operatorRange,
+						text: strictOperator
+					}]
+				});
+				return;
+			}
+			if (isLooseComparison) {
+				if (options.looseNullishComparisonStyle === "prefer-null") {
+					const leftIsUndefined = isUndefinedIdentifier(node.left);
+					const rightIsUndefined = isUndefinedIdentifier(node.right);
+					if (leftIsUndefined || rightIsUndefined) context.report({
+						fix: [{
+							range: getTSNodeRange(leftIsUndefined ? node.left : node.right, sourceFile),
+							text: "null"
+						}],
+						message: "preferLooseNull",
+						range: leftIsUndefined ? {
+							begin: node.left.getStart(sourceFile),
+							end: node.operatorToken.getEnd()
+						} : {
+							begin: node.operatorToken.getStart(sourceFile),
+							end: node.right.getEnd()
+						}
+					});
+				} else if (options.looseNullishComparisonStyle === "prefer-undefined") {
+					const leftIsNull = isNullKeyword(node.left);
+					const rightIsNull = isNullKeyword(node.right);
+					if (leftIsNull || rightIsNull) context.report({
+						fix: [{
+							range: getTSNodeRange(leftIsNull ? node.left : node.right, sourceFile),
+							text: "undefined"
+						}],
+						message: "preferLooseUndefined",
+						range: leftIsNull ? {
+							begin: node.left.getStart(sourceFile),
+							end: node.operatorToken.getEnd()
+						} : {
+							begin: node.operatorToken.getStart(sourceFile),
+							end: node.right.getEnd()
+						}
+					});
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+export { nullishCheckStyle_default as default };
+
+//# sourceMappingURL=nullishCheckStyle.js.map

package/lib/rules/nullishCoalescingOperators.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer nullish coalescing operator (??) over logical OR (||) for nullish values.";
+    readonly id: "nullishCoalescingOperators";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNullish" | "preferNullishAssignment" | "preferNullishTernary", {
+    readonly ignoreConditionalTests: z.ZodDefault<z.ZodBoolean>;
+    readonly ignoreIfStatements: z.ZodDefault<z.ZodBoolean>;
+    readonly ignoreMixedLogicalExpressions: z.ZodDefault<z.ZodBoolean>;
+    readonly ignorePrimitives: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        bigint: "bigint";
+        boolean: "boolean";
+    }>, z.ZodBoolean>]>>;
+    readonly ignoreTernaryTests: z.ZodDefault<z.ZodBoolean>;
+}>;
+export default _default;
+//# sourceMappingURL=nullishCoalescingOperators.d.ts.map