@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/deprecated.js

@@ -0,0 +1,243 @@
+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

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

package/lib/rules/destructuringConsistency.js

@@ -0,0 +1,112 @@
+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,8 +1,10 @@
-import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports functions with duplicate parameter names in their signatures.";
     readonly id: "duplicateArguments";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "duplicateParam", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "duplicateParam", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=duplicateArguments.d.ts.map

package/lib/rules/duplicateArguments.js

@@ -1,52 +1,45 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports functions with duplicate parameter names in their signatures.",
-        id: "duplicateArguments",
-        preset: "untyped",
-    },
-    messages: {
-        duplicateParam: {
-            primary: "This parameter overrides the previous parameter of the same name.",
-            secondary: [
-                "Duplicate parameter names in functions can lead to unexpected behavior and make code harder to understand.",
-                "In strict mode, duplicate parameter names are a syntax error.",
-                "Even in non-strict mode, only the last parameter with a given name is accessible.",
-            ],
-            suggestions: ["Rename one of the duplicate parameters to a unique name."],
-        },
-    },
-    setup(context) {
-        function checkNode({ parameters }, { sourceFile }) {
-            const seenNames = new Set();
-            for (const parameter of parameters) {
-                if (!ts.isIdentifier(parameter.name)) {
-                    continue;
-                }
-                const parameterName = parameter.name.text;
-                const existingParameter = seenNames.has(parameterName);
-                if (existingParameter) {
-                    context.report({
-                        message: "duplicateParam",
-                        range: getTSNodeRange(parameter.name, sourceFile),
-                    });
-                }
-                else {
-                    seenNames.add(parameterName);
-                }
-            }
-        }
-        return {
-            visitors: {
-                ArrowFunction: checkNode,
-                Constructor: checkNode,
-                FunctionDeclaration: checkNode,
-                FunctionExpression: checkNode,
-                MethodDeclaration: checkNode,
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/duplicateArguments.ts
+var duplicateArguments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports functions with duplicate parameter names in their signatures.",
+		id: "duplicateArguments",
+		presets: ["javascript"]
+	},
+	messages: { duplicateParam: {
+		primary: "This parameter overrides the previous parameter of the same name.",
+		secondary: [
+			"Duplicate parameter names in functions can lead to unexpected behavior and make code harder to understand.",
+			"In strict mode, duplicate parameter names are a syntax error.",
+			"Even in non-strict mode, only the last parameter with a given name is accessible."
+		],
+		suggestions: ["Rename one of the duplicate parameters to a unique name."]
+	} },
+	setup(context) {
+		function checkNode({ parameters }, { sourceFile }) {
+			const seenNames = /* @__PURE__ */ new Set();
+			for (const parameter of parameters) {
+				if (parameter.name.kind !== SyntaxKind.Identifier) continue;
+				const parameterName = parameter.name.text;
+				if (seenNames.has(parameterName)) context.report({
+					message: "duplicateParam",
+					range: getTSNodeRange(parameter.name, sourceFile)
+				});
+				else seenNames.add(parameterName);
+			}
+		}
+		return { visitors: {
+			ArrowFunction: checkNode,
+			Constructor: checkNode,
+			FunctionDeclaration: checkNode,
+			FunctionExpression: checkNode,
+			MethodDeclaration: checkNode
+		} };
+	}
 });
+//#endregion
+export { duplicateArguments_default as default };
+
 //# sourceMappingURL=duplicateArguments.js.map

package/lib/rules/dynamicDeletes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Disallow using the delete operator on computed key expressions.";
+    readonly id: "dynamicDeletes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "dynamicDelete", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=dynamicDeletes.d.ts.map

package/lib/rules/dynamicDeletes.js

