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

package/src/rules/prefer-arr-generate.test.mts

@@ -884,6 +884,235 @@ describe('prefer-arr-generate', () => {
           { messageId: 'useArrGenerate' },
         ],
       },
+      {
+        name: 'only suggests when a comment between the receiver and `.flatMap` would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs
+            // keep only the positives
+            .flatMap((x) => (x > 0 ? [x] : []));
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (x > 0) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a comment after `flatMap(` would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap(
+            // keep only the positives
+            (x) => (x > 0 ? [x] : []),
+          );
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (x > 0) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a comment after the callback, before `)` would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap(
+            (x) => (x > 0 ? [x] : []),
+            // keep only the positives
+          );
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (x > 0) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'keeps the fix automatic when the comment is inside the carried type argument',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap</* positives */ number>((x) => (x > 0 ? [x] : []));
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.generate</* positives */ number>(function* () {
+            for (const x of xs) {
+              if (x > 0) {
+                yield x;
+              }
+            }
+          });
+        `,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
+      {
+        name: 'keeps the fix automatic when the comment is inside the receiver or the parameter',
+        code: dedent`
+          declare const f: (a: readonly { a: number }[]) => readonly { a: number }[];
+          declare const xs: readonly { a: number }[];
+          const ys = f(/* all */ xs).flatMap(({ a /* the value */ }) => (a > 0 ? [a] : []));
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const f: (a: readonly { a: number }[]) => readonly { a: number }[];
+          declare const xs: readonly { a: number }[];
+          const ys = Arr.generate(function* () {
+            for (const { a /* the value */ } of f(/* all */ xs)) {
+              if (a > 0) {
+                yield a;
+              }
+            }
+          });
+        `,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
+      {
+        name: 'only suggests when a comment in a negated test would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap((x) => (x > 0 && /* small */ x < 9 ? [] : [x]));
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (!(x > 0) || !(x < 9)) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a comment before `.flatMap` would be lost, even if a kept comment starts with the same text',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs // TODO
+            .flatMap((x) => {
+              // TODO: check this
+              const y = x + 1;
+              return y > 0 ? [y] : [];
+            });
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      // TODO: check this
+                      const y = x + 1;
+                      if (y > 0) {
+                        yield y;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'keeps the fix automatic for a multi-line comment in the prelude',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap((x) => {
+            /*
+             * Odd ones only.
+             */
+            const y = x;
+            return y % 2 === 1 ? [y] : [];
+          });
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.generate(function* () {
+            for (const x of xs) {
+              /*
+               * Odd ones only.
+               */
+              const y = x;
+              if (y % 2 === 1) {
+                yield y;
+              }
+            }
+          });
+        `,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
       {
         name: 'only suggests when a comment would be lost',
         code: dedent`

package/src/rules/prefer-arr-is-fixed-length-array.mts

@@ -79,8 +79,8 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          // The literal or constant itself: a wrapper such as `as number`
-          // would only widen the length the guard narrows to.
+          // The literal or constant itself: a wrapper such as `as number` would
+          // only widen the length the guard narrows to.
           lengthExpression: skipTypeWrappers(valueSide),
           isNegated,
         });

package/src/rules/prefer-arr-is-max-length-array.mts

@@ -85,8 +85,8 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          // The literal or constant itself: a wrapper such as `as number`
-          // would only widen the length the guard narrows to.
+          // The literal or constant itself: a wrapper such as `as number` would
+          // only widen the length the guard narrows to.
           lengthExpression: skipTypeWrappers(valueSide),
         });
       },

package/src/rules/prefer-arr-is-min-length-array.mts

@@ -85,8 +85,8 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          // The literal or constant itself: a wrapper such as `as number`
-          // would only widen the length the guard narrows to.
+          // The literal or constant itself: a wrapper such as `as number` would
+          // only widen the length the guard narrows to.
           lengthExpression: skipTypeWrappers(valueSide),
         });
       },

package/src/rules/prefer-arr-scan.mts

@@ -45,8 +45,8 @@ type AccumulationCandidate = Readonly<{
   call: TSESTree.CallExpression;
   /**
    * What the call is replaced with, after the name `Arr` is bound to
-   * (`scan(xs, f, init)`), or `undefined` when the rewrite could not be
-   * derived and the report carries no fix.
+   * (`scan(xs, f, init)`), or `undefined` when the rewrite could not be derived
+   * and the report carries no fix.
    */
   replacement: string | undefined;
 }>;
@@ -280,12 +280,12 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // `acc.at(-1)` is `T | undefined` only because `at` can go out of bounds,
       // which a seeded accumulator never does. So once the value `scan` carries
       // is known not to be nullish, a `?? fallback` guarding the read is dead
-      // and the fix takes it with the read — leaving it would hand the author an
-      // unnecessary condition that no rule can fix for them. Every layer of
-      // type wrappers is asked (see typeWrapperLayers): the value under an
-      // `as` / `!` is what `scan` carries at run time (`[init!]` may still
-      // hold `undefined`), and a wider type a wrapper states is the author
-      // saying it may be nullish.
+      // and the fix takes it with the read — leaving it would hand the author
+      // an unnecessary condition that no rule can fix for them. Every layer of
+      // type wrappers is asked (see typeWrapperLayers): the value under an `as`
+      // / `!` is what `scan` carries at run time (`[init!]` may still hold
+      // `undefined`), and a wider type a wrapper states is the author saying it
+      // may be nullish.
       const carriesNullish = [seed, element].some((node) =>
         typeWrapperLayers(node).some(isNullish),
       );

package/src/rules/prefer-arr-sum.mts

@@ -67,9 +67,9 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
         const reducer = node.arguments[0];
 
-        // The initial value and the operands of the body are read through
-        // type wrappers: `0 as number` is still 0, `(b satisfies number)` is
-        // still `b`. Types are asked of the values underneath too.
+        // The initial value and the operands of the body are read through type
+        // wrappers: `0 as number` is still 0, `(b satisfies number)` is still
+        // `b`. Types are asked of the values underneath too.
         const initialValue = skipTypeWrappers(node.arguments[1]);
 
         // Check initial value is 0

package/src/rules/prefer-arr-uniq.mts

@@ -55,8 +55,8 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
 
     const esTreeNodeToTSNodeMap = services?.esTreeNodeToTSNodeMap;
 
-    // Without type information the rule cannot tell an array of primitives
-    // from an array of objects, and would suggest code that does not compile.
+    // Without type information the rule cannot tell an array of primitives from
+    // an array of objects, and would suggest code that does not compile.
     if (checker === undefined || esTreeNodeToTSNodeMap === undefined) {
       return {};
     }

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

@@ -87,8 +87,8 @@ const asNegatedPositiveIntegerLiteral = (
 
 /**
  * Whether re-reading the expression is free of side effects (a plain variable
- * or a non-computed property chain, type wrappers aside). Required for
- * patterns that reference the receiver twice, such as
+ * or a non-computed property chain, type wrappers aside). Required for patterns
+ * that reference the receiver twice, such as
  * `xs.filter((_, i) => i < xs.length - 1)`.
  */
 const isSimpleReference = (wrapped: TSESTree.Node): boolean => {
@@ -213,8 +213,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
     const checker = parserServices.program.getTypeChecker();
 
     /**
-     * The in-scope way to reference the `Arr` namespace, the name the
-     * reference starts with, and the edits that bring it into scope: a value
+     * The in-scope way to reference the `Arr` namespace, the name the reference
+     * starts with, and the edits that bring it into scope: a value
      * import of `Arr` (possibly aliased), a namespace import member, or `Arr`
      * bound by {@link bindValueImports}, which adds it to an existing import or
      * drops `type` from one. `undefined` when none can: `import type { Arr }`
@@ -235,8 +235,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
     const arrRef = arrTarget?.ref ?? 'Arr';
 
     /**
-     * Deferred (non-concrete) types are reduced to their base constraint
-     * before checking; `any` / `unknown` are conservatively not array-like.
+     * Deferred (non-concrete) types are reduced to their base constraint before
+     * checking; `any` / `unknown` are conservatively not array-like.
      */
     const isArrayOrTupleType = (type: ts.Type): boolean => {
       if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
@@ -398,8 +398,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
 
     /**
      * Matches an index-only filter callback (`(_, i) => <comparison>`) and
-     * classifies the comparison. Both a leading index (`i >= 1`) and a
-     * trailing index (`1 <= i`) operand order are accepted.
+     * classifies the comparison. Both a leading index (`i >= 1`) and a trailing
+     * index (`1 <= i`) operand order are accepted.
      */
     const classifyFilterCallback = (
       callback: TSESTree.CallExpressionArgument,
@@ -471,10 +471,10 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         return undefined;
       }
 
-      // The element parameter must not participate in the comparison (only
-      // the index side and a receiver-independent bound are recognized, so
-      // reaching here with an element reference is impossible for literals,
-      // but `xs.length - N` needs a stable receiver).
+      // The element parameter must not participate in the comparison (only the
+      // index side and a receiver-independent bound are recognized, so reaching
+      // here with an element reference is impossible for literals, but
+      // `xs.length - N` needs a stable receiver).
       const n = asNonNegativeIntegerLiteral(other);
 
       if (n !== undefined) {
@@ -724,8 +724,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           return;
         }
 
-        // The receiver must be an array or tuple (not a string / typed array
-        // / other object that happens to share the method name).
+        // The receiver must be an array or tuple (not a string / typed array /
+        // other object that happens to share the method name).
         if (!holdsThroughWrappers(receiver, isArrayOrTupleType)) {
           return;
         }
@@ -798,8 +798,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
               return;
             }
 
-            // `xs.concat(item)` appends only when `item` can never be an
-            // array (otherwise `concat` would flatten it).
+            // `xs.concat(item)` appends only when `item` can never be an array
+            // (otherwise `concat` would flatten it).
             if (holdsThroughWrappers(arg, isDefinitelyNotArrayType)) {
               report(
                 node,
@@ -839,8 +839,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
               : [undefined, undefined, undefined];
 
         // `spread`, `item`, and `fn` are set together (all from the same
-        // tuple), so checking `spread` also guarantees the others are
-        // defined.
+        // tuple), so checking `spread` also guarantees the others are defined.
         if (spread === undefined) {
           return;
         }

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

@@ -288,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,
@@ -303,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];

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: