eslint-plugin-ts-data-forge 0.5.4 → 0.6.0

package/src/rules/no-side-effect-import.test.mts

@@ -0,0 +1,85 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { noSideEffectImport } from './no-side-effect-import.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+  },
+});
+
+describe('no-side-effect-import', () => {
+  tester.run('no-side-effect-import', noSideEffectImport, {
+    valid: [
+      {
+        name: 'accepts a named import',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const first = Arr.isNonEmpty(xs) ? xs[0] : undefined;
+        `,
+      },
+      {
+        name: 'accepts a namespace import',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+
+          const sum = tdf.Arr.sum(xs);
+        `,
+      },
+      {
+        name: 'leaves other side-effect imports alone',
+        code: dedent`
+          import './polyfills.mjs';
+          import 'ts-data-forge-extras';
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'removes a side-effect-only import',
+        code: dedent`
+          import 'ts-data-forge';
+        `,
+        output: '',
+        errors: [{ messageId: 'removeSideEffectImport' }],
+      },
+      {
+        name: 'removes it along with its line',
+        code: dedent`
+          import 'ts-data-forge';
+          import { Arr } from 'ts-data-forge';
+
+          const sum = Arr.sum(xs);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const sum = Arr.sum(xs);
+        `,
+        errors: [{ messageId: 'removeSideEffectImport' }],
+      },
+      {
+        name: 'removes every side-effect-only import',
+        code: dedent`
+          import 'ts-data-forge';
+          import './polyfills.mjs';
+          import 'ts-data-forge';
+
+          const answer = 42;
+        `,
+        output: dedent`
+          import './polyfills.mjs';
+
+          const answer = 42;
+        `,
+        errors: [
+          { messageId: 'removeSideEffectImport' },
+          { messageId: 'removeSideEffectImport' },
+        ],
+      },
+    ],
+  });
+});

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

@@ -266,12 +266,19 @@ const dropBoundsFix = (
   rewrite: CastRewrite,
 ): readonly TSESLint.RuleFix[] =>
   rewrite.bounds.flatMap((_, index) => {
-    if (rewrite.keep.includes(index)) return [];
-
+    // 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 next = node.arguments[index + 1];
 
+    if (rewrite.keep.includes(index)) return [];
+
     return dropped === undefined || next === undefined
       ? []
       : [fixer.removeRange([dropped.range[0], next.range[0]])];

package/src/rules/prefer-range-for-loop.mts

@@ -110,7 +110,7 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
             // Only support positive integer steps
             if (typeof stepNum === 'number' && stepNum > 0) {
-              mut_step = stepNum === 1 ? undefined : String(stepNum);
+              mut_step = stepNum === 1 ? undefined : stepNum.toString();
             } else {
               return;
             }

package/src/rules/rules.mts

@@ -1,4 +1,5 @@
 import { type ESLintPlugin } from '../types.mjs';
+import { noSideEffectImport } from './no-side-effect-import.mjs';
 import { noUnnecessaryTypeGuard } from './no-unnecessary-type-guard.mjs';
 import { preferArrIsArray } from './prefer-arr-is-array.mjs';
 import { preferArrSum } from './prefer-arr-sum.mjs';
@@ -26,6 +27,7 @@ export const tsDataForgeRules = {
   'prefer-is-record-and-has-key': preferIsRecordAndHasKey,
   'prefer-num-safe-parse-int': preferNumSafeParseInt,
   'prefer-num-safe-parse-float': preferNumSafeParseFloat,
+  'no-side-effect-import': noSideEffectImport,
   'no-unnecessary-type-guard': noUnnecessaryTypeGuard,
   'prefer-comparison-over-nullish-guard': preferComparisonOverNullishGuard,
   'prefer-obj-over-entries-round-trip': preferObjOverEntriesRoundTrip,