@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/numberStaticMethods.js

@@ -1,51 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/numberStaticMethods.ts
-const globalReplacements = /* @__PURE__ */ new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
-function isDeclarationName(node) {
-	return ts.isFunctionDeclaration(node.parent) && node.parent.name === node || ts.isVariableDeclaration(node.parent) && node.parent.name === node || ts.isParameter(node.parent) && node.parent.name === node;
-}
-function isLeftHandSide(node) {
-	return node.parent.kind === ts.SyntaxKind.BinaryExpression && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
-}
-function isPropertyAccessOfNode(node) {
-	return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
-}
-function isPropertyShorthandOfNode(node) {
-	return ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
-}
-var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using legacy global functions instead of `Number` static methods.",
-		id: "numberStaticMethods",
-		presets: ["logicalStrict"]
-	},
-	messages: { preferNumberMethod: {
-		primary: "Prefer the more precise `{{ replacement }}` over the legacy global `{{ name }}`.",
-		secondary: ["`Number` static methods clearly indicate you're working with numbers.", "The global methods like `isFinite` and `isNaN` coerce their arguments, which can lead to unexpected behavior."],
-		suggestions: ["Replace `{{ name }}` with `{{ replacement }}`."]
-	} },
-	setup(context) {
-		return { visitors: { Identifier: (node, { program, sourceFile, typeChecker }) => {
-			const replacement = globalReplacements.get(node.text);
-			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker, program) || isLeftHandSide(node)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				data: {
-					name: node.text,
-					replacement
-				},
-				message: "preferNumberMethod",
-				range,
-				suggestions: [{
-					id: "replaceWithNumberMethod",
-					range,
-					text: replacement
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { numberStaticMethods_default as default };

package/lib/rules/numericErasingOperations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports operations that always result in zero, such as multiplication by zero.";
-    readonly id: "numericErasingOperations";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "erasingOperation", undefined>;
-export default _default;

package/lib/rules/numericErasingOperations.js

@@ -1,44 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticNumberValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/numericErasingOperations.ts
-function isZeroLiteral(node) {
-	return Object.is(getStaticNumberValue(node), 0);
-}
-var numericErasingOperations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports operations that always result in zero, such as multiplication by zero.",
-		id: "numericErasingOperations",
-		presets: ["logicalStrict"]
-	},
-	messages: { erasingOperation: {
-		primary: "This expression will always evaluate to zero.",
-		secondary: ["Using `0` in this operation always produces a result that is also `0`.", "This is often a sign of incompletely refactored code or incorrect program logic."],
-		suggestions: [
-			"Remove the operation",
-			"Replace with `0`",
-			"Change the operation to use a non-zero value"
-		]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			switch (node.operatorToken.kind) {
-				case ts.SyntaxKind.AmpersandToken:
-				case ts.SyntaxKind.AsteriskToken:
-					if (isZeroLiteral(node.left) || isZeroLiteral(node.right)) context.report({
-						message: "erasingOperation",
-						range: getTSNodeRange(node, sourceFile)
-					});
-					break;
-				case ts.SyntaxKind.SlashToken:
-					if (isZeroLiteral(node.left) && !isZeroLiteral(node.right)) context.report({
-						message: "erasingOperation",
-						range: getTSNodeRange(node, sourceFile)
-					});
-					break;
-			}
-		} } };
-	}
-});
-//#endregion
-export { numericErasingOperations_default as default };

package/lib/rules/numericLiteralParsing.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.";
-    readonly id: "numericLiteralParsing";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferLiteral", undefined>;
-export default _default;

package/lib/rules/numericLiteralParsing.js

