eslint-config-typed 5.1.3 → 5.3.0

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.d.mts

@@ -0,0 +1,14 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'useSafeParseFloat';
+/**
+ * Detects `parseFloat(x)`, `Number.parseFloat(x)`, and `Number(x)` (when x
+ * is typed as `string`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` (ts-data-forge).
+ *
+ * `Number(x)` is only flagged when x is purely a string type to avoid false
+ * positives for `Number(someBoolean)` or `Number(someNumber)` uses.
+ */
+export declare const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-num-safe-parse-float.d.mts.map

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-num-safe-parse-float.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAQlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,mBAAmB,CAAC;AAkBtC;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CA6HjE,CAAC"}

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.mjs

@@ -0,0 +1,111 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { getTsDataForgeImport, getNamedImports, buildImportFixes } from './import-utils.mjs';
+
+/**
+ * Returns `true` when every constituent of `type` is string-like, i.e. the
+ * type is assignable to the `string` parameter of `Num.safeParseFloat`. A
+ * union such as `string | undefined` is rejected so the autofix never
+ * produces a type error.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isStringType = (type) => {
+    const parts = type.isUnion() ? type.types : [type];
+    return (parts.length > 0 &&
+        parts.every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0));
+};
+/**
+ * Detects `parseFloat(x)`, `Number.parseFloat(x)`, and `Number(x)` (when x
+ * is typed as `string`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` (ts-data-forge).
+ *
+ * `Number(x)` is only flagged when x is purely a string type to avoid false
+ * positives for `Number(someBoolean)` or `Number(someNumber)` uses.
+ */
+const preferNumSafeParseFloat = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useSafeParseFloat: 'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseFloat({{argName}}), Number.NaN)` from ts-data-forge.',
+        },
+    },
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const program = sourceCode.ast;
+        const tsDataForgeImport = getTsDataForgeImport(program);
+        const services = context.sourceCode.parserServices;
+        const mut_nodesToFix = [];
+        return {
+            CallExpression: (node) => {
+                const { callee } = node;
+                // Match `parseFloat(...)` (global function).
+                const isGlobalParseFloat = callee.type === AST_NODE_TYPES.Identifier &&
+                    callee.name === 'parseFloat';
+                // Match `Number.parseFloat(...)`.
+                const isNumberParseFloat = callee.type === AST_NODE_TYPES.MemberExpression &&
+                    !callee.computed &&
+                    callee.object.type === AST_NODE_TYPES.Identifier &&
+                    callee.object.name === 'Number' &&
+                    callee.property.type === AST_NODE_TYPES.Identifier &&
+                    callee.property.name === 'parseFloat';
+                // Match `Number(...)` called as a function (not `new Number(...)`).
+                const isNumberCall = callee.type === AST_NODE_TYPES.Identifier &&
+                    callee.name === 'Number';
+                if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall)
+                    return;
+                const args = node.arguments;
+                const firstArg = args[0];
+                if (firstArg === undefined)
+                    return;
+                // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
+                if (firstArg.type === AST_NODE_TYPES.SpreadElement)
+                    return;
+                // The argument must be purely `string` so the autofix is type-safe
+                // against `Num.safeParseFloat(s: string)`. Without type information,
+                // skip.
+                if (services?.program == null)
+                    return;
+                const checker = services.program.getTypeChecker();
+                const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
+                if (tsNode === undefined)
+                    return;
+                const argType = checker.getTypeAtLocation(tsNode);
+                if (!isStringType(argType))
+                    return;
+                mut_nodesToFix.push({ node, argExpression: firstArg });
+            },
+            'Program:exit': () => {
+                const namedImports = getNamedImports(tsDataForgeImport);
+                const missingImports = ['Num', 'Result'].filter((name) => !namedImports.includes(name));
+                for (const [index, { node, argExpression },] of mut_nodesToFix.entries()) {
+                    const argText = sourceCode.getText(argExpression);
+                    const originalText = sourceCode.getText(node);
+                    context.report({
+                        node,
+                        messageId: 'useSafeParseFloat',
+                        data: {
+                            original: originalText,
+                            argName: argText,
+                        },
+                        fix: (fixer) => {
+                            const core = `Result.unwrapOkOr(Num.safeParseFloat(${argText}), Number.NaN)`;
+                            const importFixes = index === 0 && missingImports.length > 0
+                                ? buildImportFixes(fixer, program, tsDataForgeImport, missingImports)
+                                : [];
+                            return [...importFixes, fixer.replaceText(node, core)];
+                        },
+                    });
+                }
+            },
+        };
+    },
+    defaultOptions: [],
+};
+
+export { preferNumSafeParseFloat };
+//# sourceMappingURL=prefer-num-safe-parse-float.mjs.map

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-num-safe-parse-float.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAgBA;;;;;AAKG;AACH;AACA,MAAM,YAAY,GAAG,CAAC,IAAa,KAAa;AAC9C,IAAA,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,GAAI,CAAC,IAAI,CAAW;AAE7D,IAAA,QACE,KAAK,CAAC,MAAM,GAAG,CAAC;QAChB,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,MAAM,CAAC,CAAC;AAEjE,CAAC;AAED;;;;;;;AAOG;AACI,MAAM,uBAAuB,GAClC;AACE,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EACT,sKAAsK;AACzK,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,iBAAiB,EACf,kHAAkH;AACrH,SAAA;AACF,KAAA;AAED,IAAA,MAAM,EAAE,CAAC,OAAO,KAAI;AAClB,QAAA,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU;AAErC,QAAA,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG;AAE9B,QAAA,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,OAAO,CAAC;AAEvD,QAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,cAAc;QAElD,MAAM,cAAc,GAGd,EAAE;QAER,OAAO;AACL,YAAA,cAAc,EAAE,CAAC,IAAI,KAAI;AACvB,gBAAA,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;;gBAGvB,MAAM,kBAAkB,GACtB,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACzC,oBAAA,MAAM,CAAC,IAAI,KAAK,YAAY;;gBAG9B,MAAM,kBAAkB,GACtB,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;oBAC/C,CAAC,MAAM,CAAC,QAAQ;AAChB,oBAAA,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAChD,oBAAA,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;AAC/B,oBAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAClD,oBAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;;gBAGvC,MAAM,YAAY,GAChB,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACzC,oBAAA,MAAM,CAAC,IAAI,KAAK,QAAQ;AAE1B,gBAAA,IAAI,CAAC,kBAAkB,IAAI,CAAC,kBAAkB,IAAI,CAAC,YAAY;oBAC7D;AAEF,gBAAA,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS;AAE3B,gBAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC;gBAExB,IAAI,QAAQ,KAAK,SAAS;oBAAE;;AAG5B,gBAAA,IAAI,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,aAAa;oBAAE;;;;AAKpD,gBAAA,IAAI,QAAQ,EAAE,OAAO,IAAI,IAAI;oBAAE;gBAE/B,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,cAAc,EAAE;gBAEjD,MAAM,MAAM,GAAG,QAAQ,CAAC,qBAAqB,EAAE,GAAG,CAAC,QAAQ,CAAC;gBAE5D,IAAI,MAAM,KAAK,SAAS;oBAAE;gBAE1B,MAAM,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC;AAEjD,gBAAA,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;oBAAE;gBAE5B,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;YACxD,CAAC;YACD,cAAc,EAAE,MAAK;AACnB,gBAAA,MAAM,YAAY,GAAG,eAAe,CAAC,iBAAiB,CAAC;gBAEvD,MAAM,cAAc,GAAI,CAAC,KAAK,EAAE,QAAQ,CAAW,CAAC,MAAM,CACxD,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CACvC;AAED,gBAAA,KAAK,MAAM,CACT,KAAK,EACL,EAAE,IAAI,EAAE,aAAa,EAAE,EACxB,IAAI,cAAc,CAAC,OAAO,EAAE,EAAE;oBAC7B,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,aAAa,CAAC;oBAEjD,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC;oBAE7C,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;AACJ,wBAAA,SAAS,EAAE,mBAAmB;AAC9B,wBAAA,IAAI,EAAE;AACJ,4BAAA,QAAQ,EAAE,YAAY;AACtB,4BAAA,OAAO,EAAE,OAAO;AACjB,yBAAA;AACD,wBAAA,GAAG,EAAE,CAAC,KAAK,KAAI;AACb,4BAAA,MAAM,IAAI,GAAG,CAAA,qCAAA,EAAwC,OAAO,gBAAgB;4BAE5E,MAAM,WAAW,GACf,KAAK,KAAK,CAAC,IAAI,cAAc,CAAC,MAAM,GAAG;kCACnC,gBAAgB,CACd,KAAK,EACL,OAAO,EACP,iBAAiB,EACjB,cAAc;kCAEhB,EAAE;AAER,4BAAA,OAAO,CAAC,GAAG,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;wBACxD,CAAC;AACF,qBAAA,CAAC;gBACJ;YACF,CAAC;SACF;IACH,CAAC;AACD,IAAA,cAAc,EAAE,EAAE;;;;;"}

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.d.mts

@@ -0,0 +1,14 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'useSafeParseInt';
+/**
+ * Detects the base-10 forms of `parseInt` / `Number.parseInt` (`parseInt(x)` or
+ * `parseInt(x, 10)`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` (ts-data-forge).
+ *
+ * Other radixes (e.g. `parseInt(x, 16)`) are intentionally left untouched, as
+ * `Num.safeParseInt` only supports base 10.
+ */
+export declare const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-num-safe-parse-int.d.mts.map

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-num-safe-parse-int.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAQlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,iBAAiB,CAAC;AAkBpC;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CA6HjE,CAAC"}

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.mjs

@@ -0,0 +1,113 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { getTsDataForgeImport, getNamedImports, buildImportFixes } from './import-utils.mjs';
+
+/**
+ * Returns `true` when every constituent of `type` is string-like, i.e. the type
+ * is assignable to the `string` parameter of `Num.safeParseInt`. A union such
+ * as `string | undefined` is rejected so the autofix never produces a type
+ * error.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isStringType = (type) => {
+    const parts = type.isUnion() ? type.types : [type];
+    return (parts.length > 0 &&
+        parts.every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0));
+};
+/**
+ * Detects the base-10 forms of `parseInt` / `Number.parseInt` (`parseInt(x)` or
+ * `parseInt(x, 10)`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` (ts-data-forge).
+ *
+ * Other radixes (e.g. `parseInt(x, 16)`) are intentionally left untouched, as
+ * `Num.safeParseInt` only supports base 10.
+ */
+const preferNumSafeParseInt = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Replace `parseInt(x, 10)` with `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` from ts-data-forge.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useSafeParseInt: 'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseInt({{argName}}), Number.NaN)` from ts-data-forge.',
+        },
+    },
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const program = sourceCode.ast;
+        const tsDataForgeImport = getTsDataForgeImport(program);
+        const services = context.sourceCode.parserServices;
+        const mut_nodesToFix = [];
+        return {
+            CallExpression: (node) => {
+                const { callee } = node;
+                // Match `parseInt(...)` or `Number.parseInt(...)`.
+                const isGlobalParseInt = callee.type === AST_NODE_TYPES.Identifier &&
+                    callee.name === 'parseInt';
+                const isNumberParseInt = callee.type === AST_NODE_TYPES.MemberExpression &&
+                    !callee.computed &&
+                    callee.object.type === AST_NODE_TYPES.Identifier &&
+                    callee.object.name === 'Number' &&
+                    callee.property.type === AST_NODE_TYPES.Identifier &&
+                    callee.property.name === 'parseInt';
+                if (!isGlobalParseInt && !isNumberParseInt)
+                    return;
+                const args = node.arguments;
+                const firstArg = args[0];
+                if (firstArg === undefined)
+                    return;
+                // Spread argument (`parseInt(...rest)`) cannot be rewritten safely.
+                if (firstArg.type === AST_NODE_TYPES.SpreadElement)
+                    return;
+                // Only base 10: accept a missing radix or an explicit literal `10`.
+                if (args.length >= 2) {
+                    const radix = args[1];
+                    if (radix?.type !== AST_NODE_TYPES.Literal || radix.value !== 10) {
+                        return;
+                    }
+                }
+                // The argument must be a `string` so the autofix is type-safe against
+                // `Num.safeParseInt(s: string)`. Without type information, skip.
+                if (services?.program == null)
+                    return;
+                const checker = services.program.getTypeChecker();
+                const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
+                if (tsNode === undefined)
+                    return;
+                const argType = checker.getTypeAtLocation(tsNode);
+                if (!isStringType(argType))
+                    return;
+                mut_nodesToFix.push({ node, argExpression: firstArg });
+            },
+            'Program:exit': () => {
+                const namedImports = getNamedImports(tsDataForgeImport);
+                const missingImports = ['Num', 'Result'].filter((name) => !namedImports.includes(name));
+                for (const [index, { node, argExpression },] of mut_nodesToFix.entries()) {
+                    const argText = sourceCode.getText(argExpression);
+                    const originalText = sourceCode.getText(node);
+                    context.report({
+                        node,
+                        messageId: 'useSafeParseInt',
+                        data: {
+                            original: originalText,
+                            argName: argText,
+                        },
+                        fix: (fixer) => {
+                            const core = `Result.unwrapOkOr(Num.safeParseInt(${argText}), Number.NaN)`;
+                            const importFixes = index === 0 && missingImports.length > 0
+                                ? buildImportFixes(fixer, program, tsDataForgeImport, missingImports)
+                                : [];
+                            return [...importFixes, fixer.replaceText(node, core)];
+                        },
+                    });
+                }
+            },
+        };
+    },
+    defaultOptions: [],
+};
+
+export { preferNumSafeParseInt };
+//# sourceMappingURL=prefer-num-safe-parse-int.mjs.map

