eslint-config-typed 4.2.1 → 4.3.1

package/src/plugins/ts-data-forge/index.mts

@@ -0,0 +1 @@
+export * from './plugin.mjs';

package/src/plugins/ts-data-forge/plugin.mts

@@ -0,0 +1,6 @@
+import { type ESLintPlugin } from '../../types/index.mjs';
+import { tsDataForgeRules } from './rules/index.mjs';
+
+export const eslintPluginTsDataForge: ESLintPlugin = {
+  rules: tsDataForgeRules,
+} as const;

package/src/plugins/ts-data-forge/rules/branded-number-types.mts

@@ -0,0 +1,36 @@
+const brandedNumberTypes = [
+  'FiniteNumber',
+  'Int',
+  'Int16',
+  'Int32',
+  'NonNegativeFiniteNumber',
+  'NonNegativeInt16',
+  'NonNegativeInt32',
+  'NonZeroFiniteNumber',
+  'NonZeroInt',
+  'NonZeroInt16',
+  'NonZeroInt32',
+  'NonZeroSafeInt',
+  'NonZeroUint16',
+  'NonZeroUint32',
+  'PositiveFiniteNumber',
+  'PositiveInt',
+  'PositiveInt16',
+  'PositiveInt32',
+  'PositiveSafeInt',
+  'PositiveUint16',
+  'PositiveUint32',
+  'SafeInt',
+  'SafeUint',
+  'Uint',
+  'Uint16',
+  'Uint32',
+] as const;
+
+/**
+ * Branded number types from ts-data-forge and their corresponding as* functions
+ */
+export const brandedNumberTypeNameToFunctionName: ReadonlyMap<
+  string,
+  `as${string}`
+> = new Map(brandedNumberTypes.map((t) => [t, `as${t}`]));

package/src/plugins/ts-data-forge/rules/constants.mts

@@ -0,0 +1 @@
+export const TS_DATA_FORGE_MODULE = 'ts-data-forge';

package/src/plugins/ts-data-forge/rules/import-utils.mts

@@ -0,0 +1,56 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+export const getTsDataForgeImport = (
+  program: TSESTree.Program,
+): TSESTree.ImportDeclaration | undefined =>
+  program.body.find(
+    (node): node is TSESTree.ImportDeclaration =>
+      node.type === AST_NODE_TYPES.ImportDeclaration &&
+      node.source.value === TS_DATA_FORGE_MODULE,
+  );
+
+export const getNamedImports = (
+  node: DeepReadonly<TSESTree.ImportDeclaration> | undefined,
+): readonly string[] => {
+  if (node === undefined) return [];
+
+  return node.specifiers.flatMap((specifier) =>
+    specifier.type === AST_NODE_TYPES.ImportSpecifier
+      ? (() => {
+          const importedName =
+            specifier.imported.type === AST_NODE_TYPES.Identifier
+              ? specifier.imported.name
+              : specifier.imported.value;
+
+          return typeof importedName === 'string' ? [importedName] : [];
+        })()
+      : [],
+  );
+};
+
+export const buildImportFixes = (
+  fixer: TSESLint.RuleFixer,
+  program: TSESTree.Program,
+  _tsDataForgeImport: TSESTree.ImportDeclaration | undefined,
+  requiredNames: readonly string[],
+): readonly TSESLint.RuleFix[] => {
+  const specifierText = requiredNames.join(', ');
+
+  const importStatement = `import { ${specifierText} } from '${TS_DATA_FORGE_MODULE}';`;
+
+  const newLine = '\n';
+
+  const insertionText = `${importStatement}${newLine}`;
+
+  // Always insert at the beginning of the file
+  // (organize-imports will handle merging/deduplication)
+  return [fixer.insertTextBefore(program, insertionText)];
+};
+/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */

package/src/plugins/ts-data-forge/rules/index.mts

@@ -0,0 +1 @@
+export * from './rules.mjs';

package/src/plugins/ts-data-forge/rules/prefer-arr-is-array-at-least-length.mts

