@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/caughtVariableNames.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/caughtVariableNames.ts
-var caughtVariableNames_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces a consistent naming convention for catch clause error variables.",
-		id: "caughtVariableNames",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferErrorName: {
-		primary: "Use `error` as the name for the catch clause parameter instead of `{{ name }}`.",
-		secondary: [
-			"Consistent naming of catch clause parameters improves code readability.",
-			"The name `error` clearly indicates the purpose of the variable.",
-			"Descriptive names ending in 'Error' are generally also acceptable."
-		],
-		suggestions: ["Rename `{{ name }}` to `error`.", "Rename `{{ name }}` to a name ending with `Error`."]
-	} },
-	setup(context) {
-		return { visitors: { CatchClause: (node, { sourceFile }) => {
-			const variable = node.variableDeclaration;
-			if (!variable || !ts$1.isIdentifier(variable.name)) return;
-			const name = variable.name.text;
-			if (name === "error" || name.endsWith("Error")) return;
-			context.report({
-				data: { name },
-				message: "preferErrorName",
-				range: {
-					begin: variable.name.getStart(sourceFile),
-					end: variable.name.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { caughtVariableNames_default as default };

package/lib/rules/chainedAssignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
-    readonly id: "chainedAssignments";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noChainedAssignment", undefined>;
-export default _default;

package/lib/rules/chainedAssignments.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/chainedAssignments.ts
-var chainedAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using chained assignment expressions (e.g., a = b = c).",
-		id: "chainedAssignments",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { noChainedAssignment: {
-		primary: "Prefer separate assignment statements for readability instead of chaining assignments.",
-		secondary: ["Chained assignments can be hard to read and can lead to unexpected behavior with variable scoping and type inference.", "Each assignment creates a reference to the same value, which may cause confusion when dealing with mutable values."],
-		suggestions: ["Break the chained assignment into separate assignment statements, one for each variable."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (!tsutils.isAssignmentKind(node.operatorToken.kind)) return;
-			const rightSide = unwrapParenthesizedNode(node.right);
-			if (rightSide.kind !== SyntaxKind.BinaryExpression || !tsutils.isAssignmentKind(rightSide.operatorToken.kind)) return;
-			if (unwrapParentParenthesizedExpressions(node).kind === SyntaxKind.BinaryExpression) return;
-			context.report({
-				message: "noChainedAssignment",
-				range: getTSNodeRange(node.operatorToken, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { chainedAssignments_default as default };

package/lib/rules/charAtComparisons.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports comparing charAt() results with strings longer than one character.";
-    readonly id: "charAtComparisons";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidComparison", undefined>;
-export default _default;

package/lib/rules/charAtComparisons.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticStringValue, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/charAtComparisons.ts
-const comparisonOperators = /* @__PURE__ */ new Set([
-	ts$1.SyntaxKind.EqualsEqualsEqualsToken,
-	ts$1.SyntaxKind.EqualsEqualsToken,
-	ts$1.SyntaxKind.ExclamationEqualsEqualsToken,
-	ts$1.SyntaxKind.ExclamationEqualsToken
-]);
-function isStringCharAtCall(node, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "charAt" && isStringType(typeChecker.getTypeAtLocation(node.expression.expression));
-}
-function isStringType(type) {
-	return (type.flags & ts$1.TypeFlags.StringLike) !== 0;
-}
-var charAtComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports comparing charAt() results with strings longer than one character.",
-		id: "charAtComparisons",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { invalidComparison: {
-		primary: "Comparing charAt() result with a string of length {{ length }} is always {{ result }}.",
-		secondary: ["The `charAt` method returns a string of exactly one character.", "Comparing it with a multi-character string will always evaluate to the same result."],
-		suggestions: ["Use a single-character string for the comparison.", "Consider using `startsWith()`, `includes()`, or `slice()` for multi-character comparisons."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
-			if (!comparisonOperators.has(node.operatorToken.kind)) return;
-			let literal;
-			if (isStringCharAtCall(node.left, typeChecker)) literal = node.right;
-			else if (isStringCharAtCall(node.right, typeChecker)) literal = node.left;
-			else return;
-			const value = getStaticStringValue(literal);
-			if (value === void 0 || value.length <= 1) return;
-			const isEquality = node.operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken;
-			context.report({
-				data: {
-					length: value.length,
-					result: isEquality ? "false" : "true"
-				},
-				message: "invalidComparison",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { charAtComparisons_default as default };

package/lib/rules/classAssignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports reassigning class declarations.";
-    readonly id: "classAssignments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noClassAssign", undefined>;
-export default _default;

package/lib/rules/classAssignments.js

@@ -1,27 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/classAssignments.ts
-var classAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports reassigning class declarations.",
-		id: "classAssignments",
-		presets: ["javascript"]
-	},
-	messages: { noClassAssign: {
-		primary: "Reassigning a class declaration is misleading and makes the class harder to use.",
-		secondary: ["Reassigning a class declaration can lead to unexpected behavior and makes code harder to understand.", "Class declarations are typically intended to be immutable references, and reassigning them can cause confusion about which class is being used."],
-		suggestions: ["Use a different variable name if you need to store a modified reference to a class."]
-	} },
-	setup(context) {
-		return { visitors: { ClassDeclaration: (node, { sourceFile }) => {
-			if (!node.name) return;
-			const modifyingReferences = getModifyingReferences(node.name, sourceFile);
-			for (const reference of modifyingReferences) context.report({
-				message: "noClassAssign",
-				range: getTSNodeRange(reference, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { classAssignments_default as default };

package/lib/rules/classFieldDeclarations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports assigning literal values to `this` in constructors instead of using class field declarations.";
-    readonly id: "classFieldDeclarations";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferClassField", undefined>;
-export default _default;

package/lib/rules/classFieldDeclarations.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/classFieldDeclarations.ts
-function isLiteralValue(node) {
-	if (ts.isPrefixUnaryExpression(node)) return isLiteralValue(node.operand);
-	return node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || ts.isLiteralExpression(node);
-}
-function isThisLiteralAssignment(node) {
-	return (ts.isElementAccessExpression(node.left) || ts.isPropertyAccessExpression(node.left)) && ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword && isLiteralValue(node.right);
-}
-var classFieldDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports assigning literal values to `this` in constructors instead of using class field declarations.",
-		id: "classFieldDeclarations",
-		presets: ["javascript"]
-	},
-	messages: { preferClassField: {
-		primary: "Prefer class field declaration over `this` assignment in constructor for static values.",
-		secondary: ["Class field declarations are more concise and clearly express the intent of initializing properties.", "Moving property initialization to class fields keeps the constructor focused on dynamic initialization logic."],
-		suggestions: ["Move this property assignment to a class field declaration."]
-	} },
-	setup(context) {
-		function checkStatement(node, sourceFile) {
-			if (!ts.isExpressionStatement(node) || !ts.isBinaryExpression(node.expression) || node.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !isThisLiteralAssignment(node.expression)) return;
-			context.report({
-				message: "preferClassField",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: { Constructor: (node, { sourceFile }) => {
-			if (!node.body || !ts.isClassDeclaration(node.parent) && !ts.isClassExpression(node.parent)) return;
-			for (const statement of node.body.statements) checkStatement(statement, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { classFieldDeclarations_default as default };

package/lib/rules/classLiteralProperties.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports getters that return literal values instead of using readonly class fields.";
-    readonly id: "classLiteralProperties";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferField", undefined>;
-export default _default;

package/lib/rules/classLiteralProperties.js

@@ -1,43 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/classLiteralProperties.ts
-var classLiteralProperties_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports getters that return literal values instead of using readonly class fields.",
-		id: "classLiteralProperties",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferField: {
-		primary: "Prefer a readonly class field over a getter returning a literal value.",
-		secondary: ["Readonly fields are more concise and avoid the overhead of a function call.", "Getters returning literal values provide no benefit over readonly fields."],
-		suggestions: ["Replace this getter with a readonly field."]
-	} },
-	setup(context) {
-		return { visitors: { GetAccessor: (node, { sourceFile }) => {
-			if (node.body?.statements.length !== 1) return;
-			const statement = node.body.statements[0];
-			if (!ts.isReturnStatement(statement) || !statement.expression || !isLiteralValue(statement.expression)) return;
-			context.report({
-				message: "preferField",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-function isLiteralValue(node) {
-	switch (node.kind) {
-		case ts.SyntaxKind.BigIntLiteral:
-		case ts.SyntaxKind.FalseKeyword:
-		case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
-		case ts.SyntaxKind.NullKeyword:
-		case ts.SyntaxKind.NumericLiteral:
-		case ts.SyntaxKind.RegularExpressionLiteral:
-		case ts.SyntaxKind.StringLiteral:
-		case ts.SyntaxKind.TrueKeyword: return true;
-		case ts.SyntaxKind.PrefixUnaryExpression: return isLiteralValue(node.operand);
-		default: return false;
-	}
-}
-//#endregion
-export { classLiteralProperties_default as default };

package/lib/rules/classMemberDuplicates.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports duplicate class member names that will be overwritten.";
-    readonly id: "classMemberDuplicates";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateMember", undefined>;
-export default _default;

package/lib/rules/classMemberDuplicates.js

@@ -1,69 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/classMemberDuplicates.ts
-var classMemberDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports duplicate class member names that will be overwritten.",
-		id: "classMemberDuplicates",
-		presets: ["javascript"]
-	},
-	messages: { duplicateMember: {
-		primary: "Duplicate class member name '{{ memberName }}' will be overwritten.",
-		secondary: ["Duplicate class members are legal in JavaScript, but only the last definition is used.", "This can lead to confusion and bugs, especially when maintaining the code."],
-		suggestions: ["If both members are meant to exist, rename one of them.", "If only the last definition is meant to exist, remove the earlier one."]
-	} },
-	setup(context) {
-		return { visitors: {
-			ClassDeclaration: visitClass,
-			ClassExpression: visitClass
-		} };
-		function visitClass(node, { sourceFile }) {
-			const seenMembers = {
-				instance: {
-					getters: /* @__PURE__ */ new Map(),
-					setters: /* @__PURE__ */ new Map(),
-					values: /* @__PURE__ */ new Map()
-				},
-				static: {
-					getters: /* @__PURE__ */ new Map(),
-					setters: /* @__PURE__ */ new Map(),
-					values: /* @__PURE__ */ new Map()
-				}
-			};
-			for (const member of node.members.toReversed()) {
-				const key = getMemberKeyName(member);
-				if (!key) continue;
-				const namespace = key.isStatic ? seenMembers.static : seenMembers.instance;
-				let isDuplicate;
-				if (key.group === "values") isDuplicate = namespace.values.has(key.text) || namespace.getters.has(key.text) || namespace.setters.has(key.text);
-				else if (key.group === "getters") isDuplicate = namespace.getters.has(key.text) || namespace.values.has(key.text);
-				else isDuplicate = namespace.setters.has(key.text) || namespace.values.has(key.text);
-				if (isDuplicate) context.report({
-					data: { memberName: key.text },
-					message: "duplicateMember",
-					range: getTSNodeRange(key.node, sourceFile)
-				});
-				namespace[key.group].set(key.text, member);
-			}
-		}
-	}
-});
-function getMemberKeyName(member) {
-	if (member.kind === SyntaxKind.PropertyDeclaration || member.kind === SyntaxKind.MethodDeclaration || member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) {
-		const text = getNameText(member.name);
-		if (!text) return;
-		const isStatic = member.modifiers?.some((modifier) => modifier.kind === SyntaxKind.StaticKeyword);
-		return {
-			group: member.kind === SyntaxKind.GetAccessor ? "getters" : member.kind === SyntaxKind.SetAccessor ? "setters" : "values",
-			isStatic: !!isStatic,
-			node: member.name,
-			text
-		};
-	}
-}
-function getNameText(name) {
-	if (name.kind === SyntaxKind.Identifier || name.kind === SyntaxKind.NumericLiteral || name.kind === SyntaxKind.BigIntLiteral || name.kind === SyntaxKind.StringLiteral || name.kind === SyntaxKind.NoSubstitutionTemplateLiteral || name.kind === SyntaxKind.PrivateIdentifier) return name.text;
-}
-//#endregion
-export { classMemberDuplicates_default as default };

package/lib/rules/classMethodsThis.d.ts

@@ -1,13 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports class methods that do not use `this`.";
-    readonly id: "classMethodsThis";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingThis", {
-    ignoreClassesThatImplementAnInterface: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"public-fields">]>>;
-    ignoreOverrideMethods: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;

package/lib/rules/classMethodsThis.js

@@ -1,122 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/classMethodsThis.ts
-function classImplementsSomething(classNode) {
-	return classNode.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword) ?? false;
-}
-function containsThis(node) {
-	switch (node.kind) {
-		case ts.SyntaxKind.ClassDeclaration:
-		case ts.SyntaxKind.ClassExpression: {
-			const classNode = node;
-			for (const member of classNode.members) if (ts.isPropertyDeclaration(member) && ts.isComputedPropertyName(member.name) && containsThis(member.name.expression)) return true;
-			return false;
-		}
-		case ts.SyntaxKind.ClassStaticBlockDeclaration:
-		case ts.SyntaxKind.FunctionDeclaration:
-		case ts.SyntaxKind.FunctionExpression: return false;
-		case ts.SyntaxKind.SuperKeyword:
-		case ts.SyntaxKind.ThisKeyword: return true;
-		default: return ts.forEachChild(node, containsThis) ?? false;
-	}
-}
-function getMemberDisplayName(member, sourceFile) {
-	const name = member.name;
-	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
-	if (ts.isPrivateIdentifier(name)) return name.text;
-	if (ts.isComputedPropertyName(name)) {
-		const expr = name.expression;
-		if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr) || ts.isNumericLiteral(expr)) return expr.text;
-		return `[${expr.getText(sourceFile)}]`;
-	}
-}
-function hasModifier(modifiers, kind) {
-	return modifiers?.some((modifier) => modifier.kind === kind) ?? false;
-}
-function isPublicMember(member) {
-	if (ts.isPrivateIdentifier(member.name)) return false;
-	const modifiers = member.modifiers;
-	if (!modifiers) return true;
-	if (modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) return false;
-	return true;
-}
-function shouldSkipMember(member, classNode, options) {
-	if (hasModifier(member.modifiers, ts.SyntaxKind.StaticKeyword)) return true;
-	if (options.ignoreOverrideMethods && hasModifier(member.modifiers, ts.SyntaxKind.OverrideKeyword)) return true;
-	const implementsInterface = classImplementsSomething(classNode);
-	const ignoreImpl = options.ignoreClassesThatImplementAnInterface;
-	if (implementsInterface && ignoreImpl) {
-		if (ignoreImpl === true) return true;
-		if (isPublicMember(member)) return true;
-	}
-	return false;
-}
-var classMethodsThis_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports class methods that do not use `this`.",
-		id: "classMethodsThis",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { missingThis: {
-		primary: "Expected 'this' to be used by class {{ kind }} '{{ name }}'.",
-		secondary: ["Methods that don't use `this` could be static methods or standalone functions.", "Using instance methods that don't access instance state can be misleading."],
-		suggestions: ["Add the `static` keyword to make this a static method.", "Extract this to a standalone function if it doesn't need class context."]
-	} },
-	options: {
-		ignoreClassesThatImplementAnInterface: z$1.union([z$1.boolean(), z$1.literal("public-fields")]).default(false).describe("Whether to ignore classes that implement interfaces. Set to 'public-fields' to only ignore public members."),
-		ignoreOverrideMethods: z$1.boolean().default(false).describe("Whether to ignore members with the 'override' modifier.")
-	},
-	setup(context) {
-		function reportMember(member, kind, sourceFile, reportFromStart) {
-			const name = getMemberDisplayName(member, sourceFile);
-			if (!name) return;
-			const beginNode = reportFromStart ? member : member.name;
-			context.report({
-				data: {
-					kind,
-					name
-				},
-				message: "missingThis",
-				range: {
-					begin: beginNode.getStart(sourceFile),
-					end: member.name.getEnd()
-				}
-			});
-		}
-		function checkMethod(member, classNode, sourceFile, options) {
-			if (member.body && !shouldSkipMember(member, classNode, options) && !containsThis(member.body)) reportMember(member, "method", sourceFile, false);
-		}
-		function checkAccessor(member, classNode, sourceFile, options, kind) {
-			if (member.body && !shouldSkipMember(member, classNode, options) && !containsThis(member.body)) reportMember(member, kind, sourceFile, true);
-		}
-		function checkPropertyInitializerFunction(member, classNode, sourceFile, options) {
-			if (!member.initializer) return;
-			if (member.initializer.kind !== ts.SyntaxKind.ArrowFunction && member.initializer.kind !== ts.SyntaxKind.FunctionExpression) return;
-			if (!shouldSkipMember(member, classNode, options) && !containsThis(member.initializer.body)) reportMember(member, "method", sourceFile, false);
-		}
-		function checkClass(node, { options, sourceFile }) {
-			for (const member of node.members) switch (member.kind) {
-				case ts.SyntaxKind.GetAccessor:
-					checkAccessor(member, node, sourceFile, options, "getter");
-					break;
-				case ts.SyntaxKind.MethodDeclaration:
-					checkMethod(member, node, sourceFile, options);
-					break;
-				case ts.SyntaxKind.PropertyDeclaration:
-					checkPropertyInitializerFunction(member, node, sourceFile, options);
-					break;
-				case ts.SyntaxKind.SetAccessor:
-					checkAccessor(member, node, sourceFile, options, "setter");
-					break;
-			}
-		}
-		return { visitors: {
-			ClassDeclaration: checkClass,
-			ClassExpression: checkClass
-		} };
-	}
-});
-//#endregion
-export { classMethodsThis_default as default };

package/lib/rules/combinedPushes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports consecutive array.push() calls that could be combined into a single call.";
-    readonly id: "combinedPushes";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "combinePushes", undefined>;
-export default _default;

package/lib/rules/combinedPushes.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/combinedPushes.ts
-var combinedPushes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports consecutive array.push() calls that could be combined into a single call.",
-		id: "combinedPushes",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { combinePushes: {
-		primary: "Consecutive `.push()` calls can be combined into a single call.",
-		secondary: ["Multiple consecutive `.push()` calls on the same array can be combined.", "Use `.push(a, b, c)` instead of separate `.push(a)`, `.push(b)`, `.push(c)` calls."],
-		suggestions: ["Combine consecutive `.push()` calls into one."]
-	} },
-	setup(context) {
-		function isArrayPushCall(node, typeChecker) {
-			return ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "push" && typeChecker.isArrayType(typeChecker.getTypeAtLocation(node.expression.expression));
-		}
-		function getArrayName(node, sourceFile) {
-			return ts.isPropertyAccessExpression(node.expression) && node.expression.expression.getText(sourceFile);
-		}
-		function isPushCallStatement(statement, sourceFile, typeChecker) {
-			if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !isArrayPushCall(statement.expression, typeChecker)) return;
-			const arrayName = getArrayName(statement.expression, sourceFile);
-			if (!arrayName) return;
-			return {
-				arrayName,
-				callExpression: statement.expression
-			};
-		}
-		function checkNode({ statements }, { sourceFile, typeChecker }) {
-			for (let i = 0; i < statements.length - 1; i += 1) {
-				const currentStatement = statements[i];
-				const currentPush = isPushCallStatement(currentStatement, sourceFile, typeChecker);
-				if (!currentPush) continue;
-				const nextStatement = statements[i + 1];
-				if (isPushCallStatement(nextStatement, sourceFile, typeChecker)?.arrayName === currentPush.arrayName) context.report({
-					message: "combinePushes",
-					range: {
-						begin: currentStatement.getStart(sourceFile),
-						end: nextStatement.getEnd()
-					}
-				});
-			}
-		}
-		return { visitors: {
-			Block: checkNode,
-			SourceFile: checkNode
-		} };
-	}
-});
-//#endregion
-export { combinedPushes_default as default };

package/lib/rules/consecutiveNonNullAssertions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary extra non-null assertions.";
-    readonly id: "consecutiveNonNullAssertions";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "consecutiveNonNullAssertion", undefined>;
-export default _default;

package/lib/rules/consecutiveNonNullAssertions.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/consecutiveNonNullAssertions.ts
-var consecutiveNonNullAssertions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary extra non-null assertions.",
-		id: "consecutiveNonNullAssertions",
-		presets: ["logical"]
-	},
-	messages: { consecutiveNonNullAssertion: {
-		primary: "Consecutive non-null assertion operators are unnecessary.",
-		secondary: ["The non-null assertion operator (`!`) is used to assert that a value is not null or undefined.", "Using it multiple times in a row does not do anything, and just takes up space unnecessarily."],
-		suggestions: ["Remove the redundant non-null assertion operator."]
-	} },
-	setup(context) {
-		return { visitors: { NonNullExpression: (node) => {
-			if (node.parent.kind !== SyntaxKind.NonNullExpression) return;
-			context.report({
-				fix: {
-					range: {
-						begin: node.end,
-						end: node.parent.end
-					},
-					text: ""
-				},
-				message: "consecutiveNonNullAssertion",
-				range: {
-					begin: node.end - 1,
-					end: node.parent.end
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { consecutiveNonNullAssertions_default as default };

package/lib/rules/consoleCalls.d.ts

@@ -1,8 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports calls to console methods.";
-    readonly id: "consoleCalls";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noConsole", undefined>;
-export default _default;

package/lib/rules/consoleCalls.js

@@ -1,26 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/consoleCalls.ts
-var consoleCalls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports calls to console methods.",
-		id: "consoleCalls"
-	},
-	messages: { noConsole: {
-		primary: "Console method calls should not be used in production code.",
-		secondary: ["Console methods like `console.log`, `console.warn`, and `console.error` are useful during development but should typically be removed before shipping to production.", "Consider using a proper logging library that can be configured for different environments."],
-		suggestions: ["Remove the console call before shipping this code to users."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (!ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.expression) || node.expression.expression.text !== "console" || !isGlobalVariable(node.expression.expression, typeChecker, program)) return;
-			context.report({
-				message: "noConsole",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { consoleCalls_default as default };