package/dist/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-num-safe-parse-int.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/ts-data-forge/rules/rules.d.mts

@@ -8,6 +8,8 @@ export declare const tsDataForgeRules: {
     readonly 'prefer-is-non-null-object': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNonNullObject", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-range-for-loop': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useRangeForLoop", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-is-record-and-has-key': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsRecordAndHasKey", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-num-safe-parse-int': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useSafeParseInt", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-num-safe-parse-float': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useSafeParseFloat", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'no-unnecessary-type-guard': import("@typescript-eslint/utils/ts-eslint").RuleModule<"alwaysTrue" | "alwaysFalse" | "replaceTypeGuard", readonly [(Readonly<{
         ignore?: readonly string[];
     }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/plugins/ts-data-forge/rules/rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"names":[],"mappings":"AAaA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;CAYa,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAca,CAAC"}

package/dist/plugins/ts-data-forge/rules/rules.mjs

@@ -8,6 +8,8 @@ import { preferAsInt } from './prefer-as-int.mjs';
 import { preferComparisonOverNullishGuard } from './prefer-comparison-over-nullish-guard.mjs';
 import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
 import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
+import { preferNumSafeParseFloat } from './prefer-num-safe-parse-float.mjs';
+import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
 import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
 
 const tsDataForgeRules = {
@@ -20,6 +22,8 @@ const tsDataForgeRules = {
     'prefer-is-non-null-object': preferIsNonNullObject,
     'prefer-range-for-loop': preferRangeForLoop,
     'prefer-is-record-and-has-key': preferIsRecordAndHasKey,
+    'prefer-num-safe-parse-int': preferNumSafeParseInt,
+    'prefer-num-safe-parse-float': preferNumSafeParseFloat,
     'no-unnecessary-type-guard': noUnnecessaryTypeGuard,
     'prefer-comparison-over-nullish-guard': preferComparisonOverNullishGuard,
 };

package/dist/plugins/ts-data-forge/rules/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAaO,MAAM,gBAAgB,GAAG;AAC9B,IAAA,qCAAqC,EAAE,6BAA6B;AACpE,IAAA,+BAA+B,EAAE,wBAAwB;AACzD,IAAA,qBAAqB,EAAE,gBAAgB;AACvC,IAAA,yBAAyB,EAAE,mBAAmB;AAC9C,IAAA,gBAAgB,EAAE,YAAY;AAC9B,IAAA,eAAe,EAAE,WAAW;AAC5B,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,uBAAuB,EAAE,kBAAkB;AAC3C,IAAA,8BAA8B,EAAE,uBAAuB;AACvD,IAAA,2BAA2B,EAAE,sBAAsB;AACnD,IAAA,sCAAsC,EAAE,gCAAgC;;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;AAeO,MAAM,gBAAgB,GAAG;AAC9B,IAAA,qCAAqC,EAAE,6BAA6B;AACpE,IAAA,+BAA+B,EAAE,wBAAwB;AACzD,IAAA,qBAAqB,EAAE,gBAAgB;AACvC,IAAA,yBAAyB,EAAE,mBAAmB;AAC9C,IAAA,gBAAgB,EAAE,YAAY;AAC9B,IAAA,eAAe,EAAE,WAAW;AAC5B,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,uBAAuB,EAAE,kBAAkB;AAC3C,IAAA,8BAA8B,EAAE,uBAAuB;AACvD,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,6BAA6B,EAAE,uBAAuB;AACtD,IAAA,2BAA2B,EAAE,sBAAsB;AACnD,IAAA,sCAAsC,EAAE,gCAAgC;;;;;"}

package/dist/rules/eslint-ts-data-forge-rules.d.mts

@@ -8,6 +8,8 @@ export declare const eslintTsDataForgeRules: {
     readonly 'ts-data-forge/prefer-arr-is-array-at-least-length': "error";
     readonly 'ts-data-forge/prefer-arr-is-array-of-length': "error";
     readonly 'ts-data-forge/prefer-is-record-and-has-key': "error";
+    readonly 'ts-data-forge/prefer-num-safe-parse-int': "error";
+    readonly 'ts-data-forge/prefer-num-safe-parse-float': "error";
     readonly 'ts-data-forge/no-unnecessary-type-guard': 2 | 1;
     readonly 'ts-data-forge/prefer-comparison-over-nullish-guard': "error";
 };

package/dist/rules/eslint-ts-data-forge-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-data-forge-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-ts-data-forge-rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;CAYQ,CAAC"}
+{"version":3,"file":"eslint-ts-data-forge-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-ts-data-forge-rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAcQ,CAAC"}

package/dist/rules/eslint-ts-data-forge-rules.mjs

@@ -10,6 +10,8 @@ const eslintTsDataForgeRules = {
     'ts-data-forge/prefer-arr-is-array-at-least-length': 'error',
     'ts-data-forge/prefer-arr-is-array-of-length': 'error',
     'ts-data-forge/prefer-is-record-and-has-key': 'error',
+    'ts-data-forge/prefer-num-safe-parse-int': 'error',
+    'ts-data-forge/prefer-num-safe-parse-float': 'error',
     'ts-data-forge/no-unnecessary-type-guard': withDefaultOption('error'),
     'ts-data-forge/prefer-comparison-over-nullish-guard': 'error',
 };

package/dist/rules/eslint-ts-data-forge-rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-data-forge-rules.mjs","sources":["../../src/rules/eslint-ts-data-forge-rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKO,MAAM,sBAAsB,GAAG;AACpC,IAAA,6BAA6B,EAAE,OAAO;AACtC,IAAA,yCAAyC,EAAE,OAAO;AAClD,IAAA,mCAAmC,EAAE,OAAO;AAC5C,IAAA,uCAAuC,EAAE,OAAO;AAChD,IAAA,8BAA8B,EAAE,OAAO;AACvC,IAAA,qCAAqC,EAAE,OAAO;AAC9C,IAAA,mDAAmD,EAAE,OAAO;AAC5D,IAAA,6CAA6C,EAAE,OAAO;AACtD,IAAA,4CAA4C,EAAE,OAAO;AACrD,IAAA,yCAAyC,EAAE,iBAAiB,CAAC,OAAO,CAAC;AACrE,IAAA,oDAAoD,EAAE,OAAO;;;;;"}
+{"version":3,"file":"eslint-ts-data-forge-rules.mjs","sources":["../../src/rules/eslint-ts-data-forge-rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKO,MAAM,sBAAsB,GAAG;AACpC,IAAA,6BAA6B,EAAE,OAAO;AACtC,IAAA,yCAAyC,EAAE,OAAO;AAClD,IAAA,mCAAmC,EAAE,OAAO;AAC5C,IAAA,uCAAuC,EAAE,OAAO;AAChD,IAAA,8BAA8B,EAAE,OAAO;AACvC,IAAA,qCAAqC,EAAE,OAAO;AAC9C,IAAA,mDAAmD,EAAE,OAAO;AAC5D,IAAA,6CAA6C,EAAE,OAAO;AACtD,IAAA,4CAA4C,EAAE,OAAO;AACrD,IAAA,yCAAyC,EAAE,OAAO;AAClD,IAAA,2CAA2C,EAAE,OAAO;AACpD,IAAA,yCAAyC,EAAE,iBAAiB,CAAC,OAAO,CAAC;AACrE,IAAA,oDAAoD,EAAE,OAAO;;;;;"}

package/dist/rules/eslint-unicorn-rules.d.mts

@@ -231,7 +231,7 @@ export declare const eslintUnicornRules: {
     readonly 'unicorn/prefer-iterator-to-array-at-end': "error";
     readonly 'unicorn/prefer-math-abs': "error";
     readonly 'unicorn/prefer-minimal-ternary': "off";
-    readonly 'unicorn/prefer-number-coercion': "error";
+    readonly 'unicorn/prefer-number-coercion': "off";
     readonly 'unicorn/prefer-number-is-safe-integer': "error";
     readonly 'unicorn/prefer-object-define-properties': "error";
     readonly 'unicorn/prefer-object-destructuring-defaults': "error";

package/dist/rules/eslint-unicorn-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-unicorn-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-unicorn-rules.mts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;IAC7B;;;;OAIG;;;;;IAOH,iDAAiD;;;;;;;;IAUjD,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0HrC;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8OkC,CAAC"}
+{"version":3,"file":"eslint-unicorn-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-unicorn-rules.mts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;IAC7B;;;;OAIG;;;;;IAOH,iDAAiD;;;;;;;;IAUjD,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0HrC;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoPkC,CAAC"}

package/dist/rules/eslint-unicorn-rules.mjs

@@ -277,7 +277,12 @@ const eslintUnicornRules = {
     'unicorn/prefer-math-abs': 'error',
     // This rule is disabled because it would require the container to be directly included in the React hooks dependencies.
     'unicorn/prefer-minimal-ternary': 'off',
-    'unicorn/prefer-number-coercion': 'error',
+    // Disabled in favor of `ts-data-forge/prefer-num-safe-parse-int`, which
+    // rewrites `parseInt(x, 10)` to `Num.safeParseInt(x)` instead of
+    // `Math.trunc(Number(x))`. The latter is hard to read and silently changes
+    // parsing semantics (e.g. `Number('')` is `0` whereas `parseInt('', 10)` is
+    // `NaN`).
+    'unicorn/prefer-number-coercion': 'off',
     'unicorn/prefer-number-is-safe-integer': 'error',
     'unicorn/prefer-object-define-properties': 'error',
     'unicorn/prefer-object-destructuring-defaults': 'error',

package/dist/rules/eslint-unicorn-rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-unicorn-rules.mjs","sources":["../../src/rules/eslint-unicorn-rules.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"eslint-unicorn-rules.mjs","sources":["../../src/rules/eslint-unicorn-rules.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/types/rules/eslint-ts-data-forge-rules.d.mts

@@ -126,6 +126,34 @@ declare namespace PreferRangeForLoop {
 declare namespace PreferIsRecordAndHasKey {
     type RuleEntry = Linter.StringSeverity;
 }
+/**
+ * @description Replace `parseInt(x, 10)` with `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferNumSafeParseInt {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferNumSafeParseFloat {
+    type RuleEntry = Linter.StringSeverity;
+}
 /**
  * @description Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).
  *
@@ -191,6 +219,8 @@ export type EslintTsDataForgeRules = Readonly<{
     'ts-data-forge/prefer-is-non-null-object': PreferIsNonNullObject.RuleEntry;
     'ts-data-forge/prefer-range-for-loop': PreferRangeForLoop.RuleEntry;
     'ts-data-forge/prefer-is-record-and-has-key': PreferIsRecordAndHasKey.RuleEntry;
+    'ts-data-forge/prefer-num-safe-parse-int': PreferNumSafeParseInt.RuleEntry;
+    'ts-data-forge/prefer-num-safe-parse-float': PreferNumSafeParseFloat.RuleEntry;
     'ts-data-forge/no-unnecessary-type-guard': NoUnnecessaryTypeGuard.RuleEntry;
     'ts-data-forge/prefer-comparison-over-nullish-guard': PreferComparisonOverNullishGuard.RuleEntry;
 }>;

package/dist/types/rules/eslint-ts-data-forge-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-data-forge-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-ts-data-forge-rules.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"eslint-ts-data-forge-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-ts-data-forge-rules.mts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-typed",
-  "version": "5.1.3",
+  "version": "5.3.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.mts

@@ -0,0 +1,166 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useSafeParseFloat';
+
+/**
+ * Returns `true` when every constituent of `type` is string-like, i.e. the
+ * type is assignable to the `string` parameter of `Num.safeParseFloat`. A
+ * union such as `string | undefined` is rejected so the autofix never
+ * produces a type error.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isStringType = (type: ts.Type): boolean => {
+  const parts = type.isUnion() ? type.types : ([type] as const);
+
+  return (
+    parts.length > 0 &&
+    parts.every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0)
+  );
+};
+
+/**
+ * Detects `parseFloat(x)`, `Number.parseFloat(x)`, and `Number(x)` (when x
+ * is typed as `string`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` (ts-data-forge).
+ *
+ * `Number(x)` is only flagged when x is purely a string type to avoid false
+ * positives for `Number(someBoolean)` or `Number(someNumber)` uses.
+ */
+export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
+  {
+    meta: {
+      type: 'suggestion',
+      docs: {
+        description:
+          'Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.',
+      },
+      fixable: 'code',
+      schema: [],
+      messages: {
+        useSafeParseFloat:
+          'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseFloat({{argName}}), Number.NaN)` from ts-data-forge.',
+      },
+    },
+
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+
+      const program = sourceCode.ast;
+
+      const tsDataForgeImport = getTsDataForgeImport(program);
+
+      const services = context.sourceCode.parserServices;
+
+      const mut_nodesToFix: {
+        node: TSESTree.CallExpression;
+        argExpression: TSESTree.Expression;
+      }[] = [];
+
+      return {
+        CallExpression: (node) => {
+          const { callee } = node;
+
+          // Match `parseFloat(...)` (global function).
+          const isGlobalParseFloat =
+            callee.type === AST_NODE_TYPES.Identifier &&
+            callee.name === 'parseFloat';
+
+          // Match `Number.parseFloat(...)`.
+          const isNumberParseFloat =
+            callee.type === AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.object.type === AST_NODE_TYPES.Identifier &&
+            callee.object.name === 'Number' &&
+            callee.property.type === AST_NODE_TYPES.Identifier &&
+            callee.property.name === 'parseFloat';
+
+          // Match `Number(...)` called as a function (not `new Number(...)`).
+          const isNumberCall =
+            callee.type === AST_NODE_TYPES.Identifier &&
+            callee.name === 'Number';
+
+          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall)
+            return;
+
+          const args = node.arguments;
+
+          const firstArg = args[0];
+
+          if (firstArg === undefined) return;
+
+          // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
+          if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+
+          // The argument must be purely `string` so the autofix is type-safe
+          // against `Num.safeParseFloat(s: string)`. Without type information,
+          // skip.
+          if (services?.program == null) return;
+
+          const checker = services.program.getTypeChecker();
+
+          const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
+
+          if (tsNode === undefined) return;
+
+          const argType = checker.getTypeAtLocation(tsNode);
+
+          if (!isStringType(argType)) return;
+
+          mut_nodesToFix.push({ node, argExpression: firstArg });
+        },
+        'Program:exit': () => {
+          const namedImports = getNamedImports(tsDataForgeImport);
+
+          const missingImports = (['Num', 'Result'] as const).filter(
+            (name) => !namedImports.includes(name),
+          );
+
+          for (const [
+            index,
+            { node, argExpression },
+          ] of mut_nodesToFix.entries()) {
+            const argText = sourceCode.getText(argExpression);
+
+            const originalText = sourceCode.getText(node);
+
+            context.report({
+              node,
+              messageId: 'useSafeParseFloat',
+              data: {
+                original: originalText,
+                argName: argText,
+              },
+              fix: (fixer) => {
+                const core = `Result.unwrapOkOr(Num.safeParseFloat(${argText}), Number.NaN)`;
+
+                const importFixes =
+                  index === 0 && missingImports.length > 0
+                    ? buildImportFixes(
+                        fixer,
+                        program,
+                        tsDataForgeImport,
+                        missingImports,
+                      )
+                    : [];
+
+                return [...importFixes, fixer.replaceText(node, core)];
+              },
+            });
+          }
+        },
+      };
+    },
+    defaultOptions: [],
+  } as const;

package/src/plugins/ts-data-forge/rules/prefer-num-safe-parse-float.test.mts

@@ -0,0 +1,163 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferNumSafeParseFloat } from './prefer-num-safe-parse-float.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-num-safe-parse-float', () => {
+  tester.run('prefer-num-safe-parse-float', preferNumSafeParseFloat, {
+    valid: [
+      {
+        name: 'ignores number arguments to Number() (autofix would be unsafe)',
+        code: dedent`
+          const x = 42;
+          const n = Number(x);
+        `,
+      },
+      {
+        name: 'ignores boolean arguments to Number()',
+        code: dedent`
+          const b = true;
+          const n = Number(b);
+        `,
+      },
+      {
+        name: 'ignores never-typed arguments (string & number = never)',
+        code: dedent`
+          declare const x: string & number;
+          const n = parseFloat(x);
+        `,
+      },
+      {
+        name: 'ignores spread arguments',
+        code: dedent`
+          declare const args: [string];
+          const n = parseFloat(...args);
+        `,
+      },
+      {
+        name: 'ignores parseInt (handled by prefer-num-safe-parse-int)',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces parseFloat(s) and imports Num + Result',
+        code: dedent`
+          const s = "3.14";
+          const n = parseFloat(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces Number.parseFloat(s)',
+        code: dedent`
+          const s = "3.14";
+          const n = Number.parseFloat(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces Number(s) when s is a string',
+        code: dedent`
+          const s = "3.14";
+          const n = Number(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'adds only the missing Result import when Num is present',
+        code: dedent`
+          import { Num } from 'ts-data-forge';
+
+          const s = "3.14";
+          const n = parseFloat(s);
+        `,
+        output: dedent`
+          import { Result } from 'ts-data-forge';
+          import { Num } from 'ts-data-forge';
+
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'preserves a complex string argument expression',
+        code: dedent`
+          const get = (k: string): string => k;
+          const n = parseFloat(get("x").trim());
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const get = (k: string): string => k;
+          const n = Result.unwrapOkOr(Num.safeParseFloat(get("x").trim()), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces Number(s) with a string literal argument',
+        code: dedent`
+          const n = Number("3.14");
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const n = Result.unwrapOkOr(Num.safeParseFloat("3.14"), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces all three forms in one file',
+        code: dedent`
+          const s = "1.5";
+          const a = parseFloat(s);
+          const b = Number.parseFloat(s);
+          const c = Number(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "1.5";
+          const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          const c = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
+        ],
+      },
+    ],
+  });
+}, 20000);

package/src/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.mts

@@ -0,0 +1,166 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useSafeParseInt';
+
+/**
+ * Returns `true` when every constituent of `type` is string-like, i.e. the type
+ * is assignable to the `string` parameter of `Num.safeParseInt`. A union such
+ * as `string | undefined` is rejected so the autofix never produces a type
+ * error.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isStringType = (type: ts.Type): boolean => {
+  const parts = type.isUnion() ? type.types : ([type] as const);
+
+  return (
+    parts.length > 0 &&
+    parts.every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0)
+  );
+};
+
+/**
+ * Detects the base-10 forms of `parseInt` / `Number.parseInt` (`parseInt(x)` or
+ * `parseInt(x, 10)`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` (ts-data-forge).
+ *
+ * Other radixes (e.g. `parseInt(x, 16)`) are intentionally left untouched, as
+ * `Num.safeParseInt` only supports base 10.
+ */
+export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `parseInt(x, 10)` with `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useSafeParseInt:
+        'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseInt({{argName}}), Number.NaN)` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const services = context.sourceCode.parserServices;
+
+    const mut_nodesToFix: {
+      node: TSESTree.CallExpression;
+      argExpression: TSESTree.Expression;
+    }[] = [];
+
+    return {
+      CallExpression: (node) => {
+        const { callee } = node;
+
+        // Match `parseInt(...)` or `Number.parseInt(...)`.
+        const isGlobalParseInt =
+          callee.type === AST_NODE_TYPES.Identifier &&
+          callee.name === 'parseInt';
+
+        const isNumberParseInt =
+          callee.type === AST_NODE_TYPES.MemberExpression &&
+          !callee.computed &&
+          callee.object.type === AST_NODE_TYPES.Identifier &&
+          callee.object.name === 'Number' &&
+          callee.property.type === AST_NODE_TYPES.Identifier &&
+          callee.property.name === 'parseInt';
+
+        if (!isGlobalParseInt && !isNumberParseInt) return;
+
+        const args = node.arguments;
+
+        const firstArg = args[0];
+
+        if (firstArg === undefined) return;
+
+        // Spread argument (`parseInt(...rest)`) cannot be rewritten safely.
+        if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+
+        // Only base 10: accept a missing radix or an explicit literal `10`.
+        if (args.length >= 2) {
+          const radix = args[1];
+
+          if (radix?.type !== AST_NODE_TYPES.Literal || radix.value !== 10) {
+            return;
+          }
+        }
+
+        // The argument must be a `string` so the autofix is type-safe against
+        // `Num.safeParseInt(s: string)`. Without type information, skip.
+        if (services?.program == null) return;
+
+        const checker = services.program.getTypeChecker();
+
+        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
+
+        if (tsNode === undefined) return;
+
+        const argType = checker.getTypeAtLocation(tsNode);
+
+        if (!isStringType(argType)) return;
+
+        mut_nodesToFix.push({ node, argExpression: firstArg });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const missingImports = (['Num', 'Result'] as const).filter(
+          (name) => !namedImports.includes(name),
+        );
+
+        for (const [
+          index,
+          { node, argExpression },
+        ] of mut_nodesToFix.entries()) {
+          const argText = sourceCode.getText(argExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useSafeParseInt',
+            data: {
+              original: originalText,
+              argName: argText,
+            },
+            fix: (fixer) => {
+              const core = `Result.unwrapOkOr(Num.safeParseInt(${argText}), Number.NaN)`;
+
+              const importFixes =
+                index === 0 && missingImports.length > 0
+                  ? buildImportFixes(
+                      fixer,
+                      program,
+                      tsDataForgeImport,
+                      missingImports,
+                    )
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, core)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;

package/src/plugins/ts-data-forge/rules/prefer-num-safe-parse-int.test.mts

@@ -0,0 +1,137 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-num-safe-parse-int', () => {
+  tester.run('prefer-num-safe-parse-int', preferNumSafeParseInt, {
+    valid: [
+      {
+        name: 'ignores non-base-10 radix',
+        code: dedent`
+          const s = "ff";
+          const n = parseInt(s, 16);
+        `,
+      },
+      {
+        name: 'ignores number arguments (autofix would be unsafe)',
+        code: dedent`
+          const x = 42;
+          const n = parseInt(x, 10);
+        `,
+      },
+      {
+        name: 'ignores never-typed arguments',
+        code: dedent`
+          declare const x: string & number;
+          const n = parseInt(x, 10);
+        `,
+      },
+      {
+        name: 'ignores unrelated calls',
+        code: dedent`
+          const s = "1";
+          const n = Number(s);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces parseInt(s, 10) and imports Num + Result',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'replaces parseInt(s) without radix',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'replaces Number.parseInt(s, 10)',
+        code: dedent`
+          const s = "123";
+          const n = Number.parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'adds only the missing Result import when Num is present',
+        code: dedent`
+          import { Num } from 'ts-data-forge';
+
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Result } from 'ts-data-forge';
+          import { Num } from 'ts-data-forge';
+
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'wraps in parentheses in an operator context',
+        code: dedent`
+          const s = "123";
+          const ok = parseInt(s, 10) > 5;
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const ok = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN) > 5;
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'preserves a complex string argument expression',
+        code: dedent`
+          const get = (k: string): string => k;
+          const n = parseInt(get("x").trim(), 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const get = (k: string): string => k;
+          const n = Result.unwrapOkOr(Num.safeParseInt(get("x").trim()), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+    ],
+  });
+}, 20000);

package/src/plugins/ts-data-forge/rules/rules.mts

@@ -9,6 +9,8 @@ import { preferAsInt } from './prefer-as-int.mjs';
 import { preferComparisonOverNullishGuard } from './prefer-comparison-over-nullish-guard.mjs';
 import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
 import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
+import { preferNumSafeParseFloat } from './prefer-num-safe-parse-float.mjs';
+import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
 import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
 
 export const tsDataForgeRules = {
@@ -21,6 +23,8 @@ export const tsDataForgeRules = {
   'prefer-is-non-null-object': preferIsNonNullObject,
   'prefer-range-for-loop': preferRangeForLoop,
   'prefer-is-record-and-has-key': preferIsRecordAndHasKey,
+  'prefer-num-safe-parse-int': preferNumSafeParseInt,
+  'prefer-num-safe-parse-float': preferNumSafeParseFloat,
   'no-unnecessary-type-guard': noUnnecessaryTypeGuard,
   'prefer-comparison-over-nullish-guard': preferComparisonOverNullishGuard,
 } as const satisfies ESLintPlugin['rules'];

package/src/rules/eslint-ts-data-forge-rules.mts

@@ -13,6 +13,8 @@ export const eslintTsDataForgeRules = {
   'ts-data-forge/prefer-arr-is-array-at-least-length': 'error',
   'ts-data-forge/prefer-arr-is-array-of-length': 'error',
   'ts-data-forge/prefer-is-record-and-has-key': 'error',
+  'ts-data-forge/prefer-num-safe-parse-int': 'error',
+  'ts-data-forge/prefer-num-safe-parse-float': 'error',
   'ts-data-forge/no-unnecessary-type-guard': withDefaultOption('error'),
   'ts-data-forge/prefer-comparison-over-nullish-guard': 'error',
 } as const satisfies EslintTsDataForgeRules;

package/src/rules/eslint-unicorn-rules.mts

@@ -306,7 +306,13 @@ export const eslintUnicornRules = {
   // This rule is disabled because it would require the container to be directly included in the React hooks dependencies.
   'unicorn/prefer-minimal-ternary': 'off',
 
-  'unicorn/prefer-number-coercion': 'error',
+  // Disabled in favor of `ts-data-forge/prefer-num-safe-parse-int`, which
+  // rewrites `parseInt(x, 10)` to `Num.safeParseInt(x)` instead of
+  // `Math.trunc(Number(x))`. The latter is hard to read and silently changes
+  // parsing semantics (e.g. `Number('')` is `0` whereas `parseInt('', 10)` is
+  // `NaN`).
+  'unicorn/prefer-number-coercion': 'off',
+
   'unicorn/prefer-number-is-safe-integer': 'error',
   'unicorn/prefer-object-define-properties': 'error',
   'unicorn/prefer-object-destructuring-defaults': 'error',

package/src/types/rules/eslint-ts-data-forge-rules.mts

@@ -142,6 +142,36 @@ namespace PreferIsRecordAndHasKey {
   export type RuleEntry = Linter.StringSeverity;
 }
 
+/**
+ * @description Replace `parseInt(x, 10)` with `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+namespace PreferNumSafeParseInt {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
+/**
+ * @description Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+namespace PreferNumSafeParseFloat {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
 /**
  * @description Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).
  *
@@ -213,6 +243,8 @@ export type EslintTsDataForgeRules = Readonly<{
   'ts-data-forge/prefer-is-non-null-object': PreferIsNonNullObject.RuleEntry;
   'ts-data-forge/prefer-range-for-loop': PreferRangeForLoop.RuleEntry;
   'ts-data-forge/prefer-is-record-and-has-key': PreferIsRecordAndHasKey.RuleEntry;
+  'ts-data-forge/prefer-num-safe-parse-int': PreferNumSafeParseInt.RuleEntry;
+  'ts-data-forge/prefer-num-safe-parse-float': PreferNumSafeParseFloat.RuleEntry;
   'ts-data-forge/no-unnecessary-type-guard': NoUnnecessaryTypeGuard.RuleEntry;
   'ts-data-forge/prefer-comparison-over-nullish-guard': PreferComparisonOverNullishGuard.RuleEntry;
 }>;