@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/isNaNComparisons.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparisons with NaN, which should use Number.isNaN() instead.";
+    readonly id: "isNaNComparisons";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useIsNaN", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=isNaNComparisons.d.ts.map

package/lib/rules/isNaNComparisons.js

@@ -0,0 +1,43 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/isNaNComparisons.ts
+const comparisonOperators = new Set([
+	SyntaxKind.EqualsEqualsEqualsToken,
+	SyntaxKind.EqualsEqualsToken,
+	SyntaxKind.ExclamationEqualsEqualsToken,
+	SyntaxKind.ExclamationEqualsToken,
+	SyntaxKind.GreaterThanEqualsToken,
+	SyntaxKind.GreaterThanToken,
+	SyntaxKind.LessThanEqualsToken,
+	SyntaxKind.LessThanToken
+]);
+var isNaNComparisons_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports comparisons with NaN, which should use Number.isNaN() instead.",
+		id: "isNaNComparisons",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { useIsNaN: {
+		primary: "Use `Number.isNaN()` instead of comparing with `NaN`.",
+		secondary: ["`NaN` is not equal to anything, including itself, so comparisons with `NaN` always return `false`."],
+		suggestions: ["Use `Number.isNaN(value)` for reliable NaN detection."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
+			if (!comparisonOperators.has(node.operatorToken.kind)) return;
+			if (isNaNIdentifier(node.left, typeChecker) || isNaNIdentifier(node.right, typeChecker)) context.report({
+				message: "useIsNaN",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+		function isNaNIdentifier(node, typeChecker) {
+			const unwrapped = unwrapParenthesizedNode(node);
+			return unwrapped.kind === SyntaxKind.Identifier && unwrapped.text === "NaN" && isGlobalDeclarationOfName(unwrapped, "NaN", typeChecker);
+		}
+	}
+});
+//#endregion
+export { isNaNComparisons_default as default };
+
+//# sourceMappingURL=isNaNComparisons.js.map

package/lib/rules/literalConstructorWrappers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefers literal syntax over constructor function calls for primitive values.";
+    readonly id: "literalConstructorWrappers";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLiteral", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=literalConstructorWrappers.d.ts.map

package/lib/rules/literalConstructorWrappers.js

@@ -0,0 +1,64 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/literalConstructorWrappers.ts
+const literalConstructors = new Set([
+	"BigInt",
+	"Boolean",
+	"Number",
+	"String"
+]);
+function isBooleanLiteral(node) {
+	return node.kind === ts$1.SyntaxKind.TrueKeyword || node.kind === ts$1.SyntaxKind.FalseKeyword;
+}
+function isLiteralArgument(node, constructorName) {
+	switch (constructorName) {
+		case "BigInt": return isNumericLiteralForBigInt(node);
+		case "Boolean": return ts$1.isLiteralExpression(node) || isBooleanLiteral(node);
+		case "Number": return ts$1.isStringLiteral(node) && isValidNumericString(node.text);
+		case "String": return ts$1.isNumericLiteral(node) || isBooleanLiteral(node) || ts$1.isBigIntLiteral(node);
+		default: return false;
+	}
+}
+function isNumericLiteralForBigInt(node) {
+	return node.kind === ts$1.SyntaxKind.NumericLiteral && /^-?\d+$/.test(node.text);
+}
+function isValidNumericString(value) {
+	const trimmed = value.trim();
+	if (trimmed === "") return false;
+	const number = Number(trimmed);
+	return !Number.isNaN(number) && Number.isFinite(number);
+}
+var literalConstructorWrappers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefers literal syntax over constructor function calls for primitive values.",
+		id: "literalConstructorWrappers",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferLiteral: {
+		primary: "Prefer literal syntax over `{{ name }}()` for creating primitive values.",
+		secondary: ["Literal syntax like `123n` for BigInt or `!!value` for Boolean is more concise and idiomatic.", "Constructor calls can be replaced with operators or template literals."],
+		suggestions: ["Use literal syntax instead of `{{ name }}()`."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts$1.isIdentifier(node.expression)) return;
+			const name = node.expression.text;
+			if (!literalConstructors.has(name) || node.arguments.length !== 1 || !isGlobalDeclarationOfName(node.expression, name, typeChecker)) return;
+			const argument = node.arguments[0];
+			if (!isLiteralArgument(argument, name)) return;
+			context.report({
+				data: { name },
+				message: "preferLiteral",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.expression.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { literalConstructorWrappers_default as default };
+
+//# sourceMappingURL=literalConstructorWrappers.js.map

package/lib/rules/mathMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer modern Math methods over legacy patterns.";
+    readonly id: "mathMethods";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferModernMath", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=mathMethods.d.ts.map

package/lib/rules/mathMethods.js

@@ -0,0 +1,128 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { skipParentheses } from "./utils/skipParentheses.js";
+import { getTSNodeRange, hasSameTokens, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/mathMethods.ts
+function checkLogDivideConstant(node, typeChecker, constantName, replacementMethod) {
+	if (node.operatorToken.kind !== SyntaxKind.SlashToken) return;
+	const left = skipParentheses(node.left);
+	const right = skipParentheses(node.right);
+	if (getMathMethodArgument(left, "log", typeChecker) && isMathProperty(right, constantName, typeChecker)) return {
+		description: `Math.log(…) / Math.${constantName}`,
+		replacement: `Math.${replacementMethod}(…)`
+	};
+}
+function checkLogTimesConstant(node, typeChecker, constantName, replacementMethod) {
+	if (node.operatorToken.kind !== SyntaxKind.AsteriskToken) return;
+	const left = skipParentheses(node.left);
+	const right = skipParentheses(node.right);
+	if (getMathMethodArgument(left, "log", typeChecker) && isMathProperty(right, constantName, typeChecker)) return {
+		description: `Math.log(…) * Math.${constantName}`,
+		replacement: `Math.${replacementMethod}(…)`
+	};
+	if (isMathProperty(left, constantName, typeChecker) && getMathMethodArgument(right, "log", typeChecker)) return {
+		description: `Math.${constantName} * Math.log(…)`,
+		replacement: `Math.${replacementMethod}(…)`
+	};
+}
+function flattenPlusExpression(node) {
+	const unwrapped = skipParentheses(node);
+	if (unwrapped.kind === SyntaxKind.BinaryExpression && unwrapped.operatorToken.kind === SyntaxKind.PlusToken) return [...flattenPlusExpression(unwrapped.left), ...flattenPlusExpression(unwrapped.right)];
+	return [unwrapped];
+}
+function getMathMethodArgument(node, methodName, typeChecker) {
+	if (node.kind !== SyntaxKind.CallExpression || node.questionDotToken || node.arguments.length !== 1) return false;
+	const argument = node.arguments[0];
+	if (argument.kind === SyntaxKind.SpreadElement || !isMathProperty(node.expression, methodName, typeChecker)) return;
+	return argument;
+}
+function isMathProperty(node, propertyName, typeChecker) {
+	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === propertyName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker);
+}
+function isPowerTwoExpression(node, sourceFile) {
+	const unwrapped = skipParentheses(node);
+	if (unwrapped.kind !== SyntaxKind.BinaryExpression) return false;
+	if (unwrapped.operatorToken.kind === SyntaxKind.AsteriskToken) return hasSameTokens(unwrapped.left, unwrapped.right, sourceFile);
+	if (unwrapped.operatorToken.kind === SyntaxKind.AsteriskAsteriskToken) {
+		const right = skipParentheses(unwrapped.right);
+		return right.kind === SyntaxKind.NumericLiteral && right.text === "2";
+	}
+	return false;
+}
+var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer modern Math methods over legacy patterns.",
+		id: "mathMethods",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferModernMath: {
+		primary: "Prefer `{{ replacement }}` over `{{ description }}`.",
+		secondary: ["Modern Math methods are clearer and more explicit about their purpose.", "These methods have been available since ES2015 and are well-supported in all modern environments."],
+		suggestions: ["Replace the legacy pattern with the modern Math method."]
+	} },
+	setup(context) {
+		return { visitors: {
+			BinaryExpression: (node, { sourceFile, typeChecker }) => {
+				for (const { constantName, replacementMethod } of [{
+					constantName: "LOG10E",
+					replacementMethod: "log10"
+				}, {
+					constantName: "LOG2E",
+					replacementMethod: "log2"
+				}]) {
+					const match = checkLogTimesConstant(node, typeChecker, constantName, replacementMethod);
+					if (match) {
+						context.report({
+							data: {
+								description: match.description,
+								replacement: match.replacement
+							},
+							message: "preferModernMath",
+							range: getTSNodeRange(node, sourceFile)
+						});
+						return;
+					}
+				}
+				for (const { constantName, replacementMethod } of [{
+					constantName: "LN10",
+					replacementMethod: "log10"
+				}, {
+					constantName: "LN2",
+					replacementMethod: "log2"
+				}]) {
+					const match = checkLogDivideConstant(node, typeChecker, constantName, replacementMethod);
+					if (match) {
+						context.report({
+							data: {
+								description: match.description,
+								replacement: match.replacement
+							},
+							message: "preferModernMath",
+							range: getTSNodeRange(node, sourceFile)
+						});
+						return;
+					}
+				}
+			},
+			CallExpression: (node, { sourceFile, typeChecker }) => {
+				const argument = getMathMethodArgument(node, "sqrt", typeChecker);
+				if (!argument) return;
+				const expressions = flattenPlusExpression(argument);
+				if (!expressions.every((expr) => isPowerTwoExpression(expr, sourceFile))) return;
+				const replacementMethod = expressions.length === 1 ? "abs" : "hypot";
+				context.report({
+					data: {
+						description: "Math.sqrt(…)",
+						replacement: `Math.${replacementMethod}(…)`
+					},
+					message: "preferModernMath",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { mathMethods_default as default };
+
+//# sourceMappingURL=mathMethods.js.map

package/lib/rules/meaninglessVoidOperators.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the void operator on expressions that are already void or undefined.";
+    readonly id: "meaninglessVoidOperators";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "meaninglessVoid", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=meaninglessVoidOperators.d.ts.map

package/lib/rules/meaninglessVoidOperators.js

@@ -0,0 +1,39 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/meaninglessVoidOperators.ts
+function isVoidOrUndefinedType(type) {
+	return tsutils.isTypeFlagSet(type, ts.TypeFlags.Void | ts.TypeFlags.Undefined);
+}
+var meaninglessVoidOperators_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the void operator on expressions that are already void or undefined.",
+		id: "meaninglessVoidOperators",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { meaninglessVoid: {
+		primary: "Using the `void` operator on a value of type `{{ type }}` does nothing.",
+		secondary: ["The `void` operator is meant to discard a return value and produce `undefined`.", "Applying `void` to a value that is already `void` or `undefined` has no effect."],
+		suggestions: ["Remove the `void` operator.", "If you need to explicitly return `undefined`, use the value directly."]
+	} },
+	setup(context) {
+		return { visitors: { VoidExpression: (node, { sourceFile, typeChecker }) => {
+			const argumentType = getConstrainedTypeAtLocation(node.expression, typeChecker);
+			if (!tsutils.unionConstituents(argumentType).every(isVoidOrUndefinedType)) return;
+			context.report({
+				data: { type: typeChecker.typeToString(argumentType) },
+				message: "meaninglessVoid",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { meaninglessVoidOperators_default as default };
+
+//# sourceMappingURL=meaninglessVoidOperators.js.map

package/lib/rules/misleadingVoidExpressions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Require expressions of type void to appear in statement position.";
+    readonly id: "misleadingVoidExpressions";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "voidExpressionArrow" | "voidExpressionReturn" | "voidExpressionValue", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=misleadingVoidExpressions.d.ts.map

package/lib/rules/misleadingVoidExpressions.js

@@ -0,0 +1,128 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/misleadingVoidExpressions.ts
+function getParentFunction(node) {
+	let current = node.parent;
+	while (current) {
+		if (ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isMethodDeclaration(current)) return current;
+		current = current.parent;
+	}
+}
+function isInValidPosition(node) {
+	if (ts$1.isExpressionStatement(node.parent)) return { valid: true };
+	if (ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.CommaToken) {
+		if (node.parent.right === node) return isInValidPosition(node.parent);
+		return { valid: true };
+	}
+	if (ts$1.isParenthesizedExpression(node.parent)) return isInValidPosition(node.parent);
+	if (ts$1.isConditionalExpression(node.parent) && (node.parent.whenTrue === node || node.parent.whenFalse === node)) return isInValidPosition(node.parent);
+	if (ts$1.isBinaryExpression(node.parent) && (node.parent.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken || node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken || node.parent.operatorToken.kind === ts$1.SyntaxKind.QuestionQuestionToken) && node.parent.right === node) return isInValidPosition(node.parent);
+	if (ts$1.isVoidExpression(node.parent)) return { valid: true };
+	if (ts$1.isArrowFunction(node.parent) && node.parent.body === node) return {
+		invalidAncestor: node.parent,
+		valid: false
+	};
+	if (ts$1.isReturnStatement(node.parent)) return {
+		invalidAncestor: node.parent,
+		valid: false
+	};
+	return {
+		invalidAncestor: node,
+		valid: false
+	};
+}
+function isVoidLike(type) {
+	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.VoidLike);
+}
+var misleadingVoidExpressions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Require expressions of type void to appear in statement position.",
+		id: "misleadingVoidExpressions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		voidExpressionArrow: {
+			primary: "Returning a void expression from an arrow function shorthand is misleading.",
+			secondary: ["Arrow function shorthand returns a value, but void expressions are meant to be ignored.", "This can confuse readers who expect a meaningful return value."],
+			suggestions: ["Add braces to the arrow function to make the void expression a statement."]
+		},
+		voidExpressionReturn: {
+			primary: "Returning a void expression from a function is misleading.",
+			secondary: ["Return statements imply a value is being returned, but void expressions have no meaningful value.", "This can confuse readers about the function's intent."],
+			suggestions: ["Move the void expression before the return statement.", "Remove the return keyword if this is the last statement."]
+		},
+		voidExpressionValue: {
+			primary: "Void expressions should not be used as values.",
+			secondary: ["A `void` expression evaluates to `undefined` but its intent is to be ignored.", "Using void expressions as values can lead to confusing code and potential bugs."],
+			suggestions: ["Move the void expression to its own statement.", "Wrap with `void` operator to indicate the value is intentionally ignored."]
+		}
+	},
+	setup(context) {
+		function checkVoidExpression(node, { sourceFile, typeChecker }) {
+			if (!isVoidLike(getConstrainedTypeAtLocation(node, typeChecker))) return;
+			const positionResult = isInValidPosition(node);
+			if (positionResult.valid) return;
+			const { invalidAncestor } = positionResult;
+			if (ts$1.isArrowFunction(invalidAncestor)) {
+				const arrowBodyText = sourceFile.text.slice(invalidAncestor.body.getStart(sourceFile), invalidAncestor.body.getEnd());
+				const nodeText = sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
+				context.report({
+					message: "voidExpressionArrow",
+					range: getTSNodeRange(node, sourceFile),
+					suggestions: [{
+						id: "addBraces",
+						range: getTSNodeRange(invalidAncestor.body, sourceFile),
+						text: `{ ${arrowBodyText}; }`
+					}, {
+						id: "wrapWithVoid",
+						range: getTSNodeRange(node, sourceFile),
+						text: `void ${nodeText}`
+					}]
+				});
+				return;
+			}
+			const nodeText = sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
+			const suggestionBase = {
+				id: "wrapWithVoid",
+				range: getTSNodeRange(node, sourceFile),
+				text: `void ${nodeText}`
+			};
+			if (!ts$1.isReturnStatement(invalidAncestor)) {
+				context.report({
+					message: "voidExpressionValue",
+					range: getTSNodeRange(node, sourceFile),
+					suggestions: [suggestionBase]
+				});
+				return;
+			}
+			const functionNode = getParentFunction(invalidAncestor);
+			const isLastStatement = functionNode && ts$1.isBlock(invalidAncestor.parent) && invalidAncestor.parent.parent === functionNode && invalidAncestor.parent.statements.at(-1) === invalidAncestor;
+			const returnValueText = invalidAncestor.expression ? sourceFile.text.slice(invalidAncestor.expression.getStart(sourceFile), invalidAncestor.expression.getEnd()) : "";
+			context.report({
+				message: "voidExpressionReturn",
+				range: getTSNodeRange(node, sourceFile),
+				suggestions: [isLastStatement ? {
+					id: "removeReturn",
+					range: getTSNodeRange(invalidAncestor, sourceFile),
+					text: `${returnValueText};`
+				} : {
+					id: "moveBeforeReturn",
+					range: getTSNodeRange(invalidAncestor, sourceFile),
+					text: `${returnValueText}; return;`
+				}, suggestionBase]
+			});
+		}
+		return { visitors: {
+			AwaitExpression: checkVoidExpression,
+			CallExpression: checkVoidExpression,
+			TaggedTemplateExpression: checkVoidExpression
+		} };
+	}
+});
+//#endregion
+export { misleadingVoidExpressions_default as default };
+
+//# sourceMappingURL=misleadingVoidExpressions.js.map

package/lib/rules/moduleSpecifierLists.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Require non-empty specifier lists in import and export statements.";
+    readonly id: "moduleSpecifierLists";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyExportSpecifiers" | "emptyImportSpecifiers", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=moduleSpecifierLists.d.ts.map

package/lib/rules/moduleSpecifierLists.js

@@ -0,0 +1,92 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/moduleSpecifierLists.ts
+function hasNamedBindings(node) {
+	const namedBindings = node.importClause?.namedBindings;
+	if (!namedBindings) return false;
+	return !ts$1.isNamedImports(namedBindings) || !!namedBindings.elements.length;
+}
+function hasNamespaceImport(node) {
+	const namedBindings = node.importClause?.namedBindings;
+	return namedBindings && ts$1.isNamespaceImport(namedBindings);
+}
+function isEmptyNamedImports(node) {
+	const namedBindings = node.importClause?.namedBindings;
+	return namedBindings && ts$1.isNamedImports(namedBindings) && !namedBindings.elements.length;
+}
+var moduleSpecifierLists_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Require non-empty specifier lists in import and export statements.",
+		id: "moduleSpecifierLists",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		emptyExportSpecifiers: {
+			primary: "Export statement with empty specifier list is unnecessary.",
+			secondary: ["Empty export braces serve no purpose and can be removed.", "If re-exporting from a module, ensure you specify what to export."],
+			suggestions: ["Remove the empty export statement."]
+		},
+		emptyImportSpecifiers: {
+			primary: "Import statement with empty specifier list is unnecessary.",
+			secondary: ["Empty import braces serve no purpose and can confuse readers.", "Use a side-effect import if you only need to run the module's code."],
+			suggestions: ["Remove the empty braces or convert to a side-effect import."]
+		}
+	},
+	setup(context) {
+		function createExportSuggestions(moduleSpecifier, node, sourceFile) {
+			const moduleSpecifierText = sourceFile.text.slice(moduleSpecifier.getStart(sourceFile), moduleSpecifier.getEnd());
+			return [{
+				id: "removeStatement",
+				range: getTSNodeRange(node, sourceFile),
+				text: ""
+			}, ...moduleSpecifierText ? [{
+				id: "convertToSideEffectImport",
+				range: getTSNodeRange(node, sourceFile),
+				text: `import ${moduleSpecifierText};`
+			}] : []];
+		}
+		function createImportSuggestions(importClause, node, sourceFile) {
+			const moduleSpecifier = sourceFile.text.slice(node.moduleSpecifier.getStart(sourceFile), node.moduleSpecifier.getEnd());
+			if (importClause.name) {
+				const defaultImportName = importClause.name.getText(sourceFile);
+				return [{
+					id: "removeEmptyBraces",
+					range: getTSNodeRange(node, sourceFile),
+					text: `import ${defaultImportName} from ${moduleSpecifier};`
+				}];
+			}
+			return [{
+				id: "removeStatement",
+				range: getTSNodeRange(node, sourceFile),
+				text: ""
+			}, ...importClause.phaseModifier === ts$1.SyntaxKind.TypeKeyword ? [] : [{
+				id: "convertToSideEffectImport",
+				range: getTSNodeRange(node, sourceFile),
+				text: `import ${moduleSpecifier};`
+			}]];
+		}
+		return { visitors: {
+			ExportDeclaration: (node, { sourceFile }) => {
+				if (node.moduleSpecifier === void 0 || !ts$1.isExportDeclaration(node) || !node.exportClause || !ts$1.isNamedExports(node.exportClause) || !!node.exportClause.elements.length) return;
+				context.report({
+					message: "emptyExportSpecifiers",
+					range: getTSNodeRange(node, sourceFile),
+					suggestions: createExportSuggestions(node.moduleSpecifier, node, sourceFile)
+				});
+			},
+			ImportDeclaration: (node, { sourceFile }) => {
+				if (hasNamedBindings(node) || hasNamespaceImport(node) || !isEmptyNamedImports(node) || !node.importClause) return;
+				context.report({
+					message: "emptyImportSpecifiers",
+					range: getTSNodeRange(node.importClause.namedBindings ?? node.importClause, sourceFile),
+					suggestions: createImportSuggestions(node.importClause, node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { moduleSpecifierLists_default as default };
+
+//# sourceMappingURL=moduleSpecifierLists.js.map

package/lib/rules/multilineAmbiguities.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports ambiguous multiline expressions that could be misinterpreted.";
+    readonly id: "multilineAmbiguities";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "ambiguity", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=multilineAmbiguities.d.ts.map

package/lib/rules/multilineAmbiguities.js

@@ -0,0 +1,64 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/multilineAmbiguities.ts
+var multilineAmbiguities_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ambiguous multiline expressions that could be misinterpreted.",
+		id: "multilineAmbiguities",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { ambiguity: {
+		primary: "This ambiguous line break before {{ after }} will be misinterpreted as a {{ interpretation }}.",
+		secondary: ["When a line ends with an expression and the next line starts with {{ after }}, it may be interpreted as a {{ interpretation }} instead of two separate statements.", "This can lead to unexpected behavior and runtime errors that are difficult to debug."],
+		suggestions: ["Add a semicolon after the first line to make it clear they are separate statements.", "Alternatively, move the {{ after }} to the same line as the first expression if a {{ interpretation }} is intended."]
+	} },
+	setup(context) {
+		function checkMultilineDelimiter(expressionEnd, delimiterStart, after, interpretation, sourceFile) {
+			const { line: expressionEndLine } = sourceFile.getLineAndCharacterOfPosition(expressionEnd);
+			const { line: delimiterLine } = sourceFile.getLineAndCharacterOfPosition(delimiterStart);
+			if (expressionEndLine < delimiterLine) context.report({
+				data: {
+					after,
+					interpretation
+				},
+				message: "ambiguity",
+				range: {
+					begin: delimiterStart,
+					end: getLineEndPosition(delimiterLine, sourceFile)
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: (node, { sourceFile }) => {
+				if (!node.arguments.length || node.questionDotToken) return;
+				const openParen = findChildToken(node, ts$1.SyntaxKind.OpenParenToken, sourceFile);
+				if (!openParen) return;
+				checkMultilineDelimiter(getExpressionEnd(node, sourceFile), openParen.getStart(sourceFile), "parentheses", "function call", sourceFile);
+			},
+			ElementAccessExpression: (node, { sourceFile }) => {
+				if (node.questionDotToken) return;
+				const openBracket = findChildToken(node, ts$1.SyntaxKind.OpenBracketToken, sourceFile);
+				if (!openBracket) return;
+				checkMultilineDelimiter(node.expression.getEnd(), openBracket.getStart(sourceFile), "brackets", "property access", sourceFile);
+			},
+			TaggedTemplateExpression: (node, { sourceFile }) => {
+				checkMultilineDelimiter(node.tag.getEnd(), node.template.getStart(sourceFile), "a template literal", "tagged template", sourceFile);
+			}
+		} };
+	}
+});
+function findChildToken(node, kind, sourceFile) {
+	for (const child of node.getChildren(sourceFile)) if (child.kind === kind) return child;
+}
+function getExpressionEnd(node, sourceFile) {
+	return (node.typeArguments && findChildToken(node, ts$1.SyntaxKind.GreaterThanToken, sourceFile))?.getEnd() ?? node.expression.getEnd();
+}
+function getLineEndPosition(lineNumber, sourceFile) {
+	const nextLineStart = sourceFile.getLineStarts()[lineNumber + 1];
+	return nextLineStart === void 0 ? sourceFile.getEnd() : nextLineStart - 1;
+}
+//#endregion
+export { multilineAmbiguities_default as default };
+
+//# sourceMappingURL=multilineAmbiguities.js.map

package/lib/rules/namedDefaultExports.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports anonymous functions and classes as the default export.";
+    readonly id: "namedDefaultExports";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "anonymousClass" | "anonymousFunction", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=namedDefaultExports.d.ts.map