eslint-plugin-ts-data-forge 0.1.0

package/src/rules/no-unnecessary-type-guard.test.mts

@@ -0,0 +1,368 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { noUnnecessaryTypeGuard } from './no-unnecessary-type-guard.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('no-unnecessary-type-guard', () => {
+  tester.run('no-unnecessary-type-guard', noUnnecessaryTypeGuard, {
+    valid: [
+      {
+        name: 'isNotUndefined on a type that includes undefined',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNotUndefined(x);
+        `,
+      },
+      {
+        name: 'isNonNullish on a type that includes both null and undefined',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string | null | undefined;
+          const y = isNonNullish(x);
+        `,
+      },
+      {
+        name: 'isBoolean that actually narrows',
+        code: dedent`
+          import { isBoolean } from 'ts-data-forge';
+          declare const x: boolean | string;
+          const y = isBoolean(x);
+        `,
+      },
+      {
+        name: 'isNotBoolean that actually narrows',
+        code: dedent`
+          import { isNotBoolean } from 'ts-data-forge';
+          declare const x: boolean | string;
+          const y = isNotBoolean(x);
+        `,
+      },
+      {
+        name: 'isNonEmptyString on a plain string (real string/empty work)',
+        code: dedent`
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNonEmptyString(x);
+        `,
+      },
+      {
+        name: 'isNonEmptyString on a union that may be empty',
+        code: dedent`
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: 'a' | '';
+          const y = isNonEmptyString(x);
+        `,
+      },
+      {
+        name: 'generic type parameter is treated conservatively',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          const f = <T,>(x: T) => isNotUndefined(x);
+        `,
+      },
+      {
+        name: 'any is treated conservatively',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: any;
+          const y = isNonNullish(x);
+        `,
+      },
+      {
+        name: 'identifier not imported from ts-data-forge is ignored',
+        code: dedent`
+          const isNotUndefined = (u: unknown): boolean => u !== undefined;
+          declare const x: string;
+          const y = isNotUndefined(x);
+        `,
+      },
+      {
+        name: 'guard passed by reference (not called) is ignored',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const xs: readonly (string | undefined)[];
+          const ys = xs.filter(isNotUndefined);
+        `,
+      },
+      {
+        name: 'ignore option disables a specific guard',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const x: string;
+          const y = isNotUndefined(x);
+        `,
+        options: [{ ignore: ['isNotUndefined'] }],
+      },
+    ],
+    invalid: [
+      {
+        name: 'isNotUndefined on a type that cannot be undefined (always true)',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const x: string;
+          const y = isNotUndefined(x);
+        `,
+        output: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const x: string;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isBoolean on a value that is already boolean (always true)',
+        code: dedent`
+          import { isBoolean } from 'ts-data-forge';
+          declare const x: boolean;
+          const y = isBoolean(x);
+        `,
+        output: dedent`
+          import { isBoolean } from 'ts-data-forge';
+          declare const x: boolean;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isNotBoolean on a value that can never be boolean (always true)',
+        code: dedent`
+          import { isNotBoolean } from 'ts-data-forge';
+          declare const x: string | number;
+          const y = isNotBoolean(x);
+        `,
+        output: dedent`
+          import { isNotBoolean } from 'ts-data-forge';
+          declare const x: string | number;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isNonNullish on a non-nullable value (always true)',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string;
+          const y = isNonNullish(x);
+        `,
+        output: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isNullish on a value that is already null | undefined (always true)',
+        code: dedent`
+          import { isNullish } from 'ts-data-forge';
+          declare const x: null | undefined;
+          const y = isNullish(x);
+        `,
+        output: dedent`
+          import { isNullish } from 'ts-data-forge';
+          declare const x: null | undefined;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isNonEmptyString on a NonEmptyString value (always true)',
+        code: dedent`
+          import { type NonEmptyString } from 'ts-type-forge';
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: NonEmptyString;
+          const y = isNonEmptyString(x);
+        `,
+        output: dedent`
+          import { type NonEmptyString } from 'ts-type-forge';
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: NonEmptyString;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isNonEmptyString on a non-empty string literal union (always true)',
+        code: dedent`
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: 'a' | 'b';
+          const y = isNonEmptyString(x);
+        `,
+        output: dedent`
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: 'a' | 'b';
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isBoolean on a value that can never be boolean (always false)',
+        code: dedent`
+          import { isBoolean } from 'ts-data-forge';
+          declare const x: string;
+          const y = isBoolean(x);
+        `,
+        output: dedent`
+          import { isBoolean } from 'ts-data-forge';
+          declare const x: string;
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'isNotUndefined on an always-undefined value (always false)',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const x: undefined;
+          const y = isNotUndefined(x);
+        `,
+        output: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const x: undefined;
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'isNonNullish on an always-nullish value (always false)',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: null | undefined;
+          const y = isNonNullish(x);
+        `,
+        output: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: null | undefined;
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'isNonEmptyString on the empty string literal (always false)',
+        code: dedent`
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: '';
+          const y = isNonEmptyString(x);
+        `,
+        output: dedent`
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: '';
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'no autofix when the argument has side effects',
+        code: dedent`
+          import { isNotUndefined } from 'ts-data-forge';
+          declare const getValue: () => string;
+          const y = isNotUndefined(getValue());
+        `,
+        output: null,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isNonNullish that only removes undefined -> isNotUndefined',
+        code: dedent`
+          import { isNonNullish, isNotUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNonNullish(x);
+        `,
+        output: dedent`
+          import { isNonNullish, isNotUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNotUndefined(x);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+      {
+        name: 'replacement guard imported under an alias renames to the alias',
+        code: dedent`
+          import { isNonNullish, isNotUndefined as inu } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNonNullish(x);
+        `,
+        output: dedent`
+          import { isNonNullish, isNotUndefined as inu } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = inu(x);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+      {
+        name: 'isNonNullish that only removes null -> isNotNull (import inserted)',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isNonNullish(x);
+        `,
+        output: dedent`
+          import { isNotNull } from 'ts-data-forge';
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isNotNull(x);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+      {
+        name: 'isNullish that only matches undefined -> isUndefined',
+        code: dedent`
+          import { isNullish, isUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNullish(x);
+        `,
+        output: dedent`
+          import { isNullish, isUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isUndefined(x);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+      {
+        name: 'isNonEmptyString that only removes nullish -> isNonNullish',
+        code: dedent`
+          import { type NonEmptyString } from 'ts-type-forge';
+          import { isNonEmptyString, isNonNullish } from 'ts-data-forge';
+          declare const x: NonEmptyString | null | undefined;
+          const y = isNonEmptyString(x);
+        `,
+        output: dedent`
+          import { type NonEmptyString } from 'ts-type-forge';
+          import { isNonEmptyString, isNonNullish } from 'ts-data-forge';
+          declare const x: NonEmptyString | null | undefined;
+          const y = isNonNullish(x);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+      {
+        name: 'namespace import member call is replaced without import change',
+        code: dedent`
+          import * as tf from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = tf.isNonNullish(x);
+        `,
+        output: dedent`
+          import * as tf from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = tf.isNotUndefined(x);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+    ],
+  });
+});

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

@@ -0,0 +1,98 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { type DeepReadonly } from 'ts-type-forge';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useArrIsArray';
+
+export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useArrIsArray:
+        'Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const mut_nodesToFix: TSESTree.CallExpression[] = [];
+
+    return {
+      CallExpression: (node) => {
+        if (!isArrayIsArrayCall(node)) return;
+
+        mut_nodesToFix.push(node);
+      },
+      'Program:exit': () => {
+        // Check if Arr is already imported
+        const hasArrImport = getNamedImports(tsDataForgeImport).includes('Arr');
+
+        // Note: We add import only for the first node to avoid conflicts when
+        // multiple fixes try to insert at the same position. This means if the
+        // first node is disabled via eslint-disable comment, no import will be
+        // added.
+        for (const [index, node] of mut_nodesToFix.entries()) {
+          context.report({
+            node,
+            messageId: 'useArrIsArray',
+            fix: (fixer) => {
+              const callee = node.callee;
+
+              if (callee.type !== AST_NODE_TYPES.MemberExpression) return [];
+
+              const replacement = `Arr.isArray${sourceCode.getText(node).slice(sourceCode.getText(callee).length)}`;
+
+              // Add import only for the first node and only if not already imported
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;
+
+const isArrayIsArrayCall = (
+  node: DeepReadonly<TSESTree.CallExpression>,
+): boolean => {
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+
+  const { object, property } = node.callee;
+
+  if (object.type !== AST_NODE_TYPES.Identifier) return false;
+
+  if (object.name !== 'Array') return false;
+
+  if (property.type !== AST_NODE_TYPES.Identifier) return false;
+
+  if (property.name !== 'isArray') return false;
+
+  return true;
+};

package/src/rules/prefer-arr-is-array.test.mts

@@ -0,0 +1,62 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsArray } from './prefer-arr-is-array.mjs';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
+  valid: [
+    {
+      name: 'Already using Arr.isArray',
+      code: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Arr.isArray(value);
+      `,
+    },
+    {
+      name: 'Not Array.isArray call',
+      code: dedent`
+        const obj = { isArray: () => true };
+        const result = obj.isArray(value);
+      `,
+    },
+  ],
+  invalid: [
+    {
+      name: 'Replace Array.isArray with Arr.isArray',
+      code: dedent`
+        const result = Array.isArray(value);
+      `,
+      output: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Arr.isArray(value);
+      `,
+      errors: [{ messageId: 'useArrIsArray' }],
+    },
+    {
+      name: 'Replace Array.isArray with Arr.isArray when Arr is already imported',
+      code: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Array.isArray(value);
+      `,
+      output: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Arr.isArray(value);
+      `,
+      errors: [{ messageId: 'useArrIsArray' }],
+    },
+    {
+      name: 'Replace multiple Array.isArray calls',
+      code: dedent`
+        const result1 = Array.isArray(value1);
+        const result2 = Array.isArray(value2);
+      `,
+      output: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result1 = Arr.isArray(value1);
+        const result2 = Arr.isArray(value2);
+      `,
+      errors: [{ messageId: 'useArrIsArray' }, { messageId: 'useArrIsArray' }],
+    },
+  ],
+});

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

@@ -0,0 +1,143 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import { parseLengthComparison } from './ast-utils.mjs';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsBoundedLengthArray';
+
+export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length >= min && xs.length <= max` with `Arr.isBoundedLengthArray(xs, min, max)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsBoundedLengthArray:
+        'Replace `{{original}}` with `Arr.isBoundedLengthArray({{arrayName}}, {{min}}, {{max}})` 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.LogicalExpression;
+      arrayExpression: TSESTree.Expression;
+      minExpression: TSESTree.Expression;
+      maxExpression: TSESTree.Expression;
+    }[] = [];
+
+    return {
+      LogicalExpression: (node) => {
+        // Only `a && b` can encode a `min && max` length range.
+        if (node.operator !== '&&') return;
+
+        const left = parseLengthComparison(node.left, sourceCode);
+
+        const right = parseLengthComparison(node.right, sourceCode);
+
+        if (left === undefined || right === undefined) return;
+
+        // Need one lower bound and one upper bound on the same array.
+        if (left.kind === right.kind) return;
+
+        if (
+          sourceCode.getText(left.array) !== sourceCode.getText(right.array)
+        ) {
+          return;
+        }
+
+        const min = left.kind === 'min' ? left : right;
+
+        const max = left.kind === 'min' ? right : left;
+
+        const arrayExpression = min.array;
+
+        // Check if arrayExpression is actually an array type
+        if (services?.program !== undefined && services.program !== null) {
+          const checker = services.program.getTypeChecker();
+
+          const tsNode = services.esTreeNodeToTSNodeMap?.get(arrayExpression);
+
+          if (tsNode !== undefined) {
+            const type = checker.getTypeAtLocation(tsNode);
+
+            // Check if it's an array type or tuple type
+            const isArrayType =
+              checker.isArrayType(type) || checker.isTupleType(type);
+
+            if (!isArrayType) return;
+          } else {
+            return;
+          }
+        } else {
+          return;
+        }
+
+        mut_nodesToFix.push({
+          node,
+          arrayExpression,
+          minExpression: min.bound,
+          maxExpression: max.bound,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasArrImport = namedImports.includes('Arr');
+
+        for (const [
+          index,
+          { node, arrayExpression, minExpression, maxExpression },
+        ] of mut_nodesToFix.entries()) {
+          const arrayText = sourceCode.getText(arrayExpression);
+
+          const minText = sourceCode.getText(minExpression);
+
+          const maxText = sourceCode.getText(maxExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useIsBoundedLengthArray',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+              min: minText,
+              max: maxText,
+            },
+            fix: (fixer) => {
+              const replacement = `Arr.isBoundedLengthArray(${arrayText}, ${minText}, ${maxText})`;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;