@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/dateConstructorClones.js

@@ -1,37 +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, { sourceFile, typeChecker }) => {
-			if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "Date" || node.arguments?.length !== 1 || !isGlobalDeclarationOfName(node.expression, "Date", typeChecker)) 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 };
-
-//# sourceMappingURL=dateConstructorClones.js.map

package/lib/rules/dateNowTimestamps.d.ts

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

package/lib/rules/dateNowTimestamps.js

@@ -1,57 +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) {
-			return node.expression.kind === SyntaxKind.Identifier && node.expression.text === "Date" && !node.arguments?.length && isGlobalDeclarationOfName(node.expression, "Date", typeChecker);
-		}
-		return { visitors: {
-			CallExpression: (node, { 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)) return;
-				context.report({
-					message: "preferDateNow",
-					range: {
-						begin: node.expression.expression.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-			},
-			NewExpression: (node, { sourceFile, typeChecker }) => {
-				if (!isNewDateWithNoArguments(node, typeChecker)) 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)) 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 };
-
-//# sourceMappingURL=dateNowTimestamps.js.map

package/lib/rules/debuggerStatements.d.ts

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

package/lib/rules/debuggerStatements.js

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

package/lib/rules/defaultCaseLast.d.ts

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

package/lib/rules/defaultCaseLast.js

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

package/lib/rules/defaultParameterLast.d.ts

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

package/lib/rules/defaultParameterLast.js

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

package/lib/rules/deprecated.d.ts

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

package/lib/rules/deprecated.js

@@ -1,243 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/deprecated.ts
-var deprecated_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallow using code marked as @deprecated.",
-		id: "deprecated",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { deprecated: {
-		primary: "This is deprecated.",
-		secondary: ["The @deprecated JSDoc tag indicates this code should no longer be used.", "Deprecated code may be removed in future versions."],
-		suggestions: ["Find a non-deprecated alternative."]
-	} },
-	setup(context) {
-		function getJsDocDeprecation(symbol, typeChecker) {
-			if (!symbol) return false;
-			let jsDocTags;
-			try {
-				jsDocTags = symbol.getJsDocTags(typeChecker);
-			} catch {
-				return false;
-			}
-			return jsDocTags.some((tag) => tag.name === "deprecated");
-		}
-		function isDeprecatedFromDeclarations(symbol) {
-			return symbol?.getDeclarations()?.some((declaration) => {
-				return ts$1.getJSDocTags(declaration).some((tag) => tag.tagName.text === "deprecated" || tag.tagName.text === "Deprecated");
-			});
-		}
-		function searchForDeprecationInAliasesChain(symbol, typeChecker, checkAliasedSymbol) {
-			if (!symbol) return false;
-			if (!(symbol.flags & ts$1.SymbolFlags.Alias)) return !!(checkAliasedSymbol && (getJsDocDeprecation(symbol, typeChecker) || isDeprecatedFromDeclarations(symbol)));
-			const targetSymbol = typeChecker.getAliasedSymbol(symbol);
-			let current = symbol;
-			while (current.flags & ts$1.SymbolFlags.Alias) {
-				if (getJsDocDeprecation(current, typeChecker) || isDeprecatedFromDeclarations(current)) return true;
-				if (!current.getDeclarations()) break;
-				const immediateAliased = typeChecker.getImmediateAliasedSymbol(current);
-				if (!immediateAliased) break;
-				current = immediateAliased;
-				if (checkAliasedSymbol && current === targetSymbol) return !!(getJsDocDeprecation(current, typeChecker) || isDeprecatedFromDeclarations(current));
-			}
-			return false;
-		}
-		function isDeprecated(symbol, typeChecker) {
-			return searchForDeprecationInAliasesChain(symbol, typeChecker, true);
-		}
-		function isDeclarationSite(node) {
-			switch (node.parent.kind) {
-				case ts$1.SyntaxKind.ArrowFunction:
-				case ts$1.SyntaxKind.ClassDeclaration:
-				case ts$1.SyntaxKind.Constructor:
-				case ts$1.SyntaxKind.EnumDeclaration:
-				case ts$1.SyntaxKind.EnumMember:
-				case ts$1.SyntaxKind.FunctionDeclaration:
-				case ts$1.SyntaxKind.FunctionExpression:
-				case ts$1.SyntaxKind.GetAccessor:
-				case ts$1.SyntaxKind.InterfaceDeclaration:
-				case ts$1.SyntaxKind.MethodDeclaration:
-				case ts$1.SyntaxKind.MethodSignature:
-				case ts$1.SyntaxKind.ModuleDeclaration:
-				case ts$1.SyntaxKind.Parameter:
-				case ts$1.SyntaxKind.PropertyDeclaration:
-				case ts$1.SyntaxKind.PropertySignature:
-				case ts$1.SyntaxKind.SetAccessor:
-				case ts$1.SyntaxKind.TypeAliasDeclaration:
-				case ts$1.SyntaxKind.TypeParameter:
-				case ts$1.SyntaxKind.VariableDeclaration: return node.parent.name === node;
-				case ts$1.SyntaxKind.ExportSpecifier: return node.parent.propertyName === node;
-				case ts$1.SyntaxKind.ImportClause:
-				case ts$1.SyntaxKind.ImportSpecifier:
-				case ts$1.SyntaxKind.NamespaceImport: return true;
-				case ts$1.SyntaxKind.PropertyAssignment: return node.parent.name === node && !ts$1.isComputedPropertyName(node.parent.name) && ts$1.isObjectLiteralExpression(node.parent.parent);
-			}
-		}
-		function getCallLikeExpression(node) {
-			let current = node;
-			while (ts$1.isPropertyAccessExpression(current.parent) && current.parent.name === current) current = current.parent;
-			while (ts$1.isElementAccessExpression(current.parent) && current.parent.argumentExpression === current) current = current.parent;
-			switch (current.parent.kind) {
-				case ts$1.SyntaxKind.CallExpression:
-				case ts$1.SyntaxKind.Decorator:
-				case ts$1.SyntaxKind.NewExpression: return current.parent.expression === current && current.parent;
-				case ts$1.SyntaxKind.TaggedTemplateExpression: return current.parent.tag === current && current.parent;
-			}
-		}
-		function getCallLikeDeprecation(node, callLike, typeChecker) {
-			const signature = typeChecker.getResolvedSignature(callLike);
-			const symbol = typeChecker.getSymbolAtLocation(node);
-			const aliasedSymbol = symbol && symbol.flags & ts$1.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol) : symbol;
-			const symbolDeclarationKind = aliasedSymbol?.declarations?.[0]?.kind;
-			if (symbolDeclarationKind !== ts$1.SyntaxKind.MethodDeclaration && symbolDeclarationKind !== ts$1.SyntaxKind.FunctionDeclaration && symbolDeclarationKind !== ts$1.SyntaxKind.MethodSignature) return searchForDeprecationInAliasesChain(symbol, typeChecker, true) || getJsDocDeprecation(signature, typeChecker) || isDeprecatedFromDeclarations(aliasedSymbol);
-			return searchForDeprecationInAliasesChain(symbol, typeChecker, false) || getJsDocDeprecation(signature, typeChecker);
-		}
-		function checkNode(node, sourceFile, typeChecker) {
-			if (isDeclarationSite(node) || isInsideImport(node)) return;
-			const callLike = getCallLikeExpression(node);
-			if (callLike) {
-				if (getCallLikeDeprecation(node, callLike, typeChecker)) context.report({
-					message: "deprecated",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (ts$1.isShorthandPropertyAssignment(node.parent) && node.parent.name === node) {
-				const symbol = typeChecker.getSymbolAtLocation(node);
-				const valueSymbol = symbol && typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
-				if (valueSymbol && (getJsDocDeprecation(valueSymbol, typeChecker) || isDeprecatedFromDeclarations(valueSymbol))) context.report({
-					message: "deprecated",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (isDeprecated(typeChecker.getSymbolAtLocation(node), typeChecker)) context.report({
-				message: "deprecated",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		function checkComputedPropertyAccess(node, sourceFile, typeChecker) {
-			const argumentExpression = node.argumentExpression;
-			const argumentType = typeChecker.getTypeAtLocation(argumentExpression);
-			if (!argumentType.isLiteral()) return;
-			const objectType = typeChecker.getTypeAtLocation(node.expression);
-			let propertyName;
-			if (argumentType.isStringLiteral()) propertyName = argumentType.value;
-			else if (argumentType.isNumberLiteral()) propertyName = String(argumentType.value);
-			else return;
-			const property = objectType.getProperty(propertyName);
-			if (property && (getJsDocDeprecation(property, typeChecker) || isDeprecatedFromDeclarations(property))) context.report({
-				message: "deprecated",
-				range: getTSNodeRange(argumentExpression, sourceFile)
-			});
-		}
-		function checkBindingElement(node, sourceFile, typeChecker) {
-			const bindingPattern = node.parent;
-			if (!ts$1.isObjectBindingPattern(bindingPattern)) return;
-			const propertyName = node.propertyName ?? node.name;
-			if (!ts$1.isIdentifier(propertyName)) return;
-			const declarationOrPattern = bindingPattern.parent;
-			let objectType;
-			if (ts$1.isVariableDeclaration(declarationOrPattern)) {
-				const initializer = declarationOrPattern.initializer;
-				if (initializer) objectType = typeChecker.getTypeAtLocation(initializer);
-			} else if (ts$1.isBindingElement(declarationOrPattern)) {
-				const parentInitializer = declarationOrPattern.parent.parent;
-				if (ts$1.isVariableDeclaration(parentInitializer)) {
-					const init = parentInitializer.initializer;
-					if (init) {
-						const parentType = typeChecker.getTypeAtLocation(init);
-						const parentPropertyName = declarationOrPattern.propertyName ?? declarationOrPattern.name;
-						if (ts$1.isIdentifier(parentPropertyName)) {
-							const prop = parentType.getProperty(parentPropertyName.text);
-							if (prop) objectType = typeChecker.getTypeOfSymbolAtLocation(prop, parentInitializer);
-						}
-					}
-				}
-			}
-			if (objectType) {
-				const property = objectType.getProperty(propertyName.text);
-				if (property && (getJsDocDeprecation(property, typeChecker) || isDeprecatedFromDeclarations(property))) {
-					const reportNode = node.propertyName ?? node.name;
-					if (ts$1.isIdentifier(reportNode)) context.report({
-						message: "deprecated",
-						range: getTSNodeRange(reportNode, sourceFile)
-					});
-				}
-			}
-		}
-		function checkHeritageClause(node, sourceFile, typeChecker) {
-			for (const type of node.types) if (ts$1.isIdentifier(type.expression)) {
-				if (isDeprecated(typeChecker.getSymbolAtLocation(type.expression), typeChecker)) context.report({
-					message: "deprecated",
-					range: getTSNodeRange(type.expression, sourceFile)
-				});
-			}
-		}
-		function checkSuperCall(node, sourceFile, typeChecker) {
-			const callExpr = node.parent;
-			if (!ts$1.isCallExpression(callExpr) || callExpr.expression !== node) return;
-			const signature = typeChecker.getResolvedSignature(callExpr);
-			if (signature && getJsDocDeprecation(signature, typeChecker)) context.report({
-				message: "deprecated",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			BindingElement: (node, { sourceFile, typeChecker }) => {
-				checkBindingElement(node, sourceFile, typeChecker);
-			},
-			ElementAccessExpression: (node, { sourceFile, typeChecker }) => {
-				checkComputedPropertyAccess(node, sourceFile, typeChecker);
-			},
-			HeritageClause: (node, { sourceFile, typeChecker }) => {
-				checkHeritageClause(node, sourceFile, typeChecker);
-			},
-			Identifier: (node, { sourceFile, typeChecker }) => {
-				if (isInsideHeritageClause(node)) return;
-				if (ts$1.isPropertyAccessExpression(node.parent) && node === node.parent.name) {
-					checkNode(node, sourceFile, typeChecker);
-					return;
-				}
-				if (ts$1.isQualifiedName(node.parent) && node === node.parent.right) {
-					checkNode(node, sourceFile, typeChecker);
-					return;
-				}
-				if (ts$1.isElementAccessExpression(node.parent) && node === node.parent.argumentExpression) return;
-				checkNode(node, sourceFile, typeChecker);
-			},
-			PrivateIdentifier: (node, { sourceFile, typeChecker }) => {
-				if (ts$1.isPropertyAccessExpression(node.parent) && node === node.parent.name) checkNode(node, sourceFile, typeChecker);
-			},
-			SuperKeyword: (node, { sourceFile, typeChecker }) => {
-				checkSuperCall(node, sourceFile, typeChecker);
-			}
-		} };
-	}
-});
-function isInsideHeritageClause(node) {
-	if (ts$1.isHeritageClause(node)) return true;
-	let current = node.parent;
-	while (current) {
-		if (ts$1.isHeritageClause(current)) return true;
-		if (ts$1.isSourceFile(current) || ts$1.isClassDeclaration(current)) break;
-		current = current.parent;
-	}
-	return false;
-}
-function isInsideImport(node) {
-	if (ts$1.isImportDeclaration(node)) return true;
-	let current = node.parent;
-	while (current) {
-		if (ts$1.isImportDeclaration(current)) return true;
-		if (ts$1.isSourceFile(current) || ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isClassDeclaration(current) || ts$1.isClassExpression(current) || ts$1.isBlock(current)) return false;
-		current = current.parent;
-	}
-	return false;
-}
-//#endregion
-export { deprecated_default as default };
-
-//# sourceMappingURL=deprecated.js.map

package/lib/rules/destructuringConsistency.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Use destructured variables over properties for consistency.";
-    readonly id: "destructuringConsistency";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useDestructured", undefined>;
-export default _default;
-//# sourceMappingURL=destructuringConsistency.d.ts.map

package/lib/rules/destructuringConsistency.js

@@ -1,112 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/destructuringConsistency.ts
-function getContainingScope(node) {
-	let current = node;
-	while (current) {
-		if (ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isMethodDeclaration(current) || ts$1.isBlock(current) || ts$1.isForStatement(current) || ts$1.isForOfStatement(current) || ts$1.isForInStatement(current) || ts$1.isSourceFile(current)) return current;
-		current = current.parent;
-	}
-}
-function isInScope(accessScope, declarationScope) {
-	if (!declarationScope) return true;
-	let current = accessScope;
-	while (current) {
-		if (current === declarationScope) return true;
-		current = current.parent;
-	}
-	return false;
-}
-function getInitializerKey(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.Identifier: return node.text;
-		case ts$1.SyntaxKind.PropertyAccessExpression: {
-			if (node.questionDotToken) return;
-			const objectKey = getInitializerKey(node.expression);
-			if (!objectKey) return;
-			return `${objectKey}.${node.name.text}`;
-		}
-		case ts$1.SyntaxKind.ThisKeyword: return "this";
-	}
-}
-function isLeftHandSide(node) {
-	switch (node.parent.kind) {
-		case ts$1.SyntaxKind.BinaryExpression: return node.parent.left === node && node.parent.operatorToken.kind >= ts$1.SyntaxKind.FirstAssignment && node.parent.operatorToken.kind <= ts$1.SyntaxKind.LastAssignment;
-		case ts$1.SyntaxKind.DeleteExpression: return true;
-		case ts$1.SyntaxKind.PostfixUnaryExpression:
-		case ts$1.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts$1.SyntaxKind.PlusPlusToken || node.parent.operator === ts$1.SyntaxKind.MinusMinusToken;
-		default: return false;
-	}
-}
-var destructuringConsistency_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Use destructured variables over properties for consistency.",
-		id: "destructuringConsistency",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { useDestructured: {
-		primary: "Use the destructured variable instead of accessing the property again.",
-		secondary: ["After destructuring an object, access properties through the destructured variables.", "Mixing destructured variables with property access on the same object is inconsistent."],
-		suggestions: ["Replace `{{ expression }}` with `{{ variable }}`."]
-	} },
-	setup(context) {
-		const destructuredObjects = [];
-		function collectDestructuredProperties(node) {
-			if (!node.initializer || !ts$1.isObjectBindingPattern(node.name)) return;
-			const initKey = getInitializerKey(node.initializer);
-			if (!initKey) return;
-			const properties = /* @__PURE__ */ new Map();
-			for (const element of node.name.elements) {
-				if (!ts$1.isBindingElement(element)) continue;
-				if (element.propertyName) {
-					if (ts$1.isIdentifier(element.propertyName)) {
-						if (ts$1.isObjectBindingPattern(element.name) || ts$1.isArrayBindingPattern(element.name)) properties.set(element.propertyName.text, null);
-						else if (ts$1.isIdentifier(element.name)) properties.set(element.propertyName.text, element.name.text);
-					}
-				} else if (ts$1.isIdentifier(element.name)) properties.set(element.name.text, element.name.text);
-			}
-			if (properties.size) destructuredObjects.push({
-				declarationEnd: node.getEnd(),
-				destructuredProperties: properties,
-				initKey,
-				scope: getContainingScope(node)
-			});
-		}
-		return { visitors: {
-			PropertyAccessExpression: (node, { sourceFile }) => {
-				if (node.questionDotToken) return;
-				const accessKey = getInitializerKey(node.expression);
-				if (!accessKey) return;
-				const accessScope = getContainingScope(node);
-				const destructured = destructuredObjects.find((object) => object.initKey === accessKey && node.getStart(sourceFile) >= object.declarationEnd && isInScope(accessScope, object.scope));
-				if (!destructured) return;
-				const propertyName = node.name.text;
-				if (!destructured.destructuredProperties.has(propertyName)) return;
-				const variableName = destructured.destructuredProperties.get(propertyName);
-				if (ts$1.isCallExpression(node.parent) && node.parent.expression === node || isLeftHandSide(node)) return;
-				const range = getTSNodeRange(node, sourceFile);
-				const expression = node.getText(sourceFile);
-				const [variable, suggestions] = variableName ? [variableName, [{
-					id: "useDestructuredVariable",
-					range,
-					text: variableName
-				}]] : [propertyName];
-				context.report({
-					data: {
-						expression,
-						variable
-					},
-					message: "useDestructured",
-					range,
-					suggestions
-				});
-			},
-			VariableDeclaration: collectDestructuredProperties
-		} };
-	}
-});
-//#endregion
-export { destructuringConsistency_default as default };
-
-//# sourceMappingURL=destructuringConsistency.js.map

package/lib/rules/duplicateArguments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports functions with duplicate parameter names in their signatures.";
-    readonly id: "duplicateArguments";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateParam", undefined>;
-export default _default;
-//# sourceMappingURL=duplicateArguments.d.ts.map