@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/objectEntriesMethods.js

@@ -0,0 +1,82 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { skipParentheses } from "./utils/skipParentheses.js";
+import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectEntriesMethods.ts
+function isArrowFunctionWithParams(node) {
+	return node.kind === SyntaxKind.ArrowFunction && !!node.parameters.length;
+}
+function isEmptyObject(node, typeChecker) {
+	const unwrapped = skipParentheses(node);
+	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker);
+}
+function isEmptyObjectLiteral(node) {
+	return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
+}
+function isObjectAssignPattern(callback, typeChecker) {
+	if (callback.parameters.length < 1) return false;
+	const firstParameter = callback.parameters[0];
+	if (firstParameter.name.kind !== SyntaxKind.Identifier) return false;
+	const accumulatorName = firstParameter.name.text;
+	const body = skipParentheses(callback.body);
+	if (!isObjectMethodCall(body, "assign", typeChecker) || body.arguments.length !== 2 || !isGlobalDeclarationOfName(body.expression.expression, "Object", typeChecker)) return false;
+	const firstArg = body.arguments[0];
+	if (firstArg.kind !== SyntaxKind.Identifier || firstArg.text !== accumulatorName) return false;
+	const secondArg = body.arguments[1];
+	if (secondArg.kind !== SyntaxKind.ObjectLiteralExpression || secondArg.properties.length !== 1) return false;
+	const property = secondArg.properties[0];
+	return property.kind === SyntaxKind.PropertyAssignment && property.name.kind === SyntaxKind.ComputedPropertyName;
+}
+function isObjectCreateNull(node, typeChecker) {
+	if (!isObjectMethodCall(node, "create", typeChecker) || !isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker) || node.arguments.length !== 1) return false;
+	return node.arguments[0].kind === SyntaxKind.NullKeyword;
+}
+function isObjectMethodCall(node, text, typeChecker) {
+	return node.kind === SyntaxKind.CallExpression && node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === text && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker);
+}
+function isReduceCallWithEmptyObject(node, typeChecker) {
+	if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier || node.expression.name.text !== "reduce" || node.questionDotToken !== void 0 || node.arguments.length !== 2) return false;
+	const initialValue = node.arguments[1];
+	return isEmptyObject(initialValue, typeChecker) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
+}
+function isSpreadAccumulatorPattern(callback) {
+	if (callback.parameters.length < 1) return false;
+	const firstParam = callback.parameters[0];
+	if (firstParam?.name.kind !== SyntaxKind.Identifier) return false;
+	const accumulatorName = firstParam.name.text;
+	const body = skipParentheses(callback.body);
+	if (body.kind !== SyntaxKind.ObjectLiteralExpression || body.properties.length !== 2) return false;
+	const firstProp = body.properties[0];
+	if (firstProp.kind !== SyntaxKind.SpreadAssignment || firstProp.expression.kind !== SyntaxKind.Identifier || firstProp.expression.text !== accumulatorName) return false;
+	const secondProp = body.properties[1];
+	return secondProp.kind === SyntaxKind.PropertyAssignment && secondProp.name.kind === SyntaxKind.ComputedPropertyName;
+}
+var objectEntriesMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer Object.fromEntries() over reduce patterns that build objects from key-value pairs.",
+		id: "objectEntriesMethods",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferFromEntries: {
+		primary: "Using reduce to build an object from key-value pairs can be replaced with Object.fromEntries().",
+		secondary: ["Object.fromEntries() is more readable and concise for converting an iterable of key-value pairs into an object.", "The reduce pattern creates unnecessary intermediate objects on each iteration."],
+		suggestions: ["Convert the array to key-value pairs with map() and use Object.fromEntries()."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!isReduceCallWithEmptyObject(node, typeChecker)) return;
+			const callback = node.arguments[0];
+			if (!isArrowFunctionWithParams(callback) || callback.body.kind === SyntaxKind.Block) return;
+			if (!isObjectAssignPattern(callback, typeChecker) && !isSpreadAccumulatorPattern(callback)) return;
+			context.report({
+				message: "preferFromEntries",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { objectEntriesMethods_default as default };
+
+//# sourceMappingURL=objectEntriesMethods.js.map

package/lib/rules/objectHasOwns.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.";
     readonly id: "objectHasOwns";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferHasOwn", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferHasOwn", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=objectHasOwns.d.ts.map

package/lib/rules/objectHasOwns.js

@@ -1,74 +1,50 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclarationOfName } from "../utils/isGlobalDeclarationOfName.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.",
-        id: "objectHasOwns",
-        preset: "stylistic",
-    },
-    messages: {
-        preferHasOwn: {
-            primary: "`hasOwnProperty()` calls can fail on objects without `Object.prototype` or with overridden properties.",
-            secondary: [
-                "`Object.hasOwn()` is a more modern and safer way to check if an object has its own property.",
-                "It avoids issues with objects that don't inherit from `Object.prototype` or have a modified hasOwnProperty property.",
-                "`Object.hasOwn()` was introduced in ES2022 and is more concise than the hasOwnProperty alternatives.",
-            ],
-            suggestions: [
-                "Use the safer, more modern `Object.hasOwn(obj, key)`.",
-                "Use an alternative key check such as the `in` operator.",
-            ],
-        },
-    },
-    setup(context) {
-        function isObjectPrototypeHasOwnProperty(node, typeChecker) {
-            return (ts.isPropertyAccessExpression(node) &&
-                ts.isIdentifier(node.name) &&
-                node.name.text === "prototype" &&
-                ts.isIdentifier(node.expression) &&
-                isGlobalDeclarationOfName(node.expression, "Object", typeChecker));
-        }
-        function isObjectLiteralHasOwnProperty(node) {
-            return ts.isObjectLiteralExpression(node) && node.properties.length === 0;
-        }
-        function isHasOwnProperty(node, typeChecker) {
-            if (!ts.isPropertyAccessExpression(node) ||
-                !ts.isIdentifier(node.name) ||
-                node.name.text !== "hasOwnProperty") {
-                return false;
-            }
-            return (isObjectPrototypeHasOwnProperty(node.expression, typeChecker) ||
-                isObjectLiteralHasOwnProperty(node.expression));
-        }
-        return {
-            visitors: {
-                CallExpression: (node, { sourceFile, typeChecker }) => {
-                    if (!ts.isPropertyAccessExpression(node.expression) ||
-                        !ts.isIdentifier(node.expression.name)) {
-                        return;
-                    }
-                    if (node.expression.name.text === "call" &&
-                        node.arguments.length >= 2 &&
-                        isHasOwnProperty(node.expression.expression, typeChecker)) {
-                        context.report({
-                            message: "preferHasOwn",
-                            range: getTSNodeRange(node, sourceFile),
-                        });
-                        return;
-                    }
-                    if (node.expression.name.text === "hasOwnProperty" &&
-                        node.arguments.length >= 1 &&
-                        !isHasOwnProperty(node.expression, typeChecker)) {
-                        context.report({
-                            message: "preferHasOwn",
-                            range: getTSNodeRange(node, sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectHasOwns.ts
+var objectHasOwns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.",
+		id: "objectHasOwns",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferHasOwn: {
+		primary: "`hasOwnProperty()` calls can fail on objects without `Object.prototype` or with overridden properties.",
+		secondary: [
+			"`Object.hasOwn()` is a more modern and safer way to check if an object has its own property.",
+			"It avoids issues with objects that don't inherit from `Object.prototype` or have a modified hasOwnProperty property.",
+			"`Object.hasOwn()` was introduced in ES2022 and is more concise than the hasOwnProperty alternatives."
+		],
+		suggestions: ["Use the safer, more modern `Object.hasOwn(obj, key)`.", "Use an alternative key check such as the `in` operator."]
+	} },
+	setup(context) {
+		function isObjectPrototypeHasOwnProperty(node, typeChecker) {
+			return node.kind === SyntaxKind.PropertyAccessExpression && node.name.kind === SyntaxKind.Identifier && node.name.text === "prototype" && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Object", typeChecker);
+		}
+		function isObjectLiteralHasOwnProperty(node) {
+			return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
+		}
+		function isHasOwnProperty(node, typeChecker) {
+			if (node.kind !== SyntaxKind.PropertyAccessExpression || node.name.kind !== SyntaxKind.Identifier || node.name.text !== "hasOwnProperty") return false;
+			return isObjectPrototypeHasOwnProperty(node.expression, typeChecker) || isObjectLiteralHasOwnProperty(node.expression);
+		}
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier) return;
+			if (node.expression.name.text === "call" && node.arguments.length >= 2 && isHasOwnProperty(node.expression.expression, typeChecker)) {
+				context.report({
+					message: "preferHasOwn",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+			if (node.expression.name.text === "hasOwnProperty" && node.arguments.length >= 1 && !isHasOwnProperty(node.expression, typeChecker)) context.report({
+				message: "preferHasOwn",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { objectHasOwns_default as default };
+
 //# sourceMappingURL=objectHasOwns.js.map

package/lib/rules/objectKeyDuplicates.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary duplicate keys that override previous values.";
     readonly id: "objectKeyDuplicates";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "duplicateKey", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "duplicateKey", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=objectKeyDuplicates.d.ts.map

package/lib/rules/objectKeyDuplicates.js

@@ -1,91 +1,63 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports unnecessary duplicate keys that override previous values.",
-        id: "objectKeyDuplicates",
-        preset: "untyped",
-    },
-    messages: {
-        duplicateKey: {
-            primary: "This key is made redundant by an identical key later in the object.",
-            secondary: [
-                "Duplicate object keys are legal in JavaScript, but they can lead to unexpected behavior.",
-                "When duplicate keys exist, only the last value for a given key is used.",
-                "This can cause confusion and bugs, especially when maintaining the code.",
-            ],
-            suggestions: [
-                "If both values are meant to exist, change one of the keys to be different.",
-                "If only the last value is meant to exist, remove any prior values.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                ObjectLiteralExpression(node, { sourceFile }) {
-                    const seenKeys = {
-                        getters: new Map(),
-                        setters: new Map(),
-                        values: new Map(),
-                    };
-                    for (const property of node.properties.toReversed()) {
-                        const key = getPropertyKeyName(property);
-                        if (!key) {
-                            continue;
-                        }
-                        const existingNode = seenKeys[key.group].get(key.text);
-                        if (existingNode) {
-                            context.report({
-                                message: "duplicateKey",
-                                range: getTSNodeRange(key.node, sourceFile),
-                            });
-                        }
-                        seenKeys[key.group].set(key.text, property);
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectKeyDuplicates.ts
+var objectKeyDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary duplicate keys that override previous values.",
+		id: "objectKeyDuplicates",
+		presets: ["javascript"]
+	},
+	messages: { duplicateKey: {
+		primary: "This key is made redundant by an identical key later in the object.",
+		secondary: [
+			"Duplicate object keys are legal in JavaScript, but they can lead to unexpected behavior.",
+			"When duplicate keys exist, only the last value for a given key is used.",
+			"This can cause confusion and bugs, especially when maintaining the code."
+		],
+		suggestions: ["If both values are meant to exist, change one of the keys to be different.", "If only the last value is meant to exist, remove any prior values."]
+	} },
+	setup(context) {
+		return { visitors: { ObjectLiteralExpression(node, { sourceFile }) {
+			const seenKeys = {
+				getters: /* @__PURE__ */ new Map(),
+				setters: /* @__PURE__ */ new Map(),
+				values: /* @__PURE__ */ new Map()
+			};
+			for (const property of node.properties.toReversed()) {
+				const key = getPropertyKeyName(property);
+				if (!key) continue;
+				if (seenKeys[key.group].get(key.text)) context.report({
+					message: "duplicateKey",
+					range: getTSNodeRange(key.node, sourceFile)
+				});
+				seenKeys[key.group].set(key.text, property);
+			}
+		} } };
+	}
 });
-// TODO: Reuse a shared getStaticValue-style utility?
 function getNameText(name) {
-    if (ts.isIdentifier(name) ||
-        ts.isStringLiteral(name) ||
-        ts.isNumericLiteral(name) ||
-        ts.isLiteralExpression(name)) {
-        return name.text;
-    }
-    if (ts.isPrivateIdentifier(name)) {
-        return `#${name.text}`;
-    }
-    return undefined;
+	if (name.kind === SyntaxKind.Identifier || name.kind === SyntaxKind.NumericLiteral || name.kind === SyntaxKind.BigIntLiteral || name.kind === SyntaxKind.StringLiteral || name.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return name.text;
+	if (name.kind === SyntaxKind.PrivateIdentifier) return `#${name.text}`;
 }
 function getPropertyKeyName(property) {
-    if (ts.isShorthandPropertyAssignment(property)) {
-        return {
-            group: "values",
-            node: property.name,
-            text: property.name.text,
-        };
-    }
-    if (ts.isPropertyAssignment(property) ||
-        ts.isMethodDeclaration(property) ||
-        ts.isGetAccessorDeclaration(property) ||
-        ts.isSetAccessorDeclaration(property)) {
-        const { name } = property;
-        const text = getNameText(name);
-        if (!text) {
-            return undefined;
-        }
-        const group = ts.isGetAccessorDeclaration(property)
-            ? "getters"
-            : ts.isSetAccessorDeclaration(property)
-                ? "setters"
-                : "values";
-        return { group, node: name, text };
-    }
-    return undefined;
+	if (property.kind === SyntaxKind.ShorthandPropertyAssignment) return {
+		group: "values",
+		node: property.name,
+		text: property.name.text
+	};
+	if (property.kind === SyntaxKind.PropertyAssignment || property.kind === SyntaxKind.MethodDeclaration || property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor) {
+		const { name } = property;
+		const text = getNameText(name);
+		if (!text) return;
+		return {
+			group: property.kind === SyntaxKind.GetAccessor ? "getters" : property.kind === SyntaxKind.SetAccessor ? "setters" : "values",
+			node: name,
+			text
+		};
+	}
 }
+//#endregion
+export { objectKeyDuplicates_default as default };
+
 //# sourceMappingURL=objectKeyDuplicates.js.map

package/lib/rules/objectProto.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
     readonly id: "objectProto";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noProto", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noProto", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=objectProto.d.ts.map

package/lib/rules/objectProto.js

@@ -1,55 +1,50 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.",
-        id: "objectProto",
-        preset: "untyped",
-    },
-    messages: {
-        noProto: {
-            primary: "Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.",
-            secondary: [
-                "The __proto__ property is deprecated and not part of the ECMAScript standard.",
-                "It is maintained for compatibility with older browsers but can cause performance issues and unexpected behavior.",
-                "Direct manipulation of an object's prototype can lead to hidden classes deoptimizations in JavaScript engines.",
-            ],
-            suggestions: [
-                "Use Object.getPrototypeOf(obj) to read the prototype of an object.",
-                "Use Object.setPrototypeOf(obj, proto) to set the prototype of an object.",
-                "Use Object.create(proto) when creating new objects with a specific prototype.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                ElementAccessExpression: (node, { sourceFile }) => {
-                    if (ts.isStringLiteral(node.argumentExpression) &&
-                        node.argumentExpression.text === "__proto__") {
-                        context.report({
-                            message: "noProto",
-                            range: {
-                                begin: node.argumentExpression.getStart(sourceFile),
-                                end: node.argumentExpression.getEnd(),
-                            },
-                        });
-                    }
-                },
-                PropertyAccessExpression: (node, { sourceFile }) => {
-                    if (node.name.kind === ts.SyntaxKind.Identifier &&
-                        node.name.text === "__proto__") {
-                        context.report({
-                            message: "noProto",
-                            range: {
-                                begin: node.name.getStart(sourceFile),
-                                end: node.name.getEnd(),
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/objectProto.ts
+var objectProto_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.",
+		id: "objectProto",
+		presets: ["javascript"]
+	},
+	messages: { noProto: {
+		primary: "Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.",
+		secondary: [
+			"The __proto__ property is deprecated and not part of the ECMAScript standard.",
+			"It is maintained for compatibility with older browsers but can cause performance issues and unexpected behavior.",
+			"Direct manipulation of an object's prototype can lead to hidden classes deoptimizations in JavaScript engines."
+		],
+		suggestions: [
+			"Use Object.getPrototypeOf(obj) to read the prototype of an object.",
+			"Use Object.setPrototypeOf(obj, proto) to set the prototype of an object.",
+			"Use Object.create(proto) when creating new objects with a specific prototype."
+		]
+	} },
+	setup(context) {
+		return { visitors: {
+			ElementAccessExpression: (node, { sourceFile }) => {
+				if (node.argumentExpression.kind === SyntaxKind.StringLiteral && node.argumentExpression.text === "__proto__") context.report({
+					message: "noProto",
+					range: {
+						begin: node.argumentExpression.getStart(sourceFile),
+						end: node.argumentExpression.getEnd()
+					}
+				});
+			},
+			PropertyAccessExpression: (node, { sourceFile }) => {
+				if (node.name.kind === SyntaxKind.Identifier && node.name.text === "__proto__") context.report({
+					message: "noProto",
+					range: {
+						begin: node.name.getStart(sourceFile),
+						end: node.name.getEnd()
+					}
+				});
+			}
+		} };
+	}
 });
+//#endregion
+export { objectProto_default as default };
+
 //# sourceMappingURL=objectProto.js.map

package/lib/rules/objectPrototypeBuiltIns.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports direct calls to Object.prototype methods on object instances.";
     readonly id: "objectPrototypeBuiltIns";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "prototypeBuiltIn", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "prototypeBuiltIn", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=objectPrototypeBuiltIns.d.ts.map