@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/globalAssignments.js

@@ -1,60 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalVariable } from "../utils/isGlobalVariable.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
-        id: "globalAssignments",
-        preset: "untyped",
-    },
-    messages: {
-        noGlobalAssign: {
-            primary: "Read-only global variables should not be reassigned or modified.",
-            secondary: [
-                "Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
-                "Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
-                "In strict mode, reassigning these globals will throw a TypeError at runtime.",
-            ],
-            suggestions: [
-                "Use a different variable name instead of shadowing or reassigning globals.",
-                "If you need a similar name, consider using a more specific name that doesn't conflict with global variables.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                BinaryExpression: (node, { sourceFile, typeChecker }) => {
-                    if (tsutils.isAssignmentKind(node.operatorToken.kind) &&
-                        isGlobalVariable(node.left, typeChecker)) {
-                        context.report({
-                            message: "noGlobalAssign",
-                            range: getTSNodeRange(node.left, sourceFile),
-                        });
-                    }
-                },
-                PostfixUnaryExpression: (node, { sourceFile, typeChecker }) => {
-                    if (isGlobalVariable(node.operand, typeChecker)) {
-                        context.report({
-                            message: "noGlobalAssign",
-                            range: getTSNodeRange(node.operand, sourceFile),
-                        });
-                    }
-                },
-                PrefixUnaryExpression: (node, { sourceFile, typeChecker }) => {
-                    if ((node.operator === ts.SyntaxKind.PlusPlusToken ||
-                        node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                        isGlobalVariable(node.operand, typeChecker)) {
-                        context.report({
-                            message: "noGlobalAssign",
-                            range: getTSNodeRange(node.operand, sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+//#region src/rules/globalAssignments.ts
+var globalAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
+		id: "globalAssignments",
+		presets: ["javascript"]
+	},
+	messages: { noGlobalAssign: {
+		primary: "Read-only global variables should not be reassigned or modified.",
+		secondary: [
+			"Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
+			"Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
+			"In strict mode, reassigning these globals will throw a TypeError at runtime."
+		],
+		suggestions: ["Use a different variable name instead of shadowing or reassigning globals.", "If you need a similar name, consider using a more specific name that doesn't conflict with global variables."]
+	} },
+	setup(context) {
+		return { visitors: {
+			BinaryExpression: (node, { sourceFile, typeChecker }) => {
+				if (tsutils.isAssignmentKind(node.operatorToken.kind) && isGlobalVariable(node.left, typeChecker)) context.report({
+					message: "noGlobalAssign",
+					range: getTSNodeRange(node.left, sourceFile)
+				});
+			},
+			PostfixUnaryExpression: (node, { sourceFile, typeChecker }) => {
+				if (isGlobalVariable(node.operand, typeChecker)) context.report({
+					message: "noGlobalAssign",
+					range: getTSNodeRange(node.operand, sourceFile)
+				});
+			},
+			PrefixUnaryExpression: (node, { sourceFile, typeChecker }) => {
+				if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) && isGlobalVariable(node.operand, typeChecker)) context.report({
+					message: "noGlobalAssign",
+					range: getTSNodeRange(node.operand, sourceFile)
+				});
+			}
+		} };
+	}
 });
+//#endregion
+export { globalAssignments_default as default };
+
 //# sourceMappingURL=globalAssignments.js.map

package/lib/rules/globalObjectCalls.d.ts

@@ -1,8 +1,10 @@
-import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
     readonly id: "globalObjectCalls";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "noGlobalObjectCall", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noGlobalObjectCall", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=globalObjectCalls.d.ts.map

package/lib/rules/globalObjectCalls.js

@@ -1,44 +1,42 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-const globalObjects = new Set(["Atomics", "JSON", "Math", "Reflect"]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports calling global objects like Math, JSON, or Reflect as functions.",
-        id: "globalObjectCalls",
-        preset: "untyped",
-    },
-    messages: {
-        noGlobalObjectCall: {
-            primary: "{{ name }} is not a function and cannot be called directly.",
-            secondary: [
-                "{{ name }} is a built-in global object that provides utility methods and properties.",
-                "It is not a constructor or function and cannot be called or instantiated.",
-            ],
-            suggestions: [
-                "Use the static methods available on {{ name }} instead (e.g., {{ name }}.methodName()).",
-            ],
-        },
-    },
-    setup(context) {
-        function reportGlobalObjectCall(expression, name, sourceFile) {
-            context.report({
-                data: { name },
-                message: "noGlobalObjectCall",
-                range: getTSNodeRange(expression, sourceFile),
-            });
-        }
-        function checkNode({ expression }, { sourceFile }) {
-            if (ts.isIdentifier(expression) && globalObjects.has(expression.text)) {
-                reportGlobalObjectCall(expression, expression.text, sourceFile);
-            }
-        }
-        return {
-            visitors: {
-                CallExpression: checkNode,
-                NewExpression: checkNode,
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/globalObjectCalls.ts
+const globalObjects = new Set([
+	"Atomics",
+	"JSON",
+	"Math",
+	"Reflect"
+]);
+var globalObjectCalls_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports calling global objects like Math, JSON, or Reflect as functions.",
+		id: "globalObjectCalls",
+		presets: ["javascript"]
+	},
+	messages: { noGlobalObjectCall: {
+		primary: "{{ name }} is not a function and cannot be called directly.",
+		secondary: ["{{ name }} is a built-in global object that provides utility methods and properties.", "It is not a constructor or function and cannot be called or instantiated."],
+		suggestions: ["Use the static methods available on {{ name }} instead (e.g., {{ name }}.methodName())."]
+	} },
+	setup(context) {
+		function reportGlobalObjectCall(expression, name, sourceFile) {
+			context.report({
+				data: { name },
+				message: "noGlobalObjectCall",
+				range: getTSNodeRange(expression, sourceFile)
+			});
+		}
+		function checkNode({ expression }, { sourceFile }) {
+			if (expression.kind === SyntaxKind.Identifier && globalObjects.has(expression.text)) reportGlobalObjectCall(expression, expression.text, sourceFile);
+		}
+		return { visitors: {
+			CallExpression: checkNode,
+			NewExpression: checkNode
+		} };
+	}
 });
+//#endregion
+export { globalObjectCalls_default as default };
+
 //# sourceMappingURL=globalObjectCalls.js.map

package/lib/rules/globalThisAliases.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using window, self, or global instead of globalThis.";
+    readonly id: "globalThisAliases";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferGlobalThis", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=globalThisAliases.d.ts.map

package/lib/rules/globalThisAliases.js

@@ -0,0 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/globalThisAliases.ts
+const globalAliases = new Set([
+	"global",
+	"self",
+	"window"
+]);
+function isOnlyGlobalDeclaration(node, typeChecker) {
+	const symbol = typeChecker.getSymbolAtLocation(node);
+	if (!symbol) return false;
+	const declarations = symbol.getDeclarations();
+	if (!declarations?.length) return false;
+	return declarations.every(declarationIncludesGlobal);
+}
+function isPropertyAccess(node) {
+	return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+}
+function isPropertyShorthand(node) {
+	return ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+}
+var globalThisAliases_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using window, self, or global instead of globalThis.",
+		id: "globalThisAliases",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferGlobalThis: {
+		primary: "Prefer the standard `globalThis` over the platform-specific `{{ name }}` for accessing the global object.",
+		secondary: ["`globalThis` is the standard way to access the global object across all JavaScript environments.", "Using `window`, `self`, or `global` ties your code to specific environments (browser, web worker, or Node.js)."],
+		suggestions: ["Replace `{{ name }}` with `globalThis`."]
+	} },
+	setup(context) {
+		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
+			if (globalAliases.has(node.text) && !isPropertyAccess(node) && !isPropertyShorthand(node) && isOnlyGlobalDeclaration(node, typeChecker)) context.report({
+				data: { name: node.text },
+				message: "preferGlobalThis",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { globalThisAliases_default as default };
+
+//# sourceMappingURL=globalThisAliases.js.map

package/lib/rules/impliedEvals.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.";
+    readonly id: "impliedEvals";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "functionConstructor" | "impliedEval", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=impliedEvals.d.ts.map

package/lib/rules/impliedEvals.js

@@ -0,0 +1,130 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isBuiltinSymbolLike } from "./utils/isBuiltinSymbolLike.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/impliedEvals.ts
+const globalCandidates = new Set([
+	"global",
+	"globalThis",
+	"window"
+]);
+const evalLikeFunctions = new Set([
+	"execScript",
+	"setImmediate",
+	"setInterval",
+	"setTimeout"
+]);
+function getCalleeName(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.ElementAccessExpression:
+			if (ts$1.isIdentifier(node.expression) && globalCandidates.has(node.expression.text) && ts$1.isStringLiteral(node.argumentExpression)) return node.argumentExpression.text;
+			break;
+		case ts$1.SyntaxKind.Identifier: return node.text;
+		case ts$1.SyntaxKind.PropertyAccessExpression:
+			if (ts$1.isIdentifier(node.expression) && globalCandidates.has(node.expression.text)) return node.name.text;
+			break;
+	}
+}
+function isBind(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.Identifier: return node.text === "bind";
+		case ts$1.SyntaxKind.PropertyAccessExpression: return isBind(node.name);
+		default: return false;
+	}
+}
+function isDefinitelyString(type) {
+	if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown | ts$1.TypeFlags.Never)) return false;
+	if (type.isUnion()) return type.types.every(isDefinitelyString);
+	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.StringLike);
+}
+function isFunction$1(node, typeChecker, program) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.ArrowFunction:
+		case ts$1.SyntaxKind.FunctionDeclaration:
+		case ts$1.SyntaxKind.FunctionExpression: return true;
+		case ts$1.SyntaxKind.CallExpression:
+			if (isBind(node.expression)) return true;
+			return !isDefinitelyString(typeChecker.getTypeAtLocation(node)) && isFunctionType(node, typeChecker, program);
+		case ts$1.SyntaxKind.NoSubstitutionTemplateLiteral:
+		case ts$1.SyntaxKind.StringLiteral:
+		case ts$1.SyntaxKind.TemplateExpression: return false;
+		default: return !isDefinitelyString(typeChecker.getTypeAtLocation(node)) && isFunctionType(node, typeChecker, program);
+	}
+}
+function isFunctionType(node, typeChecker, program) {
+	const type = typeChecker.getTypeAtLocation(node);
+	if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown) || isBuiltinSymbolLike(program, type, "Function")) return true;
+	const symbol = type.getSymbol();
+	if (symbol && tsutils.isSymbolFlagSet(symbol, ts$1.SymbolFlags.Function | ts$1.SymbolFlags.Method)) return true;
+	return !!typeChecker.getSignaturesOfType(type, ts$1.SignatureKind.Call).length;
+}
+function isReferenceToGlobalFunction(node, typeChecker) {
+	if (ts$1.isPropertyAccessExpression(node.expression) || ts$1.isElementAccessExpression(node.expression)) return true;
+	const symbol = typeChecker.getSymbolAtLocation(node.expression);
+	if (!symbol) return true;
+	return !!symbol.getDeclarations()?.some((declaration) => {
+		const sourceFile = declaration.getSourceFile();
+		return sourceFile.hasNoDefaultLib || sourceFile.fileName.includes("node_modules/@types/node/") || /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName);
+	});
+}
+var impliedEvals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.",
+		id: "impliedEvals",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		functionConstructor: {
+			primary: "Avoid using the unsafe Function constructor to create functions.",
+			secondary: ["The Function constructor evaluates strings as code, similar to eval().", "This makes the code harder to analyze, optimize, and can introduce security vulnerabilities."],
+			suggestions: ["Use a function expression or arrow function instead."]
+		},
+		impliedEval: {
+			primary: "Avoid passing unsafe strings to {{ name }}; pass a function instead.",
+			secondary: ["Passing a string to {{ name }} causes it to be evaluated as code, similar to eval().", "This makes the code harder to analyze, optimize, and can introduce security vulnerabilities."],
+			suggestions: ["Pass a function expression or arrow function as the first argument."]
+		}
+	},
+	setup(context) {
+		function checkCalleeFunction(node, { program, sourceFile, typeChecker }) {
+			if (!node.arguments?.length) return;
+			if (!isBuiltinSymbolLike(program, typeChecker.getTypeAtLocation(node.expression), "FunctionConstructor")) return;
+			context.report({
+				message: "functionConstructor",
+				range: getTSNodeRange(node.expression, sourceFile)
+			});
+		}
+		function checkCalleeEval(node, calleeName, { program, sourceFile, typeChecker }) {
+			const args = node.arguments;
+			if (!args?.length) return;
+			const handler = args[0];
+			if (!evalLikeFunctions.has(calleeName) || isFunction$1(handler, typeChecker, program) || !isReferenceToGlobalFunction(node, typeChecker)) return;
+			context.report({
+				data: { name: calleeName },
+				message: "impliedEval",
+				range: getTSNodeRange(handler, sourceFile)
+			});
+		}
+		function checkNode(node, services) {
+			const calleeName = getCalleeName(node.expression);
+			switch (calleeName) {
+				case "Function":
+					checkCalleeFunction(node, services);
+					break;
+				case void 0: return;
+				default:
+					checkCalleeEval(node, calleeName, services);
+					break;
+			}
+		}
+		return { visitors: {
+			CallExpression: checkNode,
+			NewExpression: checkNode
+		} };
+	}
+});
+//#endregion
+export { impliedEvals_default as default };
+
+//# sourceMappingURL=impliedEvals.js.map

