@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/numericErasingOperations.js

@@ -0,0 +1,46 @@
+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,7 +1,10 @@
 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 preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferLiteral", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLiteral", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=numericLiteralParsing.d.ts.map

package/lib/rules/numericLiteralParsing.js

@@ -1,98 +1,66 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+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;
-    }
+	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 (!ts.isNumericLiteral(node)) {
-        return undefined;
-    }
-    const value = Number(node.text);
-    if (![2, 8, 16].includes(value)) {
-        return undefined;
-    }
-    return value;
+	if (node.kind !== SyntaxKind.NumericLiteral) return;
+	const value = Number(node.text);
+	if (![
+		2,
+		8,
+		16
+	].includes(value)) return;
+	return value;
 }
-// TODO: Use a util like getStaticValue
 function getStringValue(node) {
-    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
-        ? node.text
-        : undefined;
+	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral ? node.text : void 0;
 }
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
-        id: "numericLiteralParsing",
-        preset: "stylistic",
-    },
-    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(node.arguments[0]);
-            if (!stringValue) {
-                return;
-            }
-            const radixValue = getRadixValue(node.arguments[1]);
-            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 (ts.isIdentifier(node.expression)) {
-                        if (node.expression.text === "parseInt" &&
-                            isGlobalDeclaration(node.expression, typeChecker)) {
-                            checkParseIntCall(node, sourceFile);
-                        }
-                    }
-                    else if (ts.isPropertyAccessExpression(node.expression)) {
-                        if (ts.isIdentifier(node.expression.expression) &&
-                            node.expression.expression.text === "Number" &&
-                            ts.isIdentifier(node.expression.name) &&
-                            node.expression.name.text === "parseInt" &&
-                            isGlobalDeclaration(node.expression.expression, typeChecker)) {
-                            checkParseIntCall(node, sourceFile);
-                        }
-                    }
-                },
-            },
-        };
-    },
+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

@@ -0,0 +1,10 @@
+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: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "lossOfPrecision", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=numericPrecision.d.ts.map

package/lib/rules/numericPrecision.js

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

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports numeric literals with inconsistent separator grouping.";
+    readonly id: "numericSeparatorGroups";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidGrouping", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=numericSeparatorGroups.d.ts.map

package/lib/rules/numericSeparatorGroups.js

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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferObjectLiteral" | "preferObjectSpread", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=objectAssignSpreads.d.ts.map

package/lib/rules/objectAssignSpreads.js

@@ -0,0 +1,53 @@
+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,7 +1,10 @@
 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 preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferObjectLiteral", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferObjectLiteral", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=objectCalls.d.ts.map

package/lib/rules/objectCalls.js

@@ -1,47 +1,38 @@
-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 literal notation or `Object.create` instead of calling or constructing `Object`.",
-        id: "objectCalls",
-        preset: "stylistic",
-    },
-    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) {
-            if (!ts.isIdentifier(node.expression) ||
-                !isGlobalDeclarationOfName(node.expression, "Object", context.typeChecker)) {
-                return;
-            }
-            const reportNode = node.kind === ts.SyntaxKind.NewExpression
-                ? node.getChildAt(0, context.sourceFile)
-                : node.expression;
-            context.report({
-                message: "preferObjectLiteral",
-                range: getTSNodeRange(reportNode, context.sourceFile),
-            });
-        }
-        return {
-            visitors: {
-                CallExpression: checkNode,
-                NewExpression: checkNode,
-            },
-        };
-    },
+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

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferFromEntries", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=objectEntriesMethods.d.ts.map