eslint-config-typed 2.2.0 → 2.3.0

package/src/plugins/strict-dependencies/rules/resolve-import-path.test.mts

@@ -0,0 +1,258 @@
+import * as ts from 'typescript';
+import { resolveImportPath } from './resolve-import-path.mjs';
+
+// FIXME: https://github.com/knowledge-work/eslint-plugin-strict-dependencies/tree/v1.3.27 のテストをコピーしてきて
+// Codex でテスト・型チェックが通るようにさせただけなので、意味の無いテストになっていないかチェックして修正する
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+type TypeScriptModule = typeof import('typescript');
+
+const actualFunctions = vi.hoisted<{
+  findConfigFile?: TypeScriptModule['findConfigFile'];
+  getParsedCommandLineOfConfigFile?: TypeScriptModule['getParsedCommandLineOfConfigFile'];
+}>(() => ({
+  findConfigFile: undefined,
+  getParsedCommandLineOfConfigFile: undefined,
+}));
+
+vi.mock('typescript', async () => {
+  const actual = await vi.importActual<TypeScriptModule>('typescript');
+  // eslint-disable-next-line functional/immutable-data
+  actualFunctions.findConfigFile = actual.findConfigFile;
+  // eslint-disable-next-line functional/immutable-data
+  actualFunctions.getParsedCommandLineOfConfigFile =
+    actual.getParsedCommandLineOfConfigFile;
+  return {
+    ...actual,
+    findConfigFile: vi.fn(actual.findConfigFile),
+    getParsedCommandLineOfConfigFile: vi.fn(
+      actual.getParsedCommandLineOfConfigFile,
+    ),
+  };
+});
+
+const mockFindConfigFile = vi.mocked(ts.findConfigFile);
+const mockGetParsedCommandLine = vi.mocked(ts.getParsedCommandLineOfConfigFile);
+
+const compilerOptionsByFixture = {
+  'no-paths': {},
+  'paths-basic': {
+    paths: {
+      '@/components/': ['components/'],
+      '@/components': ['components'],
+      '@/components/*': ['components/*'],
+    },
+  },
+  'base-url-dot': {
+    baseUrl: '.',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'base-url-dot-slash': {
+    baseUrl: './',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'base-url-parent': {
+    baseUrl: '../',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'base-url-src': {
+    baseUrl: 'src',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'base-url-dot-src': {
+    baseUrl: './src',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'base-url-src-slash': {
+    baseUrl: 'src/',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'base-url-dot-src-slash': {
+    baseUrl: './src/',
+    paths: {
+      '@/components/': ['components/'],
+    },
+  },
+  'paths-multiple': {
+    paths: {
+      '@/components/*': ['src/components/*', 'src/alternativeComponents/*'],
+    },
+  },
+} as const satisfies Readonly<Record<string, ts.CompilerOptions>>;
+
+type FixtureName = keyof typeof compilerOptionsByFixture;
+
+const restoreActual = (): void => {
+  if (
+    actualFunctions.findConfigFile !== undefined &&
+    actualFunctions.getParsedCommandLineOfConfigFile !== undefined
+  ) {
+    mockFindConfigFile.mockImplementation(actualFunctions.findConfigFile);
+    mockGetParsedCommandLine.mockImplementation(
+      actualFunctions.getParsedCommandLineOfConfigFile,
+    );
+  }
+};
+
+const useFixture = (fixtureName: FixtureName | undefined): void => {
+  restoreActual();
+
+  if (fixtureName === undefined) {
+    return;
+  }
+
+  const compilerOptions = compilerOptionsByFixture[fixtureName];
+  mockFindConfigFile.mockImplementation(() => 'tsconfig.json');
+  mockGetParsedCommandLine.mockImplementation(() => ({
+    options: { ...compilerOptions },
+    fileNames: [],
+    errors: [],
+  }));
+};
+
+const aliasCases = [
+  {
+    label: '@/components/',
+    importPath: '@/components/aaa/bbb',
+    expected: 'components/aaa/bbb',
+  },
+  {
+    label: '@/components',
+    importPath: '@/components/aaa/bbb',
+    expected: 'components/aaa/bbb',
+  },
+  {
+    label: '@/components/*',
+    importPath: '@/components/aaa/bbb',
+    expected: 'components/aaa/bbb',
+  },
+] as const;
+
+const baseUrlCases = [
+  {
+    fixtureName: 'base-url-dot',
+    expected: 'components/aaa/bbb',
+  },
+  {
+    fixtureName: 'base-url-dot-slash',
+    expected: 'components/aaa/bbb',
+  },
+  {
+    fixtureName: 'base-url-parent',
+    expected: '../components/aaa/bbb',
+  },
+  {
+    fixtureName: 'base-url-src',
+    expected: 'src/components/aaa/bbb',
+  },
+  {
+    fixtureName: 'base-url-dot-src',
+    expected: 'src/components/aaa/bbb',
+  },
+  {
+    fixtureName: 'base-url-src-slash',
+    expected: 'src/components/aaa/bbb',
+  },
+  {
+    fixtureName: 'base-url-dot-src-slash',
+    expected: 'src/components/aaa/bbb',
+  },
+] as const satisfies readonly Readonly<{
+  fixtureName: FixtureName;
+  expected: string;
+}>[];
+
+describe('resolveImportPath', () => {
+  test('should resolve relative path', () => {
+    expect(
+      resolveImportPath('../../components/ui/Text', 'src/pages/aaa/bbb.ts', {}),
+    ).toBe('src/components/ui/Text');
+  });
+
+  test('should not resolve relative path if relativeFilePath is empty', () => {
+    expect(resolveImportPath('../../components/ui/Text', undefined, {})).toBe(
+      '../../components/ui/Text',
+    );
+  });
+
+  test('should do nothing if tsconfig.json does not exist', () => {
+    useFixture(undefined);
+    expect(resolveImportPath('components/aaa/bbb', undefined, {})).toBe(
+      'components/aaa/bbb',
+    );
+  });
+
+  test('should do nothing if no paths setting', () => {
+    useFixture('no-paths');
+    expect(resolveImportPath('components/aaa/bbb', undefined, {})).toBe(
+      'components/aaa/bbb',
+    );
+    useFixture(undefined);
+  });
+
+  test.each(aliasCases)(
+    'alias $label',
+    ({ importPath, expected }: Readonly<(typeof aliasCases)[number]>) => {
+      useFixture('paths-basic');
+      expect(resolveImportPath('components/aaa/bbb', undefined, {})).toBe(
+        'components/aaa/bbb',
+      );
+      expect(resolveImportPath(importPath, undefined, {})).toBe(expected);
+      useFixture(undefined);
+    },
+  );
+
+  test.each(baseUrlCases)(
+    'baseUrl $fixtureName',
+    ({ fixtureName, expected }: Readonly<(typeof baseUrlCases)[number]>) => {
+      useFixture(fixtureName);
+      expect(resolveImportPath('components/aaa/bbb', undefined, {})).toBe(
+        'components/aaa/bbb',
+      );
+      expect(resolveImportPath('@/components/aaa/bbb', undefined, {})).toBe(
+        expected,
+      );
+      useFixture(undefined);
+    },
+  );
+
+  test('should resolve path alias with specified index in pathIndexMap', () => {
+    useFixture('paths-multiple');
+    expect(
+      resolveImportPath('@/components/aaa/bbb', undefined, {
+        '@/components/*': 1,
+      }),
+    ).toBe('src/alternativeComponents/aaa/bbb');
+    useFixture(undefined);
+  });
+
+  test('should resolve path alias with default index when specified index does not exist', () => {
+    useFixture('paths-multiple');
+    expect(
+      resolveImportPath('@/components/aaa/bbb', undefined, {
+        '@/components/*': 5,
+      }),
+    ).toBe('src/components/aaa/bbb');
+    useFixture(undefined);
+  });
+
+  test('should resolve path alias with default index when pathIndexMap is empty', () => {
+    useFixture('paths-multiple');
+    expect(resolveImportPath('@/components/aaa/bbb', undefined, {})).toBe(
+      'src/components/aaa/bbb',
+    );
+    useFixture(undefined);
+  });
+});

package/src/plugins/strict-dependencies/rules/rules.mts

@@ -0,0 +1,6 @@
+import { type ESLintPlugin } from '../../../types/index.mjs';
+import { strictDependenciesRule } from './strict-dependencies.mjs';
+
+export const strictDependenciesRules = {
+  'strict-dependencies': strictDependenciesRule,
+} as const satisfies ESLintPlugin['rules'];

package/src/plugins/strict-dependencies/rules/strict-dependencies.mts

@@ -0,0 +1,201 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import isGlob from 'is-glob';
+import mm from 'micromatch';
+import * as path from 'node:path';
+import { Arr, castDeepMutable, hasKey, isNotUndefined } from 'ts-data-forge';
+import { resolveImportPath } from './resolve-import-path.mjs';
+
+// Forked from https://github.com/knowledge-work/eslint-plugin-strict-dependencies/blob/v1.3.27/strict-dependencies/index.js
+
+// Fork 時の変更点メモ
+// - normalize は path.normalize に変更（厳密には挙動が異なるが、この eslint ルールの用途的には問題ないはず）
+// - MessageId を使ってレポートするように変更（context.report に 2引数渡していた形式を object を渡すように変更）
+
+type RuleOptions = readonly [Dependencies] | readonly [Dependencies, Options];
+
+type Dependencies = readonly Readonly<{
+  module: string;
+  allowReferenceFrom: readonly string[];
+  allowSameModule?: boolean;
+  targetMembers?: readonly string[];
+  excludeTypeImportChecks?: boolean;
+}>[];
+
+type Options = Readonly<{
+  resolveRelativeImport?: boolean;
+  pathIndexMap?: ReadonlyRecord<string, number>;
+}>;
+
+type MessageId = 'forbidden-import-specifier' | 'forbidden-import';
+
+export const strictDependenciesRule: TSESLint.RuleModule<
+  MessageId,
+  RuleOptions
+> = {
+  meta: {
+    type: 'suggestion',
+    messages: {
+      'forbidden-import-specifier':
+        "import specifier '{{specifiers}}' is not allowed from {{from}}.",
+      'forbidden-import':
+        "import '{{importPath}}' is not allowed from {{from}}.",
+    },
+    schema: [
+      {
+        type: 'array',
+        items: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['module', 'allowReferenceFrom'],
+          properties: {
+            module: {
+              type: 'string',
+            },
+            allowReferenceFrom: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+            },
+            allowSameModule: {
+              type: 'boolean',
+            },
+            targetMembers: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+            },
+            excludeTypeImportChecks: {
+              type: 'boolean',
+            },
+          },
+        },
+      },
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          resolveRelativeImport: {
+            type: 'boolean',
+          },
+          pathIndexMap: {
+            type: 'object',
+            additionalProperties: {
+              type: 'number',
+            },
+          },
+        },
+      },
+    ],
+  },
+
+  create: (context) => {
+    const ruleOptions: RuleOptions = context.options;
+
+    const dependencies: Dependencies = ruleOptions[0];
+
+    const options: Options = Arr.isArrayAtLeastLength(ruleOptions, 2)
+      ? ruleOptions[1]
+      : {};
+
+    const resolveRelativeImport = options.resolveRelativeImport;
+    const pathIndexMap = options.pathIndexMap ?? {};
+
+    return {
+      ImportDeclaration: (node: DeepReadonly<TSESTree.ImportDeclaration>) => {
+        const fileFullPath = context.filename;
+        const relativeFilePath = path.normalize(
+          path.relative(process.cwd(), fileFullPath),
+        );
+        const importPath = resolveImportPath(
+          node.source.value,
+          resolveRelativeImport === true ? relativeFilePath : undefined,
+          pathIndexMap,
+        );
+
+        const importedModules: readonly string[] = (
+          node.specifiers satisfies DeepReadonly<
+            (
+              | TSESTree.ImportDefaultSpecifier
+              | TSESTree.ImportNamespaceSpecifier
+              | TSESTree.ImportSpecifier
+            )[]
+          >
+        )
+          .filter((spec) => hasKey(spec, 'imported')) // NOTE: ImportSpecifierの場合はimportedが存在する
+          .map((spec: DeepReadonly<TSESTree.ImportSpecifier>) =>
+            hasKey(spec.imported, 'name') ? spec.imported.name : undefined,
+          )
+          .filter(isNotUndefined);
+
+        for (const dependency of dependencies) {
+          // そもそもmoduleがimportPathと一致していない場合は必ず報告しない
+          if (!isMatch(importPath, dependency.module)) continue;
+
+          /**
+           * 1. 参照元チェックをしてAllowであればそこで処理を終了する
+           * 2. targetMembersが指定されていれば、targetMembersと実際にimportしているモジュールを比較して含まれていればエラーレポートして処理を終了する
+           * 3. targetMembersが指定されていない場合は、エラー扱いなのでエラーレポートして処理を終了する
+           */
+          const isAllowedByPath =
+            // 参照元が許可されている
+            dependency.allowReferenceFrom.some((allowPath) =>
+              isMatch(relativeFilePath, allowPath),
+            ) || // または同一モジュール間の参照が許可されている場合
+            (dependency.allowSameModule === true &&
+              isMatch(relativeFilePath, dependency.module)) ||
+            // または明示的に対象外としたtype importである場合
+            // FIXME: importKind という key は node に存在しないため修正が必要
+            (dependency.excludeTypeImportChecks === true &&
+              node.importKind === 'type');
+
+          if (isAllowedByPath) continue;
+
+          if (dependency.targetMembers !== undefined) {
+            const commonImportedList = getCommonElements<string>(
+              dependency.targetMembers,
+              importedModules,
+            );
+            if (commonImportedList.length > 0) {
+              context.report({
+                node: castDeepMutable(node),
+                messageId: 'forbidden-import-specifier',
+                data: {
+                  specifiers: commonImportedList.join(', '),
+                  from: relativeFilePath,
+                },
+              });
+            }
+            continue;
+          }
+
+          context.report({
+            node: castDeepMutable(node),
+            messageId: 'forbidden-import',
+            data: {
+              importPath,
+              from: relativeFilePath,
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [[]],
+};
+
+/**
+ * pathのmatcher。
+ * eslintrcで設定できる値は以下のケースを扱う
+ * - globパターン指定
+ * - globパターン以外の場合 => 前方部分一致
+ */
+const isMatch = (str: string, pattern: string): boolean =>
+  isGlob(pattern) ? mm.isMatch(str, pattern) : str.startsWith(pattern);
+
+// importedされた値・型名もLintのターゲットに入っている場合の検出処理
+const getCommonElements = <T,>(
+  arrA: readonly T[],
+  arrB: readonly T[],
+): readonly T[] => arrA.filter((element) => arrB.includes(element));

package/src/plugins/strict-dependencies/rules/strict-dependencies.test.mts

@@ -0,0 +1,113 @@
+import parserModule from '@typescript-eslint/parser';
+import { TSESLint } from '@typescript-eslint/utils';
+import * as path from 'node:path';
+import { describe, expect, test } from 'vitest';
+import { strictDependenciesRule } from './strict-dependencies.mjs';
+
+// FIXME: https://github.com/knowledge-work/eslint-plugin-strict-dependencies/tree/v1.3.27 のテストをコピーしてきて
+// Codex でテスト・型チェックが通るようにさせただけなので、意味の無いテストになっていないかチェックして修正する
+
+type RuleOptions = Parameters<
+  (typeof strictDependenciesRule)['create']
+>[0]['options'];
+
+const pluginName = 'test-strict-dependencies';
+const ruleId = 'strict-dependencies';
+
+const fromRoot = (relativePath: string): string =>
+  path.join(process.cwd(), relativePath);
+
+const normalize = (value: string): string => path.normalize(value);
+
+const allowPagesOptions: RuleOptions = [
+  [
+    {
+      module: 'src/components/ui',
+      allowReferenceFrom: ['src/components/pages'],
+      allowSameModule: true,
+    },
+  ],
+] as const;
+
+const targetMembersOptions: RuleOptions = [
+  [
+    {
+      module: 'src/components/ui',
+      allowReferenceFrom: ['src/pages/**'],
+      targetMembers: ['Text'],
+    },
+  ],
+] as const;
+
+const runRule = (
+  code: string,
+  filename: string,
+  options: RuleOptions,
+): readonly TSESLint.Linter.LintMessage[] => {
+  const linter = new TSESLint.Linter();
+
+  const config: TSESLint.Linter.ConfigType = [
+    {
+      files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'],
+      languageOptions: {
+        parser: parserModule,
+        parserOptions: {
+          ecmaVersion: 2022,
+          sourceType: 'module',
+        },
+      },
+      plugins: {
+        [pluginName]: {
+          rules: {
+            [ruleId]: strictDependenciesRule,
+          },
+        },
+      },
+      rules: {
+        [`${pluginName}/${ruleId}`]: ['error', ...options],
+      },
+    },
+  ];
+
+  return linter.verify(code, config, filename);
+};
+
+describe('strictDependenciesRule', () => {
+  test('allows import from permitted module', () => {
+    const messages = runRule(
+      "import { Text } from 'src/components/ui/Text';",
+      fromRoot('src/components/pages/allowed.ts'),
+      allowPagesOptions,
+    );
+
+    expect(messages).toHaveLength(0);
+  });
+
+  test('reports forbidden import when module is not allowed', () => {
+    const messages = runRule(
+      "import { Text } from 'src/components/ui/Text';",
+      fromRoot('src/components/test/aaa.ts'),
+      allowPagesOptions,
+    );
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]?.messageId).toBe('forbidden-import');
+    expect(messages[0]?.message).toBe(
+      `import '${normalize('src/components/ui/Text')}' is not allowed from ${normalize('src/components/test/aaa.ts')}.`,
+    );
+  });
+
+  test('reports forbidden specifier when target member is restricted', () => {
+    const messages = runRule(
+      "import { Text, TextProps } from 'src/components/ui/Text';",
+      fromRoot('src/components/button.tsx'),
+      targetMembersOptions,
+    );
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]?.messageId).toBe('forbidden-import-specifier');
+    expect(messages[0]?.message).toBe(
+      `import specifier 'Text' is not allowed from ${normalize('src/components/button.tsx')}.`,
+    );
+  });
+});

package/src/plugins/total-functions/rules/index.mts

@@ -1,18 +1 @@
-export * from './common.mjs';
-export * from './fp-ts.mjs';
-export * from './no-enums.mjs';
-export * from './no-hidden-type-assertions.mjs';
-export * from './no-nested-fp-ts-effects.mjs';
-export * from './no-partial-array-reduce.mjs';
-export * from './no-partial-division.mjs';
-export * from './no-partial-string-normalize.mjs';
-export * from './no-partial-url-constructor.mjs';
-export * from './no-premature-fp-ts-effects.mjs';
-export * from './no-unsafe-enum-assignment.mjs';
-export * from './no-unsafe-mutable-readonly-assignment.mjs';
-export * from './no-unsafe-optional-property-assignment.mjs';
-export * from './no-unsafe-readonly-mutable-assignment.mjs';
-export * from './no-unsafe-type-assertion.mjs';
-export * from './require-strict-mode.mjs';
 export * from './rules.mjs';
-export * from './unsafe-assignment-rule.mjs';

package/src/plugins/tree-shakable/rules/index.mts

@@ -1,2 +1 @@
-export * from './import-star.mjs';
 export * from './rules.mjs';

package/src/rules/eslint-import-rules.mts

@@ -14,6 +14,9 @@ export const eslintImportsRules = {
     'error',
     {
       allow: [
+        '*/index.js',
+        '*/index.mjs',
+        '*/index.cjs',
         'rxjs/operators',
         'solid-js/web',
         '@testing-library/jest-dom/**',
@@ -28,8 +31,6 @@ export const eslintImportsRules = {
         '@fontsource/**',
         'resize-observer/lib/ResizeObserverEntry',
         'vitest/config',
-        '*/index.mjs',
-        '*/index.js',
         'zx/globals',
       ],
     },

package/src/rules/typescript-eslint-rules.mts

@@ -249,6 +249,7 @@ export const typescriptEslintRules = {
         {
           from: 'lib',
           name: [
+            'RegExp',
             'AnimationEvent',
             'ClipboardEvent',
             'CompositionEvent',

package/src/types/define-config.mts

@@ -1,4 +1,4 @@
-import { type FlatConfig } from './index.mjs';
+import { type FlatConfig } from './flat-config.mjs';
 
 export const defineConfig = <const TConfig extends readonly FlatConfig[]>(
   config: TConfig,