@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/classMethodsThis.js

@@ -1,124 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z } 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.union([z.boolean(), z.literal("public-fields")]).default(false).describe("Whether to ignore classes that implement interfaces. Set to 'public-fields' to only ignore public members."),
-		ignoreOverrideMethods: z.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 };
-
-//# sourceMappingURL=classMethodsThis.js.map

package/lib/rules/combinedPushes.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=combinedPushes.d.ts.map

package/lib/rules/combinedPushes.js

@@ -1,56 +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 };
-
-//# sourceMappingURL=combinedPushes.js.map

package/lib/rules/consecutiveNonNullAssertions.d.ts

@@ -1,10 +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;
-//# sourceMappingURL=consecutiveNonNullAssertions.d.ts.map

package/lib/rules/consecutiveNonNullAssertions.js

@@ -1,39 +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 };
-
-//# sourceMappingURL=consecutiveNonNullAssertions.js.map

package/lib/rules/consoleCalls.d.ts

@@ -1,9 +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;
-//# sourceMappingURL=consoleCalls.d.ts.map

package/lib/rules/consoleCalls.js

@@ -1,28 +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, { sourceFile, typeChecker }) => {
-			if (!ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.expression) || node.expression.expression.text !== "console" || !isGlobalVariable(node.expression.expression, typeChecker)) return;
-			context.report({
-				message: "noConsole",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { consoleCalls_default as default };
-
-//# sourceMappingURL=consoleCalls.js.map

package/lib/rules/constantAssignments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports attempting to reassign variables declared with const.";
-    readonly id: "constantAssignments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noConstAssign", undefined>;
-export default _default;
-//# sourceMappingURL=constantAssignments.d.ts.map

package/lib/rules/constantAssignments.js

@@ -1,41 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/constantAssignments.ts
-var constantAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports attempting to reassign variables declared with const.",
-		id: "constantAssignments",
-		presets: ["javascript"]
-	},
-	messages: { noConstAssign: {
-		primary: "Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.",
-		secondary: ["The const keyword creates a read-only reference to a value, preventing reassignment.", "While properties of const objects and elements of const arrays can be mutated, the binding itself cannot be reassigned."],
-		suggestions: ["Use let instead of const if you need to reassign the variable."]
-	} },
-	setup(context) {
-		function collectBindingElements(name) {
-			if (name.kind === SyntaxKind.Identifier) return [name];
-			const identifiers = [];
-			for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) identifiers.push(...collectBindingElements(element.name));
-			return identifiers;
-		}
-		return { visitors: { VariableDeclarationList: (node, { sourceFile }) => {
-			if (!(node.flags & ts.NodeFlags.Const) || !node.declarations.length) return;
-			for (const declaration of node.declarations) {
-				const identifiers = collectBindingElements(declaration.name);
-				for (const identifier of identifiers) {
-					const modifyingReferences = getModifyingReferences(identifier, sourceFile);
-					for (const reference of modifyingReferences) context.report({
-						message: "noConstAssign",
-						range: getTSNodeRange(reference, sourceFile)
-					});
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { constantAssignments_default as default };
-
-//# sourceMappingURL=constantAssignments.js.map

package/lib/rules/constructorGenericCalls.d.ts

@@ -1,16 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports inconsistent placement of type arguments in constructor calls.";
-    readonly id: "constructorGenericCalls";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferConstructor" | "preferTypeAnnotation", {
-    style: z.ZodDefault<z.ZodEnum<{
-        constructor: "constructor";
-        "type-annotation": "type-annotation";
-    }>>;
-}>;
-export default _default;
-//# sourceMappingURL=constructorGenericCalls.d.ts.map

package/lib/rules/constructorGenericCalls.js

@@ -1,138 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z } from "zod/v4";
-//#region src/rules/constructorGenericCalls.ts
-const builtInTypedArrays = new Set([
-	"Float32Array",
-	"Float64Array",
-	"Int8Array",
-	"Int16Array",
-	"Int32Array",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Uint16Array",
-	"Uint32Array"
-]);
-function getTypeArgumentsRange(parent, typeArguments, sourceFile) {
-	const children = parent.getChildren(sourceFile);
-	let begin = typeArguments.pos;
-	let end = typeArguments.end;
-	for (const child of children) if (child.kind === ts.SyntaxKind.LessThanToken) begin = child.getStart(sourceFile);
-	else if (child.kind === ts.SyntaxKind.GreaterThanToken) end = child.getEnd();
-	return {
-		begin,
-		end
-	};
-}
-function getTypeArgumentsText(parent, typeArguments, sourceFile) {
-	const range = getTypeArgumentsRange(parent, typeArguments, sourceFile);
-	return sourceFile.text.slice(range.begin, range.end);
-}
-function isBuiltInTypedArray(name) {
-	return builtInTypedArrays.has(name);
-}
-const options = { style: z.enum(["constructor", "type-annotation"]).default("constructor").describe("Where to prefer type arguments: 'constructor' for the constructor call, 'type-annotation' for the type annotation.") };
-var constructorGenericCalls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports inconsistent placement of type arguments in constructor calls.",
-		id: "constructorGenericCalls",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferConstructor: {
-			primary: "Prefer specifying the type argument on the constructor call instead of the type annotation.",
-			secondary: ["When type arguments are needed, specifying them on the constructor is more explicit.", "This makes the code more readable by keeping the type information with the value."],
-			suggestions: ["Move the type argument from the type annotation to the constructor call."]
-		},
-		preferTypeAnnotation: {
-			primary: "Prefer specifying the type argument on the type annotation instead of the constructor call.",
-			secondary: ["Specifying type arguments on the type annotation keeps the variable's type explicit.", "This approach can make refactoring easier when changing the right-hand side."],
-			suggestions: ["Move the type argument from the constructor call to the type annotation."]
-		}
-	},
-	options,
-	setup(context) {
-		function checkNode(node, { options, sourceFile }) {
-			const identifier = node.name;
-			const typeAnnotation = node.type;
-			const initializer = node.initializer;
-			const style = options.style;
-			if (!initializer || !ts.isNewExpression(initializer) || !ts.isIdentifier(initializer.expression)) return;
-			const constructorName = initializer.expression.text;
-			if (!typeAnnotation) {
-				if (style === "type-annotation" && initializer.typeArguments) {
-					const typeArgsText = getTypeArgumentsText(initializer, initializer.typeArguments, sourceFile);
-					const identifierEnd = identifier.getEnd();
-					const typeAnnotationText = `${constructorName}${typeArgsText}`;
-					const typeArgumentsRange = getTypeArgumentsRange(initializer, initializer.typeArguments, sourceFile);
-					context.report({
-						fix: [{
-							range: typeArgumentsRange,
-							text: ""
-						}, {
-							range: {
-								begin: identifierEnd,
-								end: identifierEnd
-							},
-							text: `: ${typeAnnotationText}`
-						}],
-						message: "preferTypeAnnotation",
-						range: typeArgumentsRange
-					});
-				}
-				return;
-			}
-			if (!ts.isTypeReferenceNode(typeAnnotation) || !ts.isIdentifier(typeAnnotation.typeName) || typeAnnotation.typeName.text !== constructorName || isBuiltInTypedArray(typeAnnotation.typeName.text) || !!typeAnnotation.typeArguments !== !initializer.typeArguments) return;
-			if (style === "constructor" && typeAnnotation.typeArguments && !initializer.typeArguments) {
-				const typeArgsText = getTypeArgumentsText(typeAnnotation, typeAnnotation.typeArguments, sourceFile);
-				const typeArgsRange = getTypeArgumentsRange(typeAnnotation, typeAnnotation.typeArguments, sourceFile);
-				const constructorEnd = initializer.expression.getEnd();
-				const hasParens = initializer.arguments !== void 0;
-				context.report({
-					fix: [{
-						range: {
-							begin: typeAnnotation.getStart(sourceFile),
-							end: typeAnnotation.getEnd()
-						},
-						text: constructorName
-					}, {
-						range: {
-							begin: constructorEnd,
-							end: constructorEnd
-						},
-						text: typeArgsText + (hasParens ? "" : "()")
-					}],
-					message: "preferConstructor",
-					range: typeArgsRange
-				});
-			} else if (style === "type-annotation" && !typeAnnotation.typeArguments && initializer.typeArguments) {
-				const typeArgumentsText = getTypeArgumentsText(initializer, initializer.typeArguments, sourceFile);
-				const typeArgumentsRange = getTypeArgumentsRange(initializer, initializer.typeArguments, sourceFile);
-				const newTypeAnnotation = `${typeAnnotation.typeName.text}${typeArgumentsText}`;
-				context.report({
-					fix: [{
-						range: {
-							begin: typeAnnotation.getStart(sourceFile),
-							end: typeAnnotation.getEnd()
-						},
-						text: newTypeAnnotation
-					}, {
-						range: typeArgumentsRange,
-						text: ""
-					}],
-					message: "preferTypeAnnotation",
-					range: typeArgumentsRange
-				});
-			}
-		}
-		return { visitors: {
-			PropertyDeclaration: checkNode,
-			VariableDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { constructorGenericCalls_default as default };
-
-//# sourceMappingURL=constructorGenericCalls.js.map

package/lib/rules/constructorReturns.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports returning values from constructor functions.";
-    readonly id: "constructorReturns";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noConstructorReturn", undefined>;
-export default _default;
-//# sourceMappingURL=constructorReturns.d.ts.map

package/lib/rules/constructorReturns.js

@@ -1,41 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/constructorReturns.ts
-var constructorReturns_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports returning values from constructor functions.",
-		id: "constructorReturns",
-		presets: ["javascript"]
-	},
-	messages: { noConstructorReturn: {
-		primary: "Returning a value from a constructor function overrides the newly created instance.",
-		secondary: ["This behavior is often unintentional and can lead to unexpected results.", "If you need to return a different object, consider using a factory function instead."],
-		suggestions: ["Remove the return statement, or return without a value to exit early."]
-	} },
-	setup(context) {
-		return { visitors: { Constructor: (node, { sourceFile }) => {
-			if (!node.body) return;
-			function checkForReturnStatements(node) {
-				if (ts.isReturnStatement(node)) {
-					if (node.expression) context.report({
-						message: "noConstructorReturn",
-						range: {
-							begin: node.getStart(sourceFile),
-							end: node.getEnd()
-						}
-					});
-					return;
-				}
-				if (tsutils.isFunctionScopeBoundary(node)) return;
-				ts.forEachChild(node, checkForReturnStatements);
-			}
-			ts.forEachChild(node.body, checkForReturnStatements);
-		} } };
-	}
-});
-//#endregion
-export { constructorReturns_default as default };
-
-//# sourceMappingURL=constructorReturns.js.map

package/lib/rules/constructorSupers.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.";
-    readonly id: "constructorSupers";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingSuperCall" | "unexpectedSuperCall", undefined>;
-export default _default;
-//# sourceMappingURL=constructorSupers.d.ts.map

package/lib/rules/constructorSupers.js

@@ -1,77 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/constructorSupers.ts
-function classHasExtendsClause(node) {
-	return node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
-}
-function containsSuperCall(node) {
-	if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword) return true;
-	if (tsutils.isFunctionScopeBoundary(node)) return false;
-	return ts.forEachChild(node, containsSuperCall) ?? false;
-}
-var constructorSupers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.",
-		id: "constructorSupers",
-		presets: ["javascript"]
-	},
-	messages: {
-		missingSuperCall: {
-			primary: "Constructors of derived classes must call `super()` before using `this` or returning.",
-			secondary: ["The derived class constructor must initialize the parent class by calling `super()` before accessing `this`.", "Failing to call `super()` in a derived class constructor causes a runtime error."],
-			suggestions: ["Add a `super()` call at the beginning of the constructor.", "Pass required arguments to `super()` if the parent constructor expects them."]
-		},
-		unexpectedSuperCall: {
-			primary: "Constructors of non-derived classes must not call `super()`.",
-			secondary: ["This class does not extend another class, so there is no parent constructor to call.", "Calling `super()` in a non-derived class causes a syntax error."],
-			suggestions: ["Remove the `super()` call.", "If this class should inherit from another class, add an `extends` clause."]
-		}
-	},
-	setup(context) {
-		function checkConstructor(classNode, constructor, sourceFile) {
-			if (!constructor.body) return;
-			const isDerivedClass = classHasExtendsClause(classNode) ?? false;
-			const hasSuperCall = containsSuperCall(constructor.body);
-			if (isDerivedClass && !hasSuperCall) {
-				const constructorKeyword = constructor.getChildren(sourceFile).find((child) => child.kind === ts.SyntaxKind.Constructor);
-				context.report({
-					message: "missingSuperCall",
-					range: {
-						begin: constructorKeyword?.getStart(sourceFile) ?? constructor.getStart(sourceFile),
-						end: constructorKeyword?.getEnd() ?? constructor.getStart(sourceFile) + 11
-					}
-				});
-			}
-			if (!isDerivedClass && hasSuperCall) findAndReportSuperCalls(constructor.body, sourceFile);
-		}
-		function findAndReportSuperCalls(node, sourceFile) {
-			if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword) {
-				context.report({
-					message: "unexpectedSuperCall",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-				return;
-			}
-			if (tsutils.isFunctionScopeBoundary(node)) return;
-			ts.forEachChild(node, (child) => {
-				findAndReportSuperCalls(child, sourceFile);
-			});
-		}
-		function checkClass(node, { sourceFile }) {
-			for (const member of node.members) if (member.kind === ts.SyntaxKind.Constructor) checkConstructor(node, member, sourceFile);
-		}
-		return { visitors: {
-			ClassDeclaration: checkClass,
-			ClassExpression: checkClass
-		} };
-	}
-});
-//#endregion
-export { constructorSupers_default as default };
-
-//# sourceMappingURL=constructorSupers.js.map

package/lib/rules/dateConstructorClones.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.";
-    readonly id: "dateConstructorClones";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryGetTime", undefined>;
-export default _default;
-//# sourceMappingURL=dateConstructorClones.d.ts.map