@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/constantAssignments.d.ts

@@ -1,9 +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;

package/lib/rules/constantAssignments.js

@@ -1,39 +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 };

package/lib/rules/constructorGenericCalls.d.ts

@@ -1,15 +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;

package/lib/rules/constructorGenericCalls.js

@@ -1,136 +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/constructorGenericCalls.ts
-const builtInTypedArrays = /* @__PURE__ */ 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$1.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 };

package/lib/rules/constructorReturns.d.ts

@@ -1,9 +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;

package/lib/rules/constructorReturns.js

@@ -1,39 +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 };

package/lib/rules/constructorSupers.d.ts

@@ -1,9 +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;

package/lib/rules/constructorSupers.js

@@ -1,75 +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 };

package/lib/rules/dateConstructorClones.d.ts

@@ -1,9 +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;

package/lib/rules/dateConstructorClones.js

@@ -1,35 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/dateConstructorClones.ts
-function isDateType(node, typeChecker) {
-	return typeChecker.getTypeAtLocation(node).getSymbol()?.getName() === "Date";
-}
-var dateConstructorClones_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.",
-		id: "dateConstructorClones",
-		presets: ["logical"]
-	},
-	messages: { unnecessaryGetTime: {
-		primary: "Prefer passing the Date directly instead of calling getTime().",
-		secondary: ["The Date constructor can clone a Date object directly when passed as an argument.", "Calling getTime() first is unnecessary since ES2015."],
-		suggestions: ["Remove the `.getTime()` call and pass the Date directly."]
-	} },
-	setup(context) {
-		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "Date" || node.arguments?.length !== 1 || !isGlobalDeclarationOfName(node.expression, "Date", typeChecker, program)) return;
-			const argument = node.arguments[0];
-			if (argument.kind !== SyntaxKind.CallExpression || argument.expression.kind !== SyntaxKind.PropertyAccessExpression || argument.expression.name.kind !== SyntaxKind.Identifier || argument.expression.name.text !== "getTime" || !!argument.arguments.length || !isDateType(argument.expression.expression, typeChecker)) return;
-			context.report({
-				message: "unnecessaryGetTime",
-				range: {
-					begin: argument.expression.name.getStart(sourceFile),
-					end: argument.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { dateConstructorClones_default as default };

package/lib/rules/dateNowTimestamps.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.";
-    readonly id: "dateNowTimestamps";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferDateNow", undefined>;
-export default _default;

package/lib/rules/dateNowTimestamps.js

@@ -1,55 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/dateNowTimestamps.ts
-var dateNowTimestamps_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.",
-		id: "dateNowTimestamps",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferDateNow: {
-		primary: "Prefer the shorter `Date.now()` to get the current timestamp.",
-		secondary: ["`Date.now()` is shorter and avoids unnecessary instantiation of `Date` objects.", "It's more efficient and clearer than alternatives like `new Date().getTime()`."],
-		suggestions: ["Replace with `Date.now()`."]
-	} },
-	setup(context) {
-		function isNewDateWithNoArguments(node, typeChecker, program) {
-			return node.expression.kind === SyntaxKind.Identifier && node.expression.text === "Date" && !node.arguments?.length && isGlobalDeclarationOfName(node.expression, "Date", typeChecker, program);
-		}
-		return { visitors: {
-			CallExpression: (node, { program, sourceFile, typeChecker }) => {
-				if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier || !!node.arguments.length) return;
-				const methodName = node.expression.name.text;
-				if (methodName !== "getTime" && methodName !== "valueOf") return;
-				if (node.expression.expression.kind !== SyntaxKind.NewExpression || !isNewDateWithNoArguments(node.expression.expression, typeChecker, program)) return;
-				context.report({
-					message: "preferDateNow",
-					range: {
-						begin: node.expression.expression.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-			},
-			NewExpression: (node, { program, sourceFile, typeChecker }) => {
-				if (!isNewDateWithNoArguments(node, typeChecker, program)) return;
-				switch (node.parent.kind) {
-					case SyntaxKind.CallExpression:
-						if (node.parent.expression.kind === SyntaxKind.Identifier && (node.parent.expression.text === "BigInt" || node.parent.expression.text === "Number") && node.parent.arguments.length === 1 && isGlobalDeclarationOfName(node.parent.expression, node.parent.expression.text, typeChecker, program)) context.report({
-							message: "preferDateNow",
-							range: getTSNodeRange(node.parent, sourceFile)
-						});
-						break;
-					case SyntaxKind.PrefixUnaryExpression:
-						if (node.parent.operator === SyntaxKind.MinusToken || node.parent.operator === SyntaxKind.PlusToken) context.report({
-							message: "preferDateNow",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						break;
-				}
-			}
-		} };
-	}
-});
-//#endregion
-export { dateNowTimestamps_default as default };

package/lib/rules/debuggerStatements.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using debugger statements.";
-    readonly id: "debuggerStatements";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noDebugger", undefined>;
-export default _default;

package/lib/rules/debuggerStatements.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/debuggerStatements.ts
-var debuggerStatements_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using debugger statements.",
-		id: "debuggerStatements",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noDebugger: {
-		primary: "Debugger statements should not be used in production code.",
-		secondary: ["The `debugger` statement causes the JavaScript runtime to pause execution and start a debugger if one is available, such as when browser developer tools are open.", "This can be useful during development, but should not be left in production code."],
-		suggestions: ["Remove the `debugger` statement before shipping this code to users."]
-	} },
-	setup(context) {
-		return { visitors: { DebuggerStatement: (node, { sourceFile }) => {
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				message: "noDebugger",
-				range,
-				suggestions: [{
-					id: "removeDebugger",
-					range,
-					text: ""
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { debuggerStatements_default as default };

package/lib/rules/defaultCaseLast.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports switch statements where the default clause is not last.";
-    readonly id: "defaultCaseLast";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "defaultCaseShouldBeLast", undefined>;
-export default _default;

package/lib/rules/defaultCaseLast.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/defaultCaseLast.ts
-var defaultCaseLast_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports switch statements where the default clause is not last.",
-		id: "defaultCaseLast",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { defaultCaseShouldBeLast: {
-		primary: "Default clauses in switch statements should be last.",
-		secondary: ["Placing the default clause in a position other than last can lead to confusion and unexpected behavior.", "While the default clause is executed when no case matches, having it in the middle of other cases makes the control flow harder to follow."],
-		suggestions: ["Move the default clause to the end of the switch statement to improve code clarity."]
-	} },
-	setup(context) {
-		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
-			const clauses = node.caseBlock.clauses;
-			const defaultClauseIndex = clauses.findIndex((clause) => clause.kind === SyntaxKind.DefaultClause);
-			if (defaultClauseIndex === -1 || defaultClauseIndex === clauses.length - 1) return;
-			const defaultClause = nullThrows(clauses[defaultClauseIndex], "Default clause is expected to be present by prior length check");
-			context.report({
-				message: "defaultCaseShouldBeLast",
-				range: {
-					begin: defaultClause.getStart(sourceFile),
-					end: defaultClause.getStart(sourceFile) + 7
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { defaultCaseLast_default as default };

package/lib/rules/defaultParameterLast.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforce default parameters to be last.";
-    readonly id: "defaultParameterLast";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "defaultParameterLast", undefined>;
-export default _default;

package/lib/rules/defaultParameterLast.js

@@ -1,40 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/defaultParameterLast.ts
-var defaultParameterLast_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforce default parameters to be last.",
-		id: "defaultParameterLast",
-		presets: ["javascript"]
-	},
-	messages: { defaultParameterLast: {
-		primary: "Default parameters should be last to allow omitting optional tail arguments.",
-		secondary: ["Putting default parameters last allows function calls to omit optional tail arguments.", "Non-default parameters after default ones must always be explicitly provided."],
-		suggestions: ["Move the default parameter to the end of the parameter list."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			let hasSeenDefaultParameter = false;
-			for (const parameter of node.parameters) {
-				if (parameter.dotDotDotToken) continue;
-				if (parameter.questionToken || parameter.initializer) {
-					hasSeenDefaultParameter = true;
-					continue;
-				}
-				if (hasSeenDefaultParameter) context.report({
-					message: "defaultParameterLast",
-					range: getTSNodeRange(parameter, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			ArrowFunction: checkNode,
-			Constructor: checkNode,
-			FunctionDeclaration: checkNode,
-			FunctionExpression: checkNode,
-			MethodDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { defaultParameterLast_default as default };

package/lib/rules/deprecated.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallow using code marked as @deprecated.";
-    readonly id: "deprecated";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "deprecated", undefined>;
-export default _default;