@@ -1,55 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticNumberValue, getStaticStringValue, getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/numericLiteralParsing.ts
-function convertToLiteral(value, radix) {
-	const parsed = Number.parseInt(value, radix);
-	if (Number.isNaN(parsed)) return value;
-	switch (radix) {
-		case 2: return `0b${parsed.toString(2)}`;
-		case 8: return `0o${parsed.toString(8)}`;
-		case 16: return `0x${parsed.toString(16).toUpperCase()}`;
-		default: return value;
-	}
-}
-var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
-		id: "numericLiteralParsing",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferLiteral: {
-		primary: "Use {{ literal }} instead of parseInt with radix {{ radix }}.",
-		secondary: ["Binary, octal, and hexadecimal numeric literals are more readable and direct than using parseInt with a radix.", "Numeric literals are supported natively and don't require function calls."],
-		suggestions: ["Replace the parseInt call with the numeric literal."]
-	} },
-	setup(context) {
-		function checkParseIntCall(node, sourceFile) {
-			if (node.arguments.length !== 2) return;
-			const stringValue = getStaticStringValue(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
-			if (!stringValue) return;
-			const radixValue = getStaticNumberValue(nullThrows(node.arguments[1], "Second argument is expected to be present by prior length check"));
-			if (radixValue === void 0 || ![
-				2,
-				8,
-				16
-			].includes(radixValue)) return;
-			context.report({
-				data: {
-					literal: convertToLiteral(stringValue, radixValue),
-					radix: String(radixValue)
-				},
-				message: "preferLiteral",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (node.expression.kind === SyntaxKind.Identifier) {
-				if (node.expression.text === "parseInt" && isGlobalDeclaration(node.expression, typeChecker, program)) checkParseIntCall(node, sourceFile);
-			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Number" && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "parseInt" && isGlobalDeclaration(node.expression.expression, typeChecker, program)) checkParseIntCall(node, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { numericLiteralParsing_default as default };

package/lib/rules/numericPrecision.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports numeric literals that lose precision when converted to JavaScript numbers.";
-    readonly id: "numericPrecision";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "lossOfPrecision", undefined>;
-export default _default;

package/lib/rules/numericPrecision.js

@@ -1,100 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/numericPrecision.ts
-function baseTenLosesPrecision(raw, value) {
-	const normalizedRawNumber = convertNumberToScientificNotation(raw.toLowerCase(), false);
-	const requestedPrecision = normalizedRawNumber.coefficient.length;
-	if (requestedPrecision > 100) return true;
-	const normalizedStoredNumber = convertNumberToScientificNotation(value.toPrecision(requestedPrecision), true);
-	return normalizedRawNumber.magnitude !== normalizedStoredNumber.magnitude || normalizedRawNumber.coefficient !== normalizedStoredNumber.coefficient;
-}
-function convertNumberToScientificNotation(stringNumber, parseAsFloat) {
-	const splitNumber = stringNumber.split("e");
-	const originalCoefficient = splitNumber[0];
-	const normalizedNumber = parseAsFloat || stringNumber.includes(".") ? normalizeFloat(originalCoefficient) : normalizeInteger(originalCoefficient);
-	if (splitNumber.length > 1) normalizedNumber.magnitude += parseInt(splitNumber[1], 10);
-	return normalizedNumber;
-}
-function getRaw(text) {
-	return text.replace(/_/g, "");
-}
-function isBaseTen(raw) {
-	return [
-		"0x",
-		"0X",
-		"0b",
-		"0B",
-		"0o",
-		"0O"
-	].every((prefix) => !raw.startsWith(prefix)) && !/^0[0-7]+$/.test(raw);
-}
-function losesPrecision(raw, value) {
-	if (value === 0) return false;
-	return isBaseTen(raw) ? baseTenLosesPrecision(raw, value) : notBaseTenLosesPrecision(raw, value);
-}
-function normalizeFloat(stringFloat) {
-	const trimmedFloat = removeLeadingZeros(stringFloat);
-	const indexOfDecimalPoint = trimmedFloat.indexOf(".");
-	switch (indexOfDecimalPoint) {
-		case -1: return {
-			coefficient: trimmedFloat,
-			magnitude: trimmedFloat.length - 1
-		};
-		case 0: {
-			const significantDigits = removeLeadingZeros(trimmedFloat.slice(1));
-			return {
-				coefficient: significantDigits,
-				magnitude: significantDigits.length - trimmedFloat.length
-			};
-		}
-		default: return {
-			coefficient: trimmedFloat.replace(".", ""),
-			magnitude: indexOfDecimalPoint - 1
-		};
-	}
-}
-function normalizeInteger(stringInteger) {
-	const trimmedInteger = removeLeadingZeros(stringInteger);
-	return {
-		coefficient: removeTrailingZeros(trimmedInteger),
-		magnitude: trimmedInteger.length - 1
-	};
-}
-function notBaseTenLosesPrecision(raw, value) {
-	const rawString = raw.toUpperCase();
-	let base;
-	if (rawString.startsWith("0B")) base = 2;
-	else if (rawString.startsWith("0X")) base = 16;
-	else base = 8;
-	return !rawString.endsWith(value.toString(base).toUpperCase());
-}
-function removeLeadingZeros(numberAsString) {
-	for (let i = 0; i < numberAsString.length; i++) if (numberAsString[i] !== "0") return numberAsString.slice(i);
-	return numberAsString;
-}
-function removeTrailingZeros(numberAsString) {
-	for (let i = numberAsString.length - 1; i >= 0; i--) if (numberAsString[i] !== "0") return numberAsString.slice(0, i + 1);
-	return numberAsString;
-}
-var numericPrecision_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports numeric literals that lose precision when converted to JavaScript numbers.",
-		id: "numericPrecision",
-		presets: ["logicalStrict"]
-	},
-	messages: { lossOfPrecision: {
-		primary: "This number literal will lose precision at runtime.",
-		secondary: ["JavaScript numbers are 64-bit floating-point values with limited precision.", "Numbers with more than 15-17 significant digits cannot be accurately represented."],
-		suggestions: ["If large amounts of precision are needed, switch to a `BigInt` or a different data structure.", "Remove the digits that are lost at runtime."]
-	} },
-	setup(context) {
-		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
-			if (losesPrecision(getRaw(node.getText(sourceFile)), Number(node.text))) context.report({
-				message: "lossOfPrecision",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { numericPrecision_default as default };

package/lib/rules/numericSeparatorGroups.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports numeric literals with inconsistent separator grouping.";
-    readonly id: "numericSeparatorGroups";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidGrouping", undefined>;
-export default _default;

package/lib/rules/numericSeparatorGroups.js

@@ -1,99 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/numericSeparatorGroups.ts
-const groupLength = 3;
-const minimumDigits = 5;
-function addSeparator(value, fromLeft) {
-	return value.length < minimumDigits ? value : addSeparatorAlways(value, fromLeft);
-}
-function addSeparatorAlways(value, fromLeft) {
-	const { length } = value;
-	const parts = [];
-	if (fromLeft) for (let start = 0; start < length; start += groupLength) {
-		const end = Math.min(start + groupLength, length);
-		parts.push(value.slice(start, end));
-	}
-	else for (let end = length; end > 0; end -= groupLength) {
-		const start = Math.max(end - groupLength, 0);
-		parts.unshift(value.slice(start, end));
-	}
-	return parts.join("_");
-}
-function format(stripped, hasSeparators) {
-	const { mark, number, power, sign } = parseNumber(stripped);
-	return formatNumber(number, hasSeparators) + mark + sign + (hasSeparators ? addSeparatorAlways(power) : addSeparator(power));
-}
-function formatNumber(value, hasSeparators) {
-	const { dot, fractional, integer } = parseFloatNumber(value);
-	const [prefix, suffix] = hasSeparators ? [addSeparatorAlways(integer), addSeparatorAlways(fractional, true)] : [addSeparator(integer), addSeparator(fractional, true)];
-	return prefix + dot + suffix;
-}
-function parseFloatNumber(value) {
-	const dotIndex = value.indexOf(".");
-	if (dotIndex === -1) return {
-		dot: "",
-		fractional: "",
-		integer: value
-	};
-	return {
-		dot: ".",
-		fractional: value.slice(dotIndex + 1),
-		integer: value.slice(0, dotIndex)
-	};
-}
-function parseNumber(value) {
-	const match = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(e)([+-]?)(\d+)$/i.exec(value);
-	if (match) return {
-		mark: match[2].toLowerCase(),
-		number: match[1],
-		power: match[4],
-		sign: match[3] ?? ""
-	};
-	return {
-		mark: "",
-		number: value,
-		power: "",
-		sign: ""
-	};
-}
-var numericSeparatorGroups_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports numeric literals with inconsistent separator grouping.",
-		id: "numericSeparatorGroups",
-		presets: ["stylisticStrict"]
-	},
-	messages: { invalidGrouping: {
-		primary: "Use consistent grouping with numeric separators.",
-		secondary: ["Numeric separators should group digits consistently for readability.", "Use groups of 3 for decimals, 4 for binary/octal, and 2 for hexadecimal."],
-		suggestions: ["Add `_`s to the number to make it consistent with the rest of the codebase."]
-	} },
-	setup(context) {
-		function checkNode(node, raw, number, suffix, sourceFile) {
-			if (/[a-z]/i.test(number.slice(0, 2)) || number.includes("e")) return;
-			const stripped = number.replaceAll("_", "");
-			const formatted = format(stripped, number !== stripped) + suffix;
-			if (raw === formatted) return;
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: formatted
-				},
-				message: "invalidGrouping",
-				range
-			});
-		}
-		return { visitors: {
-			BigIntLiteral: (node, { sourceFile }) => {
-				const raw = node.getText(sourceFile);
-				checkNode(node, raw, raw.slice(0, -1), "n", sourceFile);
-			},
-			NumericLiteral: (node, { sourceFile }) => {
-				const raw = node.getText(sourceFile);
-				checkNode(node, raw, raw, "", sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { numericSeparatorGroups_default as default };

package/lib/rules/objectAssignSpreads.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer object spread syntax over `Object.assign()` when the first argument is an object literal.";
-    readonly id: "objectAssignSpreads";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferObjectLiteral" | "preferObjectSpread", undefined>;
-export default _default;

package/lib/rules/objectAssignSpreads.js

@@ -1,51 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/objectAssignSpreads.ts
-function hasAccessors(node) {
-	return node.properties.some((property) => property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor);
-}
-function hasArgumentsWithAccessors(node) {
-	return node.arguments.length > 1 && node.arguments.filter((argument) => argument.kind === SyntaxKind.ObjectLiteralExpression).some(hasAccessors);
-}
-function hasArraySpread(node) {
-	return node.arguments.some((argument) => argument.kind === SyntaxKind.SpreadElement);
-}
-function isObjectAssignCall(node, typeChecker, program) {
-	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "assign" && node.expression.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program);
-}
-var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer object spread syntax over `Object.assign()` when the first argument is an object literal.",
-		id: "objectAssignSpreads",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferObjectLiteral: {
-			primary: "`Object.assign()` with a single object literal argument is unnecessary.",
-			secondary: ["When `Object.assign()` is called with only one object literal argument, the result is identical to using the literal directly.", "Using the object literal directly is simpler and more readable."],
-			suggestions: ["Replace `Object.assign({ prop: value })` with `{ prop: value }`."]
-		},
-		preferObjectSpread: {
-			primary: "`Object.assign()` with an object literal as the first argument can be replaced with object spread syntax.",
-			secondary: [
-				"Object spread syntax (`{ ...source }`) is more concise and readable than `Object.assign({}, source)`.",
-				"Spread syntax was introduced in ES2018 and is widely supported in modern JavaScript environments.",
-				"Using spread syntax makes object cloning and merging more idiomatic."
-			],
-			suggestions: ["Replace `Object.assign({}, source)` with `{ ...source }`.", "Replace `Object.assign({ prop: value }, source)` with `{ prop: value, ...source }`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (!isObjectAssignCall(node, typeChecker, program) || node.arguments.length < 1) return;
-			if (node.arguments[0].kind !== SyntaxKind.ObjectLiteralExpression || hasArraySpread(node) || hasArgumentsWithAccessors(node)) return;
-			context.report({
-				message: node.arguments.length === 1 ? "preferObjectLiteral" : "preferObjectSpread",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { objectAssignSpreads_default as default };

package/lib/rules/objectCalls.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.";
-    readonly id: "objectCalls";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferObjectLiteral", undefined>;
-export default _default;

package/lib/rules/objectCalls.js

@@ -1,36 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/objectCalls.ts
-var objectCalls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.",
-		id: "objectCalls",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferObjectLiteral: {
-		primary: "Prefer directly using `{}` instead of calling or constructing `Object`.",
-		secondary: [
-			"Calling or constructing Object with `Object()` or `new Object()` is unnecessarily verbose and less idiomatic than using object literal syntax.",
-			"`{}` object literal notation is the preferred and more concise way to create plain objects.",
-			"For creating objects without a prototype, use `Object.create(null)`."
-		],
-		suggestions: ["Replace `Object()` or `new Object()` with `{}` to create an empty object.", "Use `Object.create(null)` when you need an object without a prototype."]
-	} },
-	setup(context) {
-		function checkNode(node, { program, sourceFile, typeChecker }) {
-			if (node.expression.kind !== SyntaxKind.Identifier || !isGlobalDeclarationOfName(node.expression, "Object", typeChecker, program)) return;
-			const reportNode = node.kind === SyntaxKind.NewExpression ? node.getChildAt(0, sourceFile) : node.expression;
-			context.report({
-				message: "preferObjectLiteral",
-				range: getTSNodeRange(reportNode, sourceFile)
-			});
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { objectCalls_default as default };

package/lib/rules/objectEntriesMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer Object.fromEntries() over reduce patterns that build objects from key-value pairs.";
-    readonly id: "objectEntriesMethods";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferFromEntries", undefined>;
-export default _default;

package/lib/rules/objectEntriesMethods.js

@@ -1,80 +0,0 @@
-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, program) {
-	const unwrapped = skipParentheses(node);
-	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker, program);
-}
-function isEmptyObjectLiteral(node) {
-	return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
-}
-function isObjectAssignPattern(callback, typeChecker, program) {
-	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, program) || body.arguments.length !== 2 || !isGlobalDeclarationOfName(body.expression.expression, "Object", typeChecker, program)) 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, program) {
-	if (!isObjectMethodCall(node, "create", typeChecker, program) || !isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program) || node.arguments.length !== 1) return false;
-	return node.arguments[0].kind === SyntaxKind.NullKeyword;
-}
-function isObjectMethodCall(node, text, typeChecker, program) {
-	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, program);
-}
-function isReduceCallWithEmptyObject(node, typeChecker, program) {
-	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, program) && 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, { program, sourceFile, typeChecker }) => {
-			if (!isReduceCallWithEmptyObject(node, typeChecker, program)) return;
-			const callback = node.arguments[0];
-			if (!isArrowFunctionWithParams(callback) || callback.body.kind === SyntaxKind.Block) return;
-			if (!isObjectAssignPattern(callback, typeChecker, program) && !isSpreadAccumulatorPattern(callback)) return;
-			context.report({
-				message: "preferFromEntries",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { objectEntriesMethods_default as default };

package/lib/rules/objectHasOwns.d.ts

@@ -1,9 +0,0 @@
-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 presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferHasOwn", undefined>;
-export default _default;

package/lib/rules/objectHasOwns.js

@@ -1,48 +0,0 @@
-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, program) {
-			return node.kind === SyntaxKind.PropertyAccessExpression && node.name.kind === SyntaxKind.Identifier && node.name.text === "prototype" && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Object", typeChecker, program);
-		}
-		function isObjectLiteralHasOwnProperty(node) {
-			return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
-		}
-		function isHasOwnProperty(node, typeChecker, program) {
-			if (node.kind !== SyntaxKind.PropertyAccessExpression || node.name.kind !== SyntaxKind.Identifier || node.name.text !== "hasOwnProperty") return false;
-			return isObjectPrototypeHasOwnProperty(node.expression, typeChecker, program) || isObjectLiteralHasOwnProperty(node.expression);
-		}
-		return { visitors: { CallExpression: (node, { program, 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, program)) {
-				context.report({
-					message: "preferHasOwn",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (node.expression.name.text === "hasOwnProperty" && node.arguments.length >= 1 && !isHasOwnProperty(node.expression, typeChecker, program)) context.report({
-				message: "preferHasOwn",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { objectHasOwns_default as default };