eslint-plugin-ts-std-forge 0.1.11 → 0.1.12

package/src/rules/prefer-safe-number-parse-integer.mts

@@ -1,174 +1,8 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
-import * as ts from 'typescript';
-import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
+import { createPreferSafeParseInt } from 'eslint-rule-forge';
 import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'useSafeNumberParseInteger';
-
-/**
- * Returns `true` when every constituent of `type` is string-like, i.e. the
- * type is assignable to the `string` parameter of `SafeNumber.parseInteger`.
- * 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 `parseInt(x)` / `Number.parseInt(x, 10)` and replaces them with
- * `Result.unwrapOkOr(SafeNumber.parseInteger(x), Number.NaN)` (ts-std-forge).
- *
- * Only base 10 is rewritten: `SafeNumber.parseInteger` takes no radix, so a
- * call that passes another one means something the replacement cannot say.
- */
-export const preferSafeNumberParseInteger: TSESLint.RuleModule<
-  MessageIds,
-  Options
-> = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Replace `parseInt(x)` or `Number.parseInt(x, 10)` with `Result.unwrapOkOr(SafeNumber.parseInteger(x), Number.NaN)` from ts-std-forge.',
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      useSafeNumberParseInteger:
-        'Replace `{{original}}` with `Result.unwrapOkOr(SafeNumber.parseInteger({{argName}}), Number.NaN)` from ts-std-forge.',
-    },
-  },
-
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-
-    const program = sourceCode.ast;
-
-    const tsStdForgeImports = getImportDeclarations(
-      program,
-      TS_STD_FORGE_MODULE,
-    );
-
-    const mut_nodesToFix: {
-      node: TSESTree.CallExpression;
-      argExpression: TSESTree.Expression;
-    }[] = [];
-
-    return {
-      CallExpression: (node) => {
-        const callee = skipTypeWrappers(node.callee);
-
-        // 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 &&
-          isIdentifierNamed(callee.object, '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`,
-        // read through its type wrappers, which leave the value as it is.
-        if (args.length >= 2) {
-          const radix =
-            args[1] === undefined ? undefined : skipTypeWrappers(args[1]);
-
-          if (radix?.type !== AST_NODE_TYPES.Literal || radix.value !== 10) {
-            return;
-          }
-        }
-
-        // The argument must be a `string` at every layer of type wrappers:
-        // the value's own type is what `parseInt` sees at run time
-        // (`parseInt(1e21 as unknown as string)` is 1, the rewrite 1e21), and
-        // the type a wrapper states is what the fix, which keeps the wrapper,
-        // hands `SafeNumber.parseInteger(value: string)`. Without type
-        // information, skip.
-        if (!typeHoldsAtEveryLayer(sourceCode, firstArg, isStringType)) {
-          return;
-        }
-
-        mut_nodesToFix.push({ node, argExpression: firstArg });
-      },
-      'Program:exit': () => {
-        const namedImports = getNamedImports(tsStdForgeImports);
-
-        const missingImports = (['Result', 'SafeNumber'] as const).filter(
-          (name) => !namedImports.includes(name),
-        );
-
-        for (const [
-          index,
-          { node, argExpression },
-        ] of mut_nodesToFix.entries()) {
-          const argText = getArgumentText(sourceCode, argExpression);
-
-          context.report({
-            node,
-            messageId: 'useSafeNumberParseInteger',
-            data: {
-              original: sourceCode.getText(node),
-              argName: argText,
-            },
-            fix: (fixer) => {
-              const core = `Result.unwrapOkOr(SafeNumber.parseInteger(${argText}), Number.NaN)`;
-
-              const importFixes =
-                index === 0 && missingImports.length > 0
-                  ? buildNamedImportFix(
-                      fixer,
-                      program,
-                      TS_STD_FORGE_MODULE,
-                      missingImports,
-                    )
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, core)];
-            },
-          });
-        }
-      },
-    };
-  },
-  defaultOptions: [],
-} as const;
+export const preferSafeNumberParseInteger = createPreferSafeParseInt({
+  moduleName: TS_STD_FORGE_MODULE,
+  namespace: 'SafeNumber',
+  method: 'parseInteger',
+});

