eslint-plugin-ts-data-forge 0.10.5 → 0.10.7

package/src/rules/prefer-canonical-array-slicing.test.mts

@@ -572,12 +572,20 @@ describe('prefer-canonical-array-slicing', () => {
           const ys = xs.slice(1);
           const zs = xs.slice(0, -1);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const ys = Arr.tail(xs);
-          const zs = Arr.butLast(xs);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const ys = Arr.tail(xs);
+            const zs = xs.slice(0, -1);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const ys = Arr.tail(xs);
+            const zs = Arr.butLast(xs);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -629,13 +637,22 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const b = xs.slice(0 satisfies number, -1 as number);
           const c = xs.toSpliced(2 satisfies number);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.tail(xs);
-          const b = Arr.butLast(xs);
-          const c = Arr.take(xs, 2);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.tail(xs);
+            const b = xs.slice(0 satisfies number, -1 as number);
+            const c = xs.toSpliced(2 satisfies number);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.tail(xs);
+            const b = Arr.butLast(xs);
+            const c = Arr.take(xs, 2);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -663,13 +680,22 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const ys = (xs satisfies readonly number[]).slice(1);
           const zs = [...xs!, v!];
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          declare const v: number | undefined;
-          const ys = Arr.tail(xs satisfies readonly number[]);
-          const zs = Arr.toPushed(xs!, v!);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            declare const v: number | undefined;
+            const ys = Arr.tail(xs satisfies readonly number[]);
+            const zs = [...xs!, v!];
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            declare const v: number | undefined;
+            const ys = Arr.tail(xs satisfies readonly number[]);
+            const zs = Arr.toPushed(xs!, v!);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -697,14 +723,24 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const c = xs.filter((_, i) => i < (xs.length satisfies number) - 2);
           const d = xs.toSpliced(0, xs!.length - 2);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.butLast(xs);
-          const b = Arr.butLast(xs);
-          const c = Arr.skipLast(xs, 2);
-          const d = Arr.takeLast(xs, 2);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs);
+            const b = xs.slice(0, (xs as readonly number[]).length - 1);
+            const c = xs.filter((_, i) => i < (xs.length satisfies number) - 2);
+            const d = xs.toSpliced(0, xs!.length - 2);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs);
+            const b = Arr.butLast(xs);
+            const c = Arr.skipLast(xs, 2);
+            const d = Arr.takeLast(xs, 2);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -719,12 +755,20 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const a = (xs satisfies readonly number[]).slice(0, xs.length - 1);
           const b = xs.toSpliced((xs.length as number), 0, 1);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.butLast(xs satisfies readonly number[]);
-          const b = Arr.toPushed(xs, 1);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs satisfies readonly number[]);
+            const b = xs.toSpliced((xs.length as number), 0, 1);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs satisfies readonly number[]);
+            const b = Arr.toPushed(xs, 1);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -733,3 +777,58 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
     ],
   });
 });
+
+describe('prefer-canonical-array-slicing and the import it adds', () => {
+  tester.run('prefer-canonical-array-slicing', preferCanonicalArraySlicing, {
+    valid: [],
+    invalid: [
+      {
+        name: 'writes through a namespace import, which needs no edit',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: dedent`
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = tdf.Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'joins an existing named import from the module',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: dedent`
+          import { asInt, Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'no fix when an import type binds the name',
+        code: dedent`
+          import type { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: null,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'no fix where a local binding takes the name',
+        code: dedent`
+          declare const xs: readonly number[];
+          const f = (Arr: unknown) => xs.slice(1);
+        `,
+        output: null,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-canonical-length-cast.mts

@@ -218,6 +218,24 @@ const getCastName = (
     : undefined;
 };
 
+/**
+ * A non-negative integer literal's value, or `undefined` for anything else.
+ * Read through type wrappers: `1 as const` is still the bound `1`.
+ */
+const getLengthLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  wrapped: TSESTree.Node,
+): number | undefined => {
+  const node = skipTypeWrappers(wrapped);
+
+  return node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    Number.isSafeInteger(node.value) &&
+    node.value >= 0
+    ? node.value
+    : undefined;
+};
+
 /**
  * Whether the call is `cast(...bounds, array)` with every bound written as the
  * exact numeric literal the rewrite requires.
@@ -270,10 +288,10 @@ const matchesBounds = (
 /**
  * Removes the length arguments the rewrite drops. Each removal runs from the
  * first token after the delimiter before the dropped argument (the call's `(`
- * or the previous comma) up to the first token after the comma that follows
- * it. Parentheses the source put around the dropped argument, the comma,
- * whitespace and any comments in between go with it; parentheses around the
- * next argument stay. The ranges never overlap.
+ * or the previous comma) up to the first token after the comma that follows it.
+ * Parentheses the source put around the dropped argument, the comma, whitespace
+ * and any comments in between go with it; parentheses around the next argument
+ * stay. The ranges never overlap.
  */
 const dropBoundsFix = (
   fixer: TSESLint.RuleFixer,
@@ -285,13 +303,13 @@ const dropBoundsFix = (
   rewrite: CastRewrite,
 ): readonly TSESLint.RuleFix[] =>
   rewrite.bounds.flatMap((_, index) => {
-    // Read before the `includes` below, not after. The strict standard
-    // library types `includes` as `searchElement is T` — that is what lets a
-    // literal union narrow a wider value — but the predicate applies to the
-    // false branch too, and here `keep` is `readonly number[]` against a
-    // `number`, so `index` narrows to `never` past the guard and `index + 1`
-    // stops type-checking. A false `includes` means "not in this array", not
-    // "not of this type".
+    // Read before the `includes` below, not after. The strict standard library
+    // types `includes` as `searchElement is T` — that is what lets a literal
+    // union narrow a wider value — but the predicate applies to the false
+    // branch too, and here `keep` is `readonly number[]` against a `number`, so
+    // `index` narrows to `never` past the guard and `index + 1` stops
+    // type-checking. A false `includes` means "not in this array", not "not of
+    // this type".
     const dropped = node.arguments[index];
 
     const previous = node.arguments[index - 1];
@@ -319,21 +337,3 @@ const dropBoundsFix = (
       ? []
       : [fixer.removeRange([start.range[0], end.range[0]])];
   });
-
-/**
- * A non-negative integer literal's value, or `undefined` for anything else.
- * Read through type wrappers: `1 as const` is still the bound `1`.
- */
-const getLengthLiteral = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  wrapped: TSESTree.Node,
-): number | undefined => {
-  const node = skipTypeWrappers(wrapped);
-
-  return node.type === AST_NODE_TYPES.Literal &&
-    typeof node.value === 'number' &&
-    Number.isSafeInteger(node.value) &&
-    node.value >= 0
-    ? node.value
-    : undefined;
-};

package/src/rules/prefer-canonical-length-guard.mts

@@ -59,8 +59,8 @@ const MESSAGES = {
 } as const satisfies ReadonlyRecord<MessageIds, string>;
 
 /**
- * Length guards whose bound makes them redundant with a named degenerate
- * guard, keyed by guard name.
+ * Length guards whose bound makes them redundant with a named degenerate guard,
+ * keyed by guard name.
  *
  * Every entry stays inside its own family rather than crossing the
  * branded/structural divide: