@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/numberMethodRanges.js

@@ -1,74 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/numberMethodRanges.ts
-const methodSpecs = new Map([
-	["toExponential", {
-		max: 100,
-		min: 0,
-		name: "toExponential"
-	}],
-	["toFixed", {
-		max: 100,
-		min: 0,
-		name: "toFixed"
-	}],
-	["toPrecision", {
-		max: 100,
-		min: 1,
-		name: "toPrecision"
-	}],
-	["toString", {
-		max: 36,
-		min: 2,
-		name: "toString"
-	}]
-]);
-function getMethodName(expression) {
-	if (expression.kind === SyntaxKind.PropertyAccessExpression && expression.name.kind === SyntaxKind.Identifier) return expression.name.text;
-	if (expression.kind === SyntaxKind.ElementAccessExpression && expression.argumentExpression.kind === SyntaxKind.StringLiteral) return expression.argumentExpression.text;
-}
-function getNumericValue(node) {
-	if (node.kind === SyntaxKind.NumericLiteral) return Number(node.text);
-	if (node.kind === SyntaxKind.PrefixUnaryExpression && node.operator === SyntaxKind.MinusToken && node.operand.kind === SyntaxKind.NumericLiteral) return -Number(node.operand.text);
-}
-var numberMethodRanges_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports when number method arguments are outside their valid range.",
-		id: "numberMethodRanges",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { outOfRange: {
-		primary: "The argument `{{ value }}` is out of range for `{{ method }}`. Use a value between {{ min }} and {{ max }}.",
-		secondary: ["Passing an out-of-range argument to `{{ method }}` will throw a RangeError at runtime."],
-		suggestions: ["Check the documentation for `{{ method }}` to see the valid range of values."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile }) => {
-			if (!node.arguments.length) return;
-			const methodName = getMethodName(node.expression);
-			if (!methodName) return;
-			const spec = methodSpecs.get(methodName);
-			if (!spec) return;
-			const argument = node.arguments[0];
-			if (argument.kind === SyntaxKind.SpreadElement) return;
-			const value = getNumericValue(argument);
-			if (value === void 0) return;
-			if (Number.isInteger(value) && value >= spec.min && value <= spec.max) return;
-			context.report({
-				data: {
-					max: String(spec.max),
-					method: spec.name,
-					min: String(spec.min),
-					value: String(value)
-				},
-				message: "outOfRange",
-				range: getTSNodeRange(argument, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { numberMethodRanges_default as default };
-
-//# sourceMappingURL=numberMethodRanges.js.map

package/lib/rules/numberStaticMethods.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using legacy global functions instead of `Number` static methods.";
-    readonly id: "numberStaticMethods";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNumberMethod", undefined>;
-export default _default;
-//# sourceMappingURL=numberStaticMethods.d.ts.map

package/lib/rules/numberStaticMethods.js

@@ -1,53 +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 = 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, { sourceFile, typeChecker }) => {
-			const replacement = globalReplacements.get(node.text);
-			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker) || 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 };
-
-//# sourceMappingURL=numberStaticMethods.js.map

package/lib/rules/numericErasingOperations.d.ts

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

package/lib/rules/numericErasingOperations.js

@@ -1,46 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/numericErasingOperations.ts
-function isZeroLiteral(node) {
-	return node.kind === ts.SyntaxKind.NumericLiteral && node.text === "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 };
-
-//# sourceMappingURL=numericErasingOperations.js.map

package/lib/rules/numericLiteralParsing.d.ts

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

package/lib/rules/numericLiteralParsing.js

@@ -1,66 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { 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;
-	}
-}
-function getRadixValue(node) {
-	if (node.kind !== SyntaxKind.NumericLiteral) return;
-	const value = Number(node.text);
-	if (![
-		2,
-		8,
-		16
-	].includes(value)) return;
-	return value;
-}
-function getStringValue(node) {
-	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral ? node.text : void 0;
-}
-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 = getStringValue(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
-			if (!stringValue) return;
-			const radixValue = getRadixValue(nullThrows(node.arguments[1], "Second argument is expected to be present by prior length check"));
-			if (!radixValue) return;
-			context.report({
-				data: {
-					literal: convertToLiteral(stringValue, radixValue),
-					radix: String(radixValue)
-				},
-				message: "preferLiteral",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (node.expression.kind === SyntaxKind.Identifier) {
-				if (node.expression.text === "parseInt" && isGlobalDeclaration(node.expression, typeChecker)) 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)) checkParseIntCall(node, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { numericLiteralParsing_default as default };
-
-//# sourceMappingURL=numericLiteralParsing.js.map

package/lib/rules/numericPrecision.d.ts

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

package/lib/rules/numericPrecision.js

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

package/lib/rules/numericSeparatorGroups.d.ts

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

package/lib/rules/numericSeparatorGroups.js

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

package/lib/rules/objectAssignSpreads.d.ts

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

package/lib/rules/objectAssignSpreads.js

@@ -1,53 +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) {
-	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);
-}
-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, { sourceFile, typeChecker }) => {
-			if (!isObjectAssignCall(node, typeChecker) || 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 };
-
-//# sourceMappingURL=objectAssignSpreads.js.map

package/lib/rules/objectCalls.d.ts

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

package/lib/rules/objectCalls.js

@@ -1,38 +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, { sourceFile, typeChecker }) {
-			if (node.expression.kind !== SyntaxKind.Identifier || !isGlobalDeclarationOfName(node.expression, "Object", typeChecker)) 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 };
-
-//# sourceMappingURL=objectCalls.js.map

package/lib/rules/objectEntriesMethods.d.ts

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