@@ -0,0 +1,140 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsArrayAtLeastLength';
+
+export const preferArrIsArrayAtLeastLength: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length >= n` with `Arr.isArrayAtLeastLength(xs, n)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsArrayAtLeastLength:
+        'Replace `{{original}}` with `Arr.isArrayAtLeastLength({{arrayName}}, {{length}})` 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.BinaryExpression;
+      arrayExpression: TSESTree.Expression;
+      lengthExpression: TSESTree.Expression;
+    }[] = [];
+
+    return {
+      BinaryExpression: (node) => {
+        // Check for `xs.length >= n` or `n <= xs.length`
+        if (node.operator !== '>=' && node.operator !== '<=') return;
+
+        // xs.length >= n  or  n <= xs.length
+        const isLengthOnLeft = node.operator === '>=';
+
+        const lengthSide = isLengthOnLeft ? node.left : node.right;
+
+        const valueSide = isLengthOnLeft ? node.right : node.left;
+
+        // Check if lengthSide is accessing .length
+        if (!isLengthAccess(lengthSide)) return;
+
+        // lengthSide is MemberExpression accessing .length
+        const arrayExpression = lengthSide.object;
+
+        // 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,
+          lengthExpression: valueSide,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasArrImport = namedImports.includes('Arr');
+
+        for (const [
+          index,
+          { node, arrayExpression, lengthExpression },
+        ] of mut_nodesToFix.entries()) {
+          const arrayText = sourceCode.getText(arrayExpression);
+
+          const lengthText = sourceCode.getText(lengthExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useIsArrayAtLeastLength',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+              length: lengthText,
+            },
+            fix: (fixer) => {
+              const replacement = `Arr.isArrayAtLeastLength(${arrayText}, ${lengthText})`;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+};
+
+const isLengthAccess = (
+  node: DeepReadonly<TSESTree.Expression>,
+): node is TSESTree.MemberExpression =>
+  node.type === AST_NODE_TYPES.MemberExpression &&
+  node.property.type === AST_NODE_TYPES.Identifier &&
+  node.property.name === 'length';

package/src/plugins/ts-data-forge/rules/prefer-arr-is-array-at-least-length.test.mts

@@ -0,0 +1,175 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsArrayAtLeastLength } from './prefer-arr-is-array-at-least-length.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-arr-is-array-at-least-length', () => {
+  tester.run(
+    'prefer-arr-is-array-at-least-length',
+    preferArrIsArrayAtLeastLength,
+    {
+      valid: [
+        {
+          name: 'ignores non-array types',
+          code: dedent`
+            const str = "hello";
+            const ok = str.length >= 5;
+          `,
+        },
+        {
+          name: 'ignores < comparisons',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length < 5;
+          `,
+        },
+        {
+          name: 'ignores > comparisons',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length > 0;
+          `,
+        },
+        {
+          name: 'ignores === comparisons',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length === 3;
+          `,
+        },
+      ],
+      invalid: [
+        {
+          name: 'replaces xs.length >= n with Arr.isArrayAtLeastLength',
+          code: dedent`
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = xs.length >= 3;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = Arr.isArrayAtLeastLength(xs, 3);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+        {
+          name: 'replaces n <= xs.length with Arr.isArrayAtLeastLength',
+          code: dedent`
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = 3 <= xs.length;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = Arr.isArrayAtLeastLength(xs, 3);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+        {
+          name: 'works with no type annotation',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ok = Arr.isArrayAtLeastLength(xs, 1);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+        {
+          name: 'works with const assertion',
+          code: dedent`
+            const xs = [1, 2, 3] as const;
+            const ok = xs.length >= 2;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3] as const;
+            const ok = Arr.isArrayAtLeastLength(xs, 2);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+        {
+          name: 'works with variable length',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const n = 2;
+            const ok = xs.length >= n;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const n = 2;
+            const ok = Arr.isArrayAtLeastLength(xs, n);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+        {
+          name: 'keeps existing Arr import',
+          code: dedent`
+            import { Arr } from 'ts-data-forge';
+
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+
+            const xs = [1, 2, 3];
+            const ok = Arr.isArrayAtLeastLength(xs, 1);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+        {
+          name: 'replaces multiple checks',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = xs.length >= 2;
+            const ok2 = ys.length >= 1;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isArrayAtLeastLength(xs, 2);
+            const ok2 = Arr.isArrayAtLeastLength(ys, 1);
+          `,
+          errors: [
+            { messageId: 'useIsArrayAtLeastLength' },
+            { messageId: 'useIsArrayAtLeastLength' },
+          ],
+        },
+        {
+          name: 'works with >= 0 (checking non-empty)',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ok = Arr.isArrayAtLeastLength(xs, 1);
+          `,
+          errors: [{ messageId: 'useIsArrayAtLeastLength' }],
+        },
+      ],
+    },
+  );
+}, 20000);

package/src/plugins/ts-data-forge/rules/prefer-arr-is-array-of-length.mts

@@ -0,0 +1,144 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsArrayOfLength';
+
+export const preferArrIsArrayOfLength: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length === n` with `Arr.isArrayOfLength(xs, n)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsArrayOfLength:
+        'Replace `{{original}}` with `Arr.isArrayOfLength({{arrayName}}, {{length}})` 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.BinaryExpression;
+      arrayExpression: TSESTree.Expression;
+      lengthExpression: TSESTree.Expression;
+      isNegated: boolean;
+    }[] = [];
+
+    return {
+      BinaryExpression: (node) => {
+        // Check for `xs.length === n` or `n === xs.length` or `xs.length !== n`
+        if (node.operator !== '===' && node.operator !== '!==') return;
+
+        const isNegated = node.operator === '!==';
+
+        const isLengthOnLeft = isLengthAccess(node.left);
+
+        const lengthSide = isLengthOnLeft ? node.left : node.right;
+
+        const valueSide = isLengthOnLeft ? node.right : node.left;
+
+        if (!isLengthAccess(lengthSide)) return;
+
+        // lengthSide is MemberExpression accessing .length
+        const arrayExpression = lengthSide.object;
+
+        // 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,
+          lengthExpression: valueSide,
+          isNegated,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasArrImport = namedImports.includes('Arr');
+
+        for (const [
+          index,
+          { node, arrayExpression, lengthExpression, isNegated },
+        ] of mut_nodesToFix.entries()) {
+          const arrayText = sourceCode.getText(arrayExpression);
+
+          const lengthText = sourceCode.getText(lengthExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useIsArrayOfLength',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+              length: lengthText,
+            },
+            fix: (fixer) => {
+              const baseCall = `Arr.isArrayOfLength(${arrayText}, ${lengthText})`;
+
+              const replacement = isNegated ? `!${baseCall}` : baseCall;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+};
+
+const isLengthAccess = (
+  node: DeepReadonly<TSESTree.Expression>,
+): node is TSESTree.MemberExpression =>
+  node.type === AST_NODE_TYPES.MemberExpression &&
+  node.property.type === AST_NODE_TYPES.Identifier &&
+  node.property.name === 'length';