package/lib/rules/importEmptyBlocks.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty named import blocks.";
+    readonly id: "importEmptyBlocks";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noEmptyNamedBlocksOnly" | "noEmptyNamedBlocksWithOther", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=importEmptyBlocks.d.ts.map

package/lib/rules/importEmptyBlocks.js

@@ -0,0 +1,53 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/importEmptyBlocks.ts
+var importEmptyBlocks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty named import blocks.",
+		id: "importEmptyBlocks",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		noEmptyNamedBlocksOnly: {
+			primary: "Empty named import blocks are unnecessary.",
+			secondary: ["An empty `{ }` in an import statement has no effect and can be removed."],
+			suggestions: ["Remove the entire import statement.", "Convert to a side-effect only import."]
+		},
+		noEmptyNamedBlocksWithOther: {
+			primary: "Empty named import blocks are unnecessary.",
+			secondary: ["An empty `{ }` in an import statement has no effect and can be removed."],
+			suggestions: ["Remove the empty block."]
+		}
+	},
+	setup(context) {
+		return { visitors: { ImportDeclaration: (node, { sourceFile }) => {
+			if (!node.importClause?.namedBindings || !ts.isNamedImports(node.importClause.namedBindings) || node.importClause.namedBindings.elements.length) return;
+			if (!node.importClause.name) context.report({
+				fix: {
+					range: getTSNodeRange(node, sourceFile),
+					text: `import ${node.moduleSpecifier.getText(sourceFile)};`
+				},
+				message: "noEmptyNamedBlocksOnly",
+				range: getTSNodeRange(node.importClause.namedBindings, sourceFile)
+			});
+			const commaToken = node.importClause.getChildren(sourceFile).find((child) => child.kind === ts.SyntaxKind.CommaToken);
+			if (!commaToken) return;
+			context.report({
+				fix: {
+					range: {
+						begin: commaToken.getStart(sourceFile),
+						end: node.importClause.namedBindings.getEnd()
+					},
+					text: ""
+				},
+				message: "noEmptyNamedBlocksWithOther",
+				range: getTSNodeRange(node.importClause.namedBindings, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { importEmptyBlocks_default as default };
+
+//# sourceMappingURL=importEmptyBlocks.js.map

package/lib/rules/importTypeSideEffects.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.";
+    readonly id: "importTypeSideEffects";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useTopLevelQualifier", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=importTypeSideEffects.d.ts.map

package/lib/rules/importTypeSideEffects.js

@@ -0,0 +1,31 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/importTypeSideEffects.ts
+var importTypeSideEffects_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.",
+		id: "importTypeSideEffects",
+		presets: ["logical"]
+	},
+	messages: { useTopLevelQualifier: {
+		primary: "Every specifier in this import is a type, so a single top-level `import type` would be cleaner.",
+		secondary: ["When all specifiers in an import have inline `type` qualifiers, TypeScript's `verbatimModuleSyntax` leaves behind an empty import statement.", "This creates an unnecessary side-effect import at runtime."],
+		suggestions: ["Replace `import { type A, type B }` with `import type { A, B }`."]
+	} },
+	setup(context) {
+		return { visitors: { ImportDeclaration: (node, { sourceFile }) => {
+			if (!node.importClause || node.importClause.name || node.importClause.phaseModifier === SyntaxKind.TypeKeyword) return;
+			const namedBindings = node.importClause.namedBindings;
+			if (!namedBindings || !ts.isNamedImports(namedBindings) || !namedBindings.elements.length || namedBindings.elements.some((element) => !element.isTypeOnly)) return;
+			context.report({
+				message: "useTopLevelQualifier",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { importTypeSideEffects_default as default };
+
+//# sourceMappingURL=importTypeSideEffects.js.map

package/lib/rules/indexedObjectTypes.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports indexed object types that don't match the configured style.";
+    readonly id: "indexedObjectTypes";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferIndexSignature" | "preferRecord", {
+    readonly style: z.ZodDefault<z.ZodEnum<{
+        record: "record";
+        "index-signature": "index-signature";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=indexedObjectTypes.d.ts.map

package/lib/rules/indexedObjectTypes.js

@@ -0,0 +1,83 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/indexedObjectTypes.ts
+function getSingleIndexSignature(members) {
+	if (members.length !== 1) return;
+	const member = members[0];
+	if (member.kind !== ts$1.SyntaxKind.IndexSignature) return;
+	return member;
+}
+function getTypeName(node) {
+	if (node.kind === ts$1.SyntaxKind.InterfaceDeclaration) return node.name.text;
+	let current = node.parent;
+	while (current) {
+		if (ts$1.isTypeAliasDeclaration(current)) return current.name.text;
+		current = current.parent;
+	}
+}
+function isDirectlyRecursive(node, parentTypeName) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.ConditionalType: return isDirectlyRecursive(node.checkType, parentTypeName) || isDirectlyRecursive(node.extendsType, parentTypeName) || isDirectlyRecursive(node.trueType, parentTypeName) || isDirectlyRecursive(node.falseType, parentTypeName);
+		case ts$1.SyntaxKind.IndexedAccessType: return isDirectlyRecursive(node.objectType, parentTypeName) || isDirectlyRecursive(node.indexType, parentTypeName);
+		case ts$1.SyntaxKind.IntersectionType:
+		case ts$1.SyntaxKind.UnionType: return node.types.some((type) => isDirectlyRecursive(type, parentTypeName));
+		case ts$1.SyntaxKind.ParenthesizedType: return isDirectlyRecursive(node.type, parentTypeName);
+		case ts$1.SyntaxKind.TypeReference:
+			if (node.typeName.kind === ts$1.SyntaxKind.Identifier && node.typeName.text === parentTypeName) return true;
+			if (node.typeArguments) return node.typeArguments.some((arg) => isDirectlyRecursive(arg, parentTypeName));
+			return false;
+		default: return false;
+	}
+}
+var indexedObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports indexed object types that don't match the configured style.",
+		id: "indexedObjectTypes",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		preferIndexSignature: {
+			primary: "Prefer an index signature over `Record<K, V>`.",
+			secondary: ["TypeScript provides two equivalent ways to define indexed object types: `Record<K, V>` and `{ [key: K]: V }`.", "Using index signatures consistently matches the more traditional TypeScript syntax."],
+			suggestions: ["Replace `Record<K, V>` with `{ [key: K]: V }`."]
+		},
+		preferRecord: {
+			primary: "Prefer `Record<K, V>` over an index signature.",
+			secondary: ["TypeScript provides two equivalent ways to define indexed object types: `Record<K, V>` and `{ [key: K]: V }`.", "Using `Record<K, V>` consistently is more concise and idiomatic."],
+			suggestions: ["Replace the index signature with `Record<K, V>`."]
+		}
+	},
+	options: { style: z.enum(["index-signature", "record"]).default("record").describe("Which indexed object type syntax to enforce: 'record' for `Record<K, V>`, or 'index-signature' for `{ [key: K]: V }`.") },
+	setup(context) {
+		function checkForRecord(node, members, sourceFile) {
+			const member = getSingleIndexSignature(members);
+			if (!member?.type) return;
+			const typeName = getTypeName(node);
+			if (typeName && isDirectlyRecursive(member.type, typeName)) return;
+			context.report({
+				message: "preferRecord",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		return { visitors: {
+			InterfaceDeclaration: (node, { options, sourceFile }) => {
+				if (options.style === "record" && !node.heritageClauses?.length) checkForRecord(node, node.members, sourceFile);
+			},
+			TypeLiteral: (node, { options, sourceFile }) => {
+				if (options.style === "record") checkForRecord(node, node.members, sourceFile);
+			},
+			TypeReference: (node, { options, sourceFile, typeChecker }) => {
+				if (options.style === "index-signature" && node.typeName.kind === ts$1.SyntaxKind.Identifier && node.typeName.text === "Record" && isGlobalDeclaration(node.typeName, typeChecker) && node.typeArguments?.length === 2) context.report({
+					message: "preferIndexSignature",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { indexedObjectTypes_default as default };
+
+//# sourceMappingURL=indexedObjectTypes.js.map

package/lib/rules/instanceOfArrays.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `instanceof Array` instead of `Array.isArray()`.";
+    readonly id: "instanceOfArrays";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useArrayIsArray", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=instanceOfArrays.d.ts.map