@@ -0,0 +1,37 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind, isElementAccessExpression, isNumericLiteral, isPrefixUnaryExpression, isStringLiteral } from "typescript";
+//#region src/rules/dynamicDeletes.ts
+function isAcceptableIndexExpression(property) {
+	return isStringLiteral(property) || isNumericLiteral(property) || isPrefixUnaryExpression(property) && property.operator === SyntaxKind.MinusToken && isNumericLiteral(property.operand);
+}
+var dynamicDeletes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow using the delete operator on computed key expressions.",
+		id: "dynamicDeletes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { dynamicDelete: {
+		primary: "Using the `delete` operator on a computed key can be dangerous and is often not well optimized.",
+		secondary: ["In modern code, JavaScript objects are generally intended to be optimized as static shapes by engines.", "Consider using a `Map` or `Set` if you need to dynamically add and remove keys."],
+		suggestions: ["Use a `Map` or `Set` instead of an object for dynamic keys."]
+	} },
+	setup(context) {
+		return { visitors: { DeleteExpression: (node, { sourceFile }) => {
+			const argument = node.expression;
+			if (!isElementAccessExpression(argument) || isAcceptableIndexExpression(argument.argumentExpression)) return;
+			const property = argument.argumentExpression;
+			context.report({
+				message: "dynamicDelete",
+				range: {
+					begin: property.getStart(sourceFile),
+					end: property.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { dynamicDeletes_default as default };
+
+//# sourceMappingURL=dynamicDeletes.js.map

package/lib/rules/elseIfDuplicates.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports duplicate conditions in if-else-if chains that make code unreachable.";
     readonly id: "elseIfDuplicates";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "duplicateCondition", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "duplicateCondition", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=elseIfDuplicates.d.ts.map

package/lib/rules/elseIfDuplicates.js

@@ -1,54 +1,38 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { hasSameTokens } from "../utils/hasSameTokens.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports duplicate conditions in if-else-if chains that make code unreachable.",
-        id: "elseIfDuplicates",
-        preset: "logical",
-    },
-    messages: {
-        duplicateCondition: {
-            primary: "This condition is identical to a previous condition in the if-else-if chain.",
-            secondary: [
-                "When an if-else-if chain has duplicate conditions, the duplicate branch will never execute because the earlier identical condition will always be evaluated first.",
-                "This typically indicates a copy-paste error or logic mistake.",
-            ],
-            suggestions: [
-                "Verify the condition logic is correct and update to check for the intended condition.",
-            ],
-        },
-    },
-    setup(context) {
-        function checkIfStatement(node, sourceFile) {
-            const seen = [];
-            let current = node;
-            while (true) {
-                if (seen.some((previous) => hasSameTokens(previous, current.expression, sourceFile))) {
-                    context.report({
-                        message: "duplicateCondition",
-                        range: getTSNodeRange(current.expression, sourceFile),
-                    });
-                }
-                if (!current.elseStatement ||
-                    !ts.isIfStatement(current.elseStatement)) {
-                    break;
-                }
-                seen.push(current.expression);
-                current = current.elseStatement;
-            }
-        }
-        return {
-            visitors: {
-                IfStatement: (node, { sourceFile }) => {
-                    if (!ts.isIfStatement(node.parent) ||
-                        node.parent.elseStatement !== node) {
-                        checkIfStatement(node, sourceFile);
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/elseIfDuplicates.ts
+var elseIfDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports duplicate conditions in if-else-if chains that make code unreachable.",
+		id: "elseIfDuplicates",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { duplicateCondition: {
+		primary: "This condition is identical to a previous condition in the if-else-if chain.",
+		secondary: ["When an if-else-if chain has duplicate conditions, the duplicate branch will never execute because the earlier identical condition will always be evaluated first.", "This typically indicates a copy-paste error or logic mistake."],
+		suggestions: ["Verify the condition logic is correct and update to check for the intended condition."]
+	} },
+	setup(context) {
+		function checkIfStatement(node, sourceFile) {
+			const seen = [];
+			let current = node;
+			while (true) {
+				if (seen.some((previous) => hasSameTokens(previous, current.expression, sourceFile))) context.report({
+					message: "duplicateCondition",
+					range: getTSNodeRange(current.expression, sourceFile)
+				});
+				if (current.elseStatement?.kind !== SyntaxKind.IfStatement) break;
+				seen.push(current.expression);
+				current = current.elseStatement;
+			}
+		}
+		return { visitors: { IfStatement: (node, { sourceFile }) => {
+			if (node.parent.kind !== SyntaxKind.IfStatement || node.parent.elseStatement !== node) checkIfStatement(node, sourceFile);
+		} } };
+	}
 });
+//#endregion
+export { elseIfDuplicates_default as default };
+
 //# sourceMappingURL=elseIfDuplicates.js.map

package/lib/rules/elseReturns.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary `else` blocks following `if` statements that always return or throw.";
+    readonly id: "elseReturns";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryElse", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=elseReturns.d.ts.map