eslint-config-typed 5.2.0 → 5.3.1

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":"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"}

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

@@ -9,6 +9,7 @@ export declare const tsDataForgeRules: {
     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":"AAcA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;CAaa,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,7 @@ 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';
 
@@ -22,6 +23,7 @@ const tsDataForgeRules = {
     '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":";;;;;;;;;;;;;AAcO,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,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

@@ -9,6 +9,7 @@ export declare const eslintTsDataForgeRules: {
     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;;;;;;;;;;;;;CAaQ,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

@@ -11,6 +11,7 @@ const eslintTsDataForgeRules = {
     '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,OAAO;AAClD,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/types/rules/eslint-ts-data-forge-rules.d.mts

@@ -140,6 +140,20 @@ declare namespace PreferIsRecordAndHasKey {
 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).
  *
@@ -206,6 +220,7 @@ export type EslintTsDataForgeRules = Readonly<{
     '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.2.0",
+  "version": "5.3.1",
   "private": false,
   "keywords": [
     "typescript"
@@ -93,7 +93,7 @@
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/eslint": "^9.6.1",
     "@typescript-eslint/eslint-plugin": "^8.61.1",
-    "@typescript-eslint/parser": "^8.61.1",
+    "@typescript-eslint/parser": "^8.62.0",
     "@typescript-eslint/type-utils": "^8.61.1",
     "@typescript-eslint/utils": "^8.61.1",
     "@vitest/eslint-plugin": "^1.6.20",
@@ -165,7 +165,7 @@
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.7",
-    "rollup": "4.62.0",
+    "rollup": "4.62.2",
     "semantic-release": "25.0.5",
     "ts-codemod-lib": "2.2.0",
     "ts-fortress": "7.1.0",

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/rules.mts

@@ -9,6 +9,7 @@ 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';
 
@@ -23,6 +24,7 @@ export const tsDataForgeRules = {
   '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

@@ -14,6 +14,7 @@ export const eslintTsDataForgeRules = {
   '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/types/rules/eslint-ts-data-forge-rules.mts

@@ -157,6 +157,21 @@ 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).
  *
@@ -229,6 +244,7 @@ export type EslintTsDataForgeRules = Readonly<{
   '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;
 }>;