@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/namedDefaultExports.js

@@ -0,0 +1,60 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/namedDefaultExports.ts
+function hasDefaultModifier(modifiers) {
+	return modifiers?.some((mod) => mod.kind === SyntaxKind.DefaultKeyword);
+}
+function hasExportModifier(modifiers) {
+	return modifiers?.some((mod) => mod.kind === SyntaxKind.ExportKeyword);
+}
+var namedDefaultExports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports anonymous functions and classes as the default export.",
+		id: "namedDefaultExports",
+		presets: ["stylisticStrict"]
+	},
+	messages: {
+		anonymousClass: {
+			primary: "This default-exported class is missing an informative name.",
+			secondary: ["Named default exports improve codebase searchability by ensuring consistent identifier use for a module's default export.", "When a class is anonymous, it becomes harder to find all usages and references in the codebase."],
+			suggestions: ["Add a name to the exported class."]
+		},
+		anonymousFunction: {
+			primary: "This default-exported function is missing an informative name.",
+			secondary: ["Named default exports improve codebase searchability by ensuring consistent identifier use for a module's default export.", "When a function is anonymous, it becomes harder to find all usages and references in the codebase."],
+			suggestions: ["Add a name to the exported function.", "Assign the arrow function to a named variable, then export it."]
+		}
+	},
+	setup(context) {
+		return { visitors: {
+			ClassDeclaration: (node, { sourceFile }) => {
+				if (hasExportModifier(node.modifiers) && hasDefaultModifier(node.modifiers) && !node.name) context.report({
+					message: "anonymousClass",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			ExportAssignment: (node, { sourceFile }) => {
+				if (node.isExportEquals) return;
+				if (ts.isArrowFunction(node.expression) || ts.isFunctionExpression(node.expression) && !node.expression.name) context.report({
+					message: "anonymousFunction",
+					range: getTSNodeRange(node.expression, sourceFile)
+				});
+				else if (ts.isClassExpression(node.expression) && !node.expression.name) context.report({
+					message: "anonymousClass",
+					range: getTSNodeRange(node.expression, sourceFile)
+				});
+			},
+			FunctionDeclaration: (node, { sourceFile }) => {
+				if (hasExportModifier(node.modifiers) && hasDefaultModifier(node.modifiers) && !node.name) context.report({
+					message: "anonymousFunction",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { namedDefaultExports_default as default };
+
+//# sourceMappingURL=namedDefaultExports.js.map

package/lib/rules/namespaceDeclarations.d.ts

@@ -1,10 +1,14 @@
-import { z } from "zod";
+import { z } from "zod/v4";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "preferModules", {
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferModules", {
     readonly allowDeclarations: z.ZodDefault<z.ZodBoolean>;
     readonly allowDefinitionFiles: z.ZodDefault<z.ZodBoolean>;
 }>;
 export default _default;
+//# sourceMappingURL=namespaceDeclarations.d.ts.map

package/lib/rules/namespaceDeclarations.js

@@ -1,57 +1,37 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { z } from "zod";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using legacy `namespace` declarations.",
-        id: "namespaceDeclarations",
-        preset: "logical",
-    },
-    messages: {
-        preferModules: {
-            primary: "Prefer using ECMAScript modules over legacy TypeScript namespaces.",
-            secondary: [
-                "Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules.",
-            ],
-            suggestions: [
-                "Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead.",
-            ],
-        },
-    },
-    options: {
-        allowDeclarations: z
-            .boolean()
-            .default(false)
-            .describe("Whether to allow namespaces declared with the `declare` keyword."),
-        allowDefinitionFiles: z
-            .boolean()
-            .default(false)
-            .describe("Whether to allow namespaces in `.d.ts` and other definition files."),
-    },
-    setup(context, { allowDeclarations, allowDefinitionFiles }) {
-        if (allowDefinitionFiles && context.sourceFile.isDeclarationFile) {
-            return;
-        }
-        return {
-            visitors: {
-                ModuleDeclaration: (node) => {
-                    if (node.parent.kind !== ts.SyntaxKind.SourceFile ||
-                        node.name.kind !== ts.SyntaxKind.Identifier ||
-                        node.name.text === "global") {
-                        return;
-                    }
-                    if (allowDeclarations &&
-                        tsutils.includesModifier(node.modifiers, ts.SyntaxKind.DeclareKeyword)) {
-                        return;
-                    }
-                    context.report({
-                        message: "preferModules",
-                        range: getTSNodeRange(node.getChildAt(0), context.sourceFile),
-                    });
-                },
-            },
-        };
-    },
+import { z } from "zod/v4";
+//#region src/rules/namespaceDeclarations.ts
+var namespaceDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using legacy `namespace` declarations.",
+		id: "namespaceDeclarations",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferModules: {
+		primary: "Prefer using ECMAScript modules over legacy TypeScript namespaces.",
+		secondary: ["Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules."],
+		suggestions: ["Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead."]
+	} },
+	options: {
+		allowDeclarations: z.boolean().default(false).describe("Whether to allow namespaces declared with the `declare` keyword."),
+		allowDefinitionFiles: z.boolean().default(false).describe("Whether to allow namespaces in `.d.ts` and other definition files.")
+	},
+	setup(context) {
+		return { visitors: { ModuleDeclaration: (node, { options: { allowDeclarations, allowDefinitionFiles }, sourceFile }) => {
+			if (allowDefinitionFiles && sourceFile.isDeclarationFile) return;
+			if (node.parent.kind !== SyntaxKind.SourceFile || node.name.kind !== SyntaxKind.Identifier || node.name.text === "global") return;
+			if (allowDeclarations && tsutils.includesModifier(node.modifiers, SyntaxKind.DeclareKeyword)) return;
+			context.report({
+				message: "preferModules",
+				range: getTSNodeRange(node.getChildAt(0), sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { namespaceDeclarations_default as default };
+
+//# sourceMappingURL=namespaceDeclarations.js.map

package/lib/rules/namespaceImplicitAmbientImports.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports declared namespaces that implicitly export all members.";
+    readonly id: "namespaceImplicitAmbientImports";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "implicitExports", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=namespaceImplicitAmbientImports.d.ts.map

package/lib/rules/namespaceImplicitAmbientImports.js

@@ -0,0 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/namespaceImplicitAmbientImports.ts
+function hasExportModifier(node) {
+	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
+}
+function hasNamedExport(statements) {
+	return statements.some((statement) => statement.kind === SyntaxKind.ExportDeclaration && statement.exportClause?.kind === SyntaxKind.NamedExports);
+}
+function hasNonExportedMember(statements) {
+	return statements.some((statement) => !hasExportModifier(statement) && (statement.kind === SyntaxKind.TypeAliasDeclaration || statement.kind === SyntaxKind.InterfaceDeclaration || statement.kind === SyntaxKind.ClassDeclaration || statement.kind === SyntaxKind.EnumDeclaration || statement.kind === SyntaxKind.FunctionDeclaration || statement.kind === SyntaxKind.VariableStatement || statement.kind === SyntaxKind.ModuleDeclaration));
+}
+var namespaceImplicitAmbientImports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports declared namespaces that implicitly export all members.",
+		id: "namespaceImplicitAmbientImports",
+		presets: ["stylisticStrict"]
+	},
+	messages: { implicitExports: {
+		primary: "Declared namespaces without explicit exports implicitly export all members.",
+		secondary: ["When a declared namespace has no named export statements, all its members are implicitly exported.", "This can lead to unintended exports and make it harder to understand what the namespace exposes."],
+		suggestions: ["Add an `export {};` statement to opt out of implicit exports, then explicitly export the members you intend to expose."]
+	} },
+	setup(context) {
+		return { visitors: { ModuleDeclaration: (node, { sourceFile }) => {
+			if (!node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.DeclareKeyword) || node.name.kind !== SyntaxKind.Identifier || node.body?.kind !== SyntaxKind.ModuleBlock) return;
+			const statements = node.body.statements;
+			if (!statements.length || hasNamedExport(statements) || !hasNonExportedMember(statements)) return;
+			context.report({
+				message: "implicitExports",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { namespaceImplicitAmbientImports_default as default };
+
+//# sourceMappingURL=namespaceImplicitAmbientImports.js.map

package/lib/rules/namespaceKeywords.d.ts

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

package/lib/rules/namespaceKeywords.js

@@ -0,0 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/namespaceKeywords.ts
+var namespaceKeywords_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using `module` keyword instead of `namespace` for TypeScript namespaces.",
+		id: "namespaceKeywords",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferNamespace: {
+		primary: "The `namespace` keyword is preferred over `module` for TypeScript namespaces.",
+		secondary: [
+			"TypeScript originally used the `module` keyword to declare internal modules (namespaces).",
+			"The `namespace` keyword was later introduced to avoid confusion with ES6 modules.",
+			"Using `namespace` makes it clear you are defining a TypeScript namespace, not an ES6 module."
+		],
+		suggestions: ["Replace `module` with `namespace`."]
+	} },
+	setup(context) {
+		return { visitors: { ModuleDeclaration: (node, { sourceFile }) => {
+			if (node.name.kind === SyntaxKind.StringLiteral) return;
+			const moduleKeywordToken = node.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.ModuleKeyword);
+			if (!moduleKeywordToken) return;
+			const range = getTSNodeRange(moduleKeywordToken, sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: "namespace"
+				},
+				message: "preferNamespace",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { namespaceKeywords_default as default };
+
+//# sourceMappingURL=namespaceKeywords.js.map

package/lib/rules/nativeObjectExtensions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports extending the prototype of native JavaScript objects.";
+    readonly id: "nativeObjectExtensions";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noExtendNative", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nativeObjectExtensions.d.ts.map

package/lib/rules/nativeObjectExtensions.js

@@ -0,0 +1,114 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/nativeObjectExtensions.ts
+const nativeConstructors = new Set([
+	"AggregateError",
+	"Array",
+	"ArrayBuffer",
+	"BigInt",
+	"BigInt64Array",
+	"BigUint64Array",
+	"Boolean",
+	"DataView",
+	"Date",
+	"Error",
+	"EvalError",
+	"FinalizationRegistry",
+	"Float16Array",
+	"Float32Array",
+	"Float64Array",
+	"Function",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Map",
+	"Number",
+	"Object",
+	"Promise",
+	"RangeError",
+	"ReferenceError",
+	"RegExp",
+	"Set",
+	"SharedArrayBuffer",
+	"String",
+	"Symbol",
+	"SyntaxError",
+	"TypeError",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Uint16Array",
+	"Uint32Array",
+	"URIError",
+	"WeakMap",
+	"WeakRef",
+	"WeakSet"
+]);
+function getPrototypeObject(node) {
+	return ts$1.isIdentifier(node.expression) && node.expression;
+}
+function isPrototypeAccess(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.ElementAccessExpression: return ts$1.isStringLiteral(node.argumentExpression) && node.argumentExpression.text === "prototype";
+		case ts$1.SyntaxKind.PropertyAccessExpression: return node.name.text === "prototype";
+		default: return false;
+	}
+}
+var nativeObjectExtensions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports extending the prototype of native JavaScript objects.",
+		id: "nativeObjectExtensions",
+		presets: ["javascript"]
+	},
+	messages: { noExtendNative: {
+		primary: "Extending the {{ name }} prototype modifies built-in behavior that other code depends on.",
+		secondary: [
+			"Adding properties to native prototypes affects all instances of that type across the codebase.",
+			"This can cause conflicts with other libraries that expect standard prototype behavior.",
+			"Future ECMAScript versions may add methods with the same name, causing unexpected behavior."
+		],
+		suggestions: ["Create a wrapper class or utility function instead of extending the prototype.", "Use composition rather than modifying the prototype chain."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile, typeChecker }) {
+			if (!isPrototypeAccess(node)) return;
+			const objectIdentifier = getPrototypeObject(node);
+			if (!objectIdentifier) return;
+			const name = objectIdentifier.text;
+			if (!nativeConstructors.has(name) || !isGlobalDeclarationOfName(objectIdentifier, name, typeChecker)) return;
+			switch (node.parent.kind) {
+				case ts$1.SyntaxKind.CallExpression: {
+					if (node.parent.arguments[0] !== node) break;
+					const callee = node.parent.expression;
+					if (!ts$1.isPropertyAccessExpression(callee) || !ts$1.isIdentifier(callee.expression) || callee.expression.text !== "Object" || callee.name.text !== "defineProperty" && callee.name.text !== "defineProperties" || !isGlobalDeclarationOfName(callee.expression, "Object", typeChecker)) break;
+					context.report({
+						data: { name },
+						message: "noExtendNative",
+						range: getTSNodeRange(node.parent, sourceFile)
+					});
+					break;
+				}
+				case ts$1.SyntaxKind.ElementAccessExpression:
+				case ts$1.SyntaxKind.PropertyAccessExpression: {
+					if (node.parent.expression !== node) break;
+					const grandparent = node.parent.parent;
+					if (!ts$1.isBinaryExpression(grandparent) || grandparent.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || grandparent.left !== node.parent) break;
+					context.report({
+						data: { name },
+						message: "noExtendNative",
+						range: getTSNodeRange(grandparent, sourceFile)
+					});
+					break;
+				}
+			}
+		}
+		return { visitors: {
+			ElementAccessExpression: checkNode,
+			PropertyAccessExpression: checkNode
+		} };
+	}
+});
+//#endregion
+export { nativeObjectExtensions_default as default };
+
+//# sourceMappingURL=nativeObjectExtensions.js.map

package/lib/rules/negativeIndexLengthMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.";
+    readonly id: "negativeIndexLengthMethods";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNegativeIndex", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=negativeIndexLengthMethods.d.ts.map

package/lib/rules/negativeIndexLengthMethods.js

@@ -0,0 +1,180 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { isTypeRecursive } from "./utils/isTypeRecursive.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/negativeIndexLengthMethods.ts
+const typedArrayNames = new Set([
+	"BigInt64Array",
+	"BigUint64Array",
+	"Float32Array",
+	"Float64Array",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Uint16Array",
+	"Uint32Array"
+]);
+const methodConfigurations = new Map([
+	["at", {
+		argumentIndexes: [0],
+		supportedTypes: new Set([
+			"Array",
+			"String",
+			...typedArrayNames
+		])
+	}],
+	["slice", {
+		argumentIndexes: [0, 1],
+		supportedTypes: new Set([
+			"Array",
+			"String",
+			...typedArrayNames
+		])
+	}],
+	["splice", {
+		argumentIndexes: [0],
+		supportedTypes: new Set(["Array"])
+	}],
+	["subarray", {
+		argumentIndexes: [0, 1],
+		supportedTypes: new Set(typedArrayNames)
+	}],
+	["toSpliced", {
+		argumentIndexes: [0],
+		supportedTypes: new Set(["Array"])
+	}],
+	["with", {
+		argumentIndexes: [0],
+		supportedTypes: new Set(["Array", ...typedArrayNames])
+	}]
+]);
+function getNegativeIndexLengthNode(node, target, sourceFile) {
+	const unwrapped = unwrapParenthesizedNode(node);
+	if (!ts$1.isBinaryExpression(unwrapped) || unwrapped.operatorToken.kind !== ts$1.SyntaxKind.MinusToken) return;
+	const right = unwrapParenthesizedNode(unwrapped.right);
+	if (!isPositiveNumericLiteral(right)) return;
+	const left = unwrapParenthesizedNode(unwrapped.left);
+	if (isLengthPropertyAccess(left, target, sourceFile)) return {
+		binaryExpression: unwrapped,
+		lengthNode: left,
+		rightOperand: right
+	};
+	return getNegativeIndexLengthNode(unwrapped.left, target, sourceFile);
+}
+function isLengthPropertyAccess(node, target, sourceFile) {
+	return ts$1.isPropertyAccessExpression(node) && node.name.text === "length" && hasSameTokens(node.expression, target, sourceFile);
+}
+function isPositiveNumericLiteral(node) {
+	if (!ts$1.isNumericLiteral(node)) return false;
+	const value = Number(node.text);
+	return Number.isInteger(value) && value > 0;
+}
+function isSupportedType(node, typeChecker, supportedTypes) {
+	return isTypeRecursive(getConstrainedTypeAtLocation(node, typeChecker), (constituent) => {
+		if ((constituent.flags & ts$1.TypeFlags.Any) !== 0) return true;
+		if (typeChecker.isArrayType(constituent) || typeChecker.isTupleType(constituent)) return supportedTypes.has("Array");
+		const typeName = constituent.getSymbol()?.getName();
+		if (typeName) return supportedTypes.has(typeName);
+		if (constituent.isStringLiteral() || (constituent.flags & ts$1.TypeFlags.String) !== 0) return supportedTypes.has("String");
+		return false;
+	});
+}
+function isValidPrototypePattern(node, method) {
+	if (ts$1.isArrayLiteralExpression(node) && !node.elements.length) return true;
+	if (method === "slice" && ts$1.isStringLiteral(node) && node.text === "") return true;
+	if (!ts$1.isPropertyAccessExpression(node) || node.name.text !== "prototype") return false;
+	const object = node.expression;
+	if (!ts$1.isIdentifier(object)) return false;
+	return !!methodConfigurations.get(method)?.supportedTypes.has(object.text);
+}
+function parseCallExpression(node) {
+	if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+	const methodName = node.expression.name.text;
+	const receiver = node.expression.expression;
+	if (methodConfigurations.has(methodName)) return {
+		argumentNodes: node.arguments,
+		method: methodName,
+		target: receiver
+	};
+	if (methodName !== "call" && methodName !== "apply") return;
+	return parsePrototypeCall(node, methodName === "apply");
+}
+function parsePrototypeCall(node, isApply) {
+	if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+	const callee = node.expression.expression;
+	if (!ts$1.isPropertyAccessExpression(callee)) return;
+	const method = callee.name.text;
+	if (!methodConfigurations.has(method)) return;
+	const prototypeObject = callee.expression;
+	if (!isValidPrototypePattern(prototypeObject, method)) return;
+	const [targetArgument, ...restArguments] = node.arguments;
+	if (!targetArgument) return;
+	if (isApply) {
+		const arrayArgument = restArguments[0];
+		if (!arrayArgument || !ts$1.isArrayLiteralExpression(arrayArgument)) return;
+		return {
+			argumentNodes: arrayArgument.elements.filter((element) => !ts$1.isSpreadElement(element)),
+			method,
+			target: targetArgument
+		};
+	}
+	return {
+		argumentNodes: restArguments,
+		method,
+		target: targetArgument
+	};
+}
+var negativeIndexLengthMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.",
+		id: "negativeIndexLengthMethods",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferNegativeIndex: {
+		primary: "Prefer using a negative index over `.length - index` for `{{ method }}`.",
+		secondary: ["Negative indices are more concise and express the intent of accessing from the end more clearly.", "Methods like `.at()`, `.slice()`, and `.splice()` support negative indices natively."],
+		suggestions: ["Use a negative index instead of subtracting from `.length`."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			const parsed = parseCallExpression(node);
+			if (!parsed) return;
+			const { argumentNodes, method, target } = parsed;
+			const methodConfiguration = methodConfigurations.get(method);
+			if (!methodConfiguration) return;
+			if (!isSupportedType(target, typeChecker, methodConfiguration.supportedTypes)) return;
+			const fixableArguments = [];
+			for (const index of methodConfiguration.argumentIndexes) {
+				const argument = argumentNodes[index];
+				if (!argument) continue;
+				const info = getNegativeIndexLengthNode(argument, target, sourceFile);
+				if (info) fixableArguments.push({
+					argument,
+					info
+				});
+			}
+			if (!fixableArguments.length) return;
+			context.report({
+				data: { method },
+				fix: fixableArguments.map(({ info }) => {
+					return {
+						range: {
+							begin: info.binaryExpression.getStart(sourceFile),
+							end: info.binaryExpression.getEnd()
+						},
+						text: `-${info.rightOperand.getText(sourceFile)}`
+					};
+				}),
+				message: "preferNegativeIndex",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { negativeIndexLengthMethods_default as default };
+
+//# sourceMappingURL=negativeIndexLengthMethods.js.map

package/lib/rules/negativeZeroComparisons.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports comparisons with -0 that may not behave as expected.";
     readonly id: "negativeZeroComparisons";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedNegativeZeroComparison", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedNegativeZeroComparison", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=negativeZeroComparisons.d.ts.map