package/src/rules/prefer-safe-number-parse-integer.test.mts

@@ -34,6 +34,20 @@ describe('prefer-safe-number-parse-integer', () => {
           const n = parseInt(x as unknown as string & never, 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: [
       {
@@ -47,7 +61,7 @@ describe('prefer-safe-number-parse-integer', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+        errors: [{ messageId: 'useSafeParseInt' }],
       },
       {
         name: 'rewrites Number.parseInt(x, 10)',
@@ -60,7 +74,7 @@ describe('prefer-safe-number-parse-integer', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+        errors: [{ messageId: 'useSafeParseInt' }],
       },
     ],
   });
@@ -111,7 +125,7 @@ describe('prefer-safe-number-parse-integer through type wrappers', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+        errors: [{ messageId: 'useSafeParseInt' }],
       },
       {
         name: 'reads a radix of 10 through `satisfies` and keeps `satisfies` on the argument',
@@ -124,7 +138,7 @@ describe('prefer-safe-number-parse-integer through type wrappers', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parseInteger(s satisfies string), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+        errors: [{ messageId: 'useSafeParseInt' }],
       },
       {
         name: 'reads the callee through `as` and `!`',
@@ -140,8 +154,8 @@ describe('prefer-safe-number-parse-integer through type wrappers', () => {
           const b = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
         `,
         errors: [
-          { messageId: 'useSafeNumberParseInteger' },
-          { messageId: 'useSafeNumberParseInteger' },
+          { messageId: 'useSafeParseInt' },
+          { messageId: 'useSafeParseInt' },
         ],
       },
       {
@@ -155,7 +169,7 @@ describe('prefer-safe-number-parse-integer through type wrappers', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parseInteger(s! as string), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+        errors: [{ messageId: 'useSafeParseInt' }],
       },
     ],
   });
@@ -178,7 +192,7 @@ describe('prefer-safe-number-parse-integer with parenthesized operands', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parseInteger((a, s)), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+        errors: [{ messageId: 'useSafeParseInt' }],
       },
     ],
   });

package/src/rules/prefer-safe-number-parse.mts

@@ -1,171 +1,14 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
-import * as ts from 'typescript';
-import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
+import { createPreferSafeParseFloat } from 'eslint-rule-forge';
 import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'useSafeNumberParse';
-
 /**
- * Returns `true` when every constituent of `type` is string-like, i.e. the
- * type is assignable to the `string` parameter of `SafeNumber.parse`. 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(SafeNumber.parse(x), Number.NaN)` (ts-std-forge).
- *
- * `Number(x)` is only flagged when x is purely a string type to avoid false
- * positives for `Number(someBoolean)` or `Number(someNumber)` uses.
- *
  * The ts-data-forge rule of the same shape names `Num.safeParseFloat`, which
  * has delegated to `SafeNumber.parse` since the D-49 inversion and wraps the
  * result in a `FiniteNumber` brand. This one names the implementation, for
  * callers who do not want the brand or the extra dependency.
  */
-export const preferSafeNumberParse: 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(SafeNumber.parse(x), Number.NaN)` from ts-std-forge.',
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      useSafeNumberParse:
-        'Replace `{{original}}` with `Result.unwrapOkOr(SafeNumber.parse({{argName}}), Number.NaN)` from ts-std-forge.',
-    },
-  },
-
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-
-    const program = sourceCode.ast;
-
-    const tsStdForgeImports = getImportDeclarations(
-      program,
-      TS_STD_FORGE_MODULE,
-    );
-
-    const mut_nodesToFix: {
-      node: TSESTree.CallExpression;
-      argExpression: TSESTree.Expression;
-    }[] = [];
-
-    return {
-      CallExpression: (node) => {
-        const callee = skipTypeWrappers(node.callee);
-
-        // 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 &&
-          isIdentifierNamed(callee.object, '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` at every layer of type
-        // wrappers: the value's own type is what `Number` sees at run time
-        // (`Number(true as unknown as string)` is 1, the rewrite NaN), and the
-        // type a wrapper states is what the fix, which keeps the wrapper,
-        // hands `SafeNumber.parse(value: string)`. Without type information,
-        // skip.
-        if (!typeHoldsAtEveryLayer(sourceCode, firstArg, isStringType)) {
-          return;
-        }
-
-        mut_nodesToFix.push({ node, argExpression: firstArg });
-      },
-      'Program:exit': () => {
-        const namedImports = getNamedImports(tsStdForgeImports);
-
-        const missingImports = (['Result', 'SafeNumber'] as const).filter(
-          (name) => !namedImports.includes(name),
-        );
-
-        for (const [
-          index,
-          { node, argExpression },
-        ] of mut_nodesToFix.entries()) {
-          const argText = getArgumentText(sourceCode, argExpression);
-
-          context.report({
-            node,
-            messageId: 'useSafeNumberParse',
-            data: {
-              original: sourceCode.getText(node),
-              argName: argText,
-            },
-            fix: (fixer) => {
-              const core = `Result.unwrapOkOr(SafeNumber.parse(${argText}), Number.NaN)`;
-
-              const importFixes =
-                index === 0 && missingImports.length > 0
-                  ? buildNamedImportFix(
-                      fixer,
-                      program,
-                      TS_STD_FORGE_MODULE,
-                      missingImports,
-                    )
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, core)];
-            },
-          });
-        }
-      },
-    };
-  },
-  defaultOptions: [],
-} as const;
+export const preferSafeNumberParse = createPreferSafeParseFloat({
+  moduleName: TS_STD_FORGE_MODULE,
+  namespace: 'SafeNumber',
+  method: 'parse',
+});

package/src/rules/prefer-safe-number-parse.test.mts

@@ -34,6 +34,27 @@ describe('prefer-safe-number-parse', () => {
           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-safe-number-parse-integer)',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+      },
       {
         name: 'ignores a union that is not purely string',
         code: dedent`
@@ -61,7 +82,7 @@ describe('prefer-safe-number-parse', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
       {
         name: 'rewrites Number.parseFloat on a string',
@@ -74,7 +95,7 @@ describe('prefer-safe-number-parse', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
       {
         name: 'rewrites Number(x) when x is a string',
@@ -87,7 +108,7 @@ describe('prefer-safe-number-parse', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
       {
         name: 'adds only the missing import',
@@ -102,7 +123,7 @@ describe('prefer-safe-number-parse', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
     ],
   });
@@ -159,7 +180,7 @@ describe('prefer-safe-number-parse through type wrappers', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse(s satisfies string), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
       {
         name: 'reads the callee through `as` and `!`',
@@ -175,8 +196,8 @@ describe('prefer-safe-number-parse through type wrappers', () => {
           const b = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
         `,
         errors: [
-          { messageId: 'useSafeNumberParse' },
-          { messageId: 'useSafeNumberParse' },
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
         ],
       },
       {
@@ -190,7 +211,7 @@ describe('prefer-safe-number-parse through type wrappers', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse(s! as string), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
     ],
   });
@@ -213,7 +234,7 @@ describe('prefer-safe-number-parse with parenthesized operands', () => {
           declare const s: string;
           const n = Result.unwrapOkOr(SafeNumber.parse((a, s)), Number.NaN);
         `,
-        errors: [{ messageId: 'useSafeNumberParse' }],
+        errors: [{ messageId: 'useSafeParseFloat' }],
       },
     ],
   });

package/dist/rules/ast-utils.d.mts

@@ -1,18 +0,0 @@
-import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
-import type * as ts from 'typescript';
-/**
- * Whether `node`, read through its type wrappers, is the identifier `name`:
- * `Number`, `(Number as NumberConstructor)` and `Number!` are the same object.
- */
-export declare const isIdentifierNamed: (node: TSESTree.Node, name: string) => boolean;
-/**
- * Whether `holds` is true of the type of every layer of type wrappers around
- * `node` (see {@link typeWrapperLayers}), outermost to innermost; `false`
- * without type information. A widening cast (`s as string | number`) is the
- * author saying the value may be more than it is, and is respected; a
- * narrowing one (`s!`, `v as unknown as string`) cannot vouch for what the
- * value's own type does not, and the fix, which keeps the wrapper, has to
- * type-check at every layer too.
- */
-export declare const typeHoldsAtEveryLayer: (sourceCode: TSESLint.SourceCode, node: TSESTree.Node, holds: (type: ts.Type, typeChecker: ts.TypeChecker) => boolean) => boolean;
-//# sourceMappingURL=ast-utils.d.mts.map

package/dist/rules/ast-utils.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ast-utils.d.mts","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,SAEtB,QAAQ,CAAC,IAAI,QACb,MAAM,KACX,OAMF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,eAEpB,QAAQ,CAAC,UAAU,QAEzB,QAAQ,CAAC,IAAI,SAEZ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC,WAAW,KAAK,OAAO,KAC7D,OAgBF,CAAC"}

package/dist/rules/ast-utils.mjs

@@ -1,39 +0,0 @@
-import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
-import { skipTypeWrappers, typeWrapperLayers } from 'eslint-rule-forge';
-
-
-
-
-export const isIdentifierNamed = (
-
-node, name) => {
-    const unwrapped = skipTypeWrappers(node);
-    return (unwrapped.type === AST_NODE_TYPES.Identifier && unwrapped.name === name);
-};
-
-
-
-
-
-
-
-
-
-export const typeHoldsAtEveryLayer = (
-
-sourceCode, 
-
-node, 
-
-holds) => {
-    const services = sourceCode.parserServices;
-    const checker = services?.program?.getTypeChecker();
-    if (checker === undefined) {
-        return false;
-    }
-    return typeWrapperLayers(node).every((layer) => {
-        const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
-        return (tsNode !== undefined && holds(checker.getTypeAtLocation(tsNode), checker));
-    });
-};
-//# sourceMappingURL=ast-utils.mjs.map

package/dist/rules/ast-utils.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ast-utils.mjs","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAGf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGxE;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;AAC/B,8EAA8E;AAC9E,IAAmB,EACnB,IAAY,EACH,EAAE;IACX,MAAM,SAAS,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAEzC,OAAO,CACL,SAAS,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,CACxE,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;AACnC,8EAA8E;AAC9E,UAA+B;AAC/B,8EAA8E;AAC9E,IAAmB;AACnB,8EAA8E;AAC9E,KAA8D,EACrD,EAAE;IACX,MAAM,QAAQ,GAAG,UAAU,CAAC,cAAc,CAAC;IAE3C,MAAM,OAAO,GAAG,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IAEpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7C,MAAM,MAAM,GAAG,QAAQ,EAAE,qBAAqB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAE3D,OAAO,CACL,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAC1E,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

package/src/rules/ast-utils.mts

@@ -1,57 +0,0 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import { skipTypeWrappers, typeWrapperLayers } from 'eslint-rule-forge';
-import type * as ts from 'typescript';
-
-/**
- * Whether `node`, read through its type wrappers, is the identifier `name`:
- * `Number`, `(Number as NumberConstructor)` and `Number!` are the same object.
- */
-export const isIdentifierNamed = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-  name: string,
-): boolean => {
-  const unwrapped = skipTypeWrappers(node);
-
-  return (
-    unwrapped.type === AST_NODE_TYPES.Identifier && unwrapped.name === name
-  );
-};
-
-/**
- * Whether `holds` is true of the type of every layer of type wrappers around
- * `node` (see {@link typeWrapperLayers}), outermost to innermost; `false`
- * without type information. A widening cast (`s as string | number`) is the
- * author saying the value may be more than it is, and is respected; a
- * narrowing one (`s!`, `v as unknown as string`) cannot vouch for what the
- * value's own type does not, and the fix, which keeps the wrapper, has to
- * type-check at every layer too.
- */
-export const typeHoldsAtEveryLayer = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  holds: (type: ts.Type, typeChecker: ts.TypeChecker) => boolean,
-): boolean => {
-  const services = sourceCode.parserServices;
-
-  const checker = services?.program?.getTypeChecker();
-
-  if (checker === undefined) {
-    return false;
-  }
-
-  return typeWrapperLayers(node).every((layer) => {
-    const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
-
-    return (
-      tsNode !== undefined && holds(checker.getTypeAtLocation(tsNode), checker)
-    );
-  });
-};