@dword-design/eslint-plugin-import-alias 8.0.1 → 8.1.1

package/dist/rules/prefer-alias.d.ts

@@ -5,16 +5,21 @@ export interface BabelPluginModuleResolverOptions {
     cwd?: string;
     resolvePath?: (sourcePath: string, currentFile: string, options: Pick<BabelPluginModuleResolverOptions, 'alias' | 'cwd'>) => string;
 }
+interface AliasInfo {
+    path: string;
+    includePatterns: string[];
+    configDir: string;
+}
 export interface Options {
-    alias: Record<string, string>;
+    alias: Record<string, AliasInfo[]>;
     aliasForSubpaths: boolean;
     shouldReadTsConfig: boolean;
     shouldReadBabelConfig: boolean;
     resolvePath: (sourcePath: string, currentFile: string, options: Pick<BabelPluginModuleResolverOptions, 'alias' | 'cwd'>) => string;
-    cwd: string;
 }
 type BabelOptions = Exclude<Parameters<typeof loadOptions>[0], undefined>;
-export type OptionsInput = Partial<Options> & {
+export type OptionsInput = Omit<Partial<Options>, 'alias'> & {
+    alias?: Record<string, string>;
     babelOptions?: BabelOptions;
 };
 declare const _default: ESLintUtils.RuleModule<"parentImport" | "subpathImport", [OptionsInput], unknown, ESLintUtils.RuleListener>;

package/dist/rules/prefer-alias.js

@@ -3,16 +3,14 @@ import { loadOptions } from "@babel/core";
 import defaults from "@dword-design/defaults";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { resolvePath as defaultResolvePath } from "babel-plugin-module-resolver";
-import { omit, orderBy, pick } from "lodash-es";
+import { mapValues, omit, orderBy, pick } from "lodash-es";
+import micromatch from "micromatch";
 const ts = await import("typescript").then(module => module.default).catch(() => null);
-const loadTsConfigPaths = (currentFile, cwd) => {
-  if (!ts) {
-    return {};
-  }
-  const configPath = ts.findConfigFile(pathLib.dirname(currentFile), ts.sys.fileExists, "tsconfig.json");
-  if (!configPath) {
+const loadTsConfigPathsFromFile = (configPath, cwd, visitedConfigs = /* @__PURE__ */new Set()) => {
+  if (!ts || visitedConfigs.has(configPath)) {
     return {};
   }
+  visitedConfigs.add(configPath);
   const configText = ts.sys.readFile(configPath);
   if (!configText) {
     return {};
@@ -24,27 +22,70 @@ const loadTsConfigPaths = (currentFile, cwd) => {
   const parsedConfig = ts.parseJsonConfigFileContent(result.config, ts.sys, pathLib.dirname(configPath), void 0, configPath);
   const {
     baseUrl,
-    paths
+    paths = []
   } = parsedConfig.options;
-  if (!paths) {
-    return {};
-  }
-  const aliases = {};
-  const basePath = baseUrl ? pathLib.resolve(pathLib.dirname(configPath), baseUrl) : pathLib.dirname(configPath);
-  return Object.fromEntries(Object.entries(paths).map(([key, values]) => {
+  const projectReferences = parsedConfig.projectReferences ?? [];
+  const includePatterns = result.config.include ?? ["**/*"];
+  const configDir = pathLib.dirname(configPath);
+  const basePath = baseUrl ? pathLib.resolve(configDir, baseUrl) : configDir;
+  const aliases = Object.fromEntries(Object.entries(paths).map(([key, values]) => {
     const aliasKey = key.replace(/\/\*$/, "");
     const absoluteAliasPath = pathLib.resolve(basePath, values[0].replace(/\/\*$/, ""));
     const relativeAliasPath = pathLib.relative(cwd, absoluteAliasPath);
-    return [aliasKey, `./${relativeAliasPath}`];
+    return [aliasKey, [{
+      configDir,
+      includePatterns,
+      path: `./${relativeAliasPath}`
+    }]];
   }));
+  for (const reference of projectReferences) {
+    const referencePath = pathLib.resolve(pathLib.dirname(configPath), reference.path);
+    let referencedConfigPath = referencePath;
+    if (!referencedConfigPath.endsWith(".json")) {
+      referencedConfigPath = pathLib.join(referencePath, "tsconfig.json");
+    }
+    if (ts.sys.fileExists(referencedConfigPath)) {
+      const referencedAliases = loadTsConfigPathsFromFile(referencedConfigPath, cwd, visitedConfigs);
+      for (const [key, aliasInfos] of Object.entries(referencedAliases)) {
+        if (aliases[key]) {
+          for (const aliasInfo of aliasInfos) {
+            if (!aliases[key].some(a => a.path === aliasInfo.path)) {
+              aliases[key].push(aliasInfo);
+            }
+          }
+        } else {
+          aliases[key] = aliasInfos;
+        }
+      }
+    }
+  }
   return aliases;
 };
+const loadTsConfigPaths = (currentFile, cwd) => {
+  if (!ts) {
+    return {};
+  }
+  const configPath = ts.findConfigFile(pathLib.dirname(currentFile), ts.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    return {};
+  }
+  return loadTsConfigPathsFromFile(configPath, cwd);
+};
 const createRule = ESLintUtils.RuleCreator(() => "");
 const isParentImport = path => /^(\.\/)?\.\.\//.test(path);
-const findMatchingAlias = (sourcePath, currentFile, options) => {
-  const absoluteSourcePath = pathLib.resolve(pathLib.dirname(currentFile), sourcePath);
-  const matches = Object.keys(options.alias).map(aliasName => {
-    const path = pathLib.resolve(pathLib.dirname(currentFile), options.resolvePath(`${aliasName}/`, currentFile, pick(options, ["alias", "cwd"])));
+const findMatchingAlias = (sourcePath, currentFilename, options, {
+  cwd = "."
+} = {}) => {
+  const absoluteSourcePath = pathLib.resolve(pathLib.dirname(currentFilename), sourcePath);
+  const matches = Object.entries(options.alias).flatMap(([aliasName, aliasInfos]) => aliasInfos.map(info => [aliasName, info])).filter(([, info]) => micromatch.isMatch(currentFilename, info.includePatterns, {
+    cwd: info.configDir
+  })).map(([aliasName, info]) => {
+    const path = pathLib.resolve(pathLib.dirname(currentFilename), options.resolvePath(`${aliasName}/`, currentFilename, {
+      alias: {
+        [aliasName]: info.path
+      },
+      cwd
+    }));
     if (absoluteSourcePath.startsWith(path)) {
       return {
         name: aliasName,
@@ -55,13 +96,22 @@ const findMatchingAlias = (sourcePath, currentFile, options) => {
     return null;
   }).filter(match => !!match);
   const sortedMatches = orderBy(matches, ["segmentCount"], ["desc"]);
-  return sortedMatches?.[0] ?? null;
+  return sortedMatches?.[0] ? omit(sortedMatches[0], ["segmentCount"]) : null;
 };
+const withNormalizedAliases = (options, {
+  cwd
+}) => ({
+  ...options,
+  alias: mapValues(options.alias, aliasPath => typeof aliasPath === "string" ? [{
+    configDir: cwd,
+    includePatterns: ["**/*"],
+    path: aliasPath
+  }] : aliasPath)
+});
 export default createRule({
   create: context => {
-    const currentFile = context.getFilename();
-    const folder = pathLib.dirname(currentFile);
-    if (currentFile === "<text>") return {};
+    const folder = pathLib.dirname(context.filename);
+    if (context.filename === "<text>") return {};
     const optionsFromRule = defaults(context.options[0] ?? {}, {
       babelOptions: {},
       shouldReadBabelConfig: true,
@@ -69,16 +119,22 @@ export default createRule({
     });
     const optionsFromBabelPlugin = optionsFromRule.shouldReadBabelConfig ? (() => {
       const babelConfig = loadOptions({
-        filename: currentFile,
+        filename: context.filename,
         ...optionsFromRule.babelOptions
       });
       const babelPlugin = babelConfig?.plugins?.find?.(iteratedPlugin => iteratedPlugin.key === "module-resolver") ?? null;
       const babelPluginOptions = babelPlugin?.options ?? {};
-      return pick(babelPluginOptions, ["alias", "resolvePath"]);
+      return withNormalizedAliases(pick(babelPluginOptions, ["alias", "resolvePath"]), {
+        cwd: context.cwd
+      });
     })() : {};
-    const options = defaults(omit(optionsFromRule, ["babelOptions"]), {
-      alias: optionsFromRule.shouldReadTsConfig ? loadTsConfigPaths(currentFile, context.cwd) : {}
-    }, optionsFromBabelPlugin, {
+    const options = defaults(withNormalizedAliases(omit(optionsFromRule, ["babelOptions"]), {
+      cwd: context.cwd
+    }), {
+      alias: optionsFromRule.shouldReadTsConfig ? loadTsConfigPaths(context.filename, context.cwd) : {}
+    }, withNormalizedAliases(optionsFromBabelPlugin, {
+      cwd: context.cwd
+    }), {
       alias: {},
       aliasForSubpaths: false,
       cwd: context.cwd,
@@ -92,7 +148,9 @@ export default createRule({
         const sourcePath = node.source.value;
         const hasAlias = Object.keys(options.alias).some(alias => sourcePath.startsWith(`${alias}/`));
         if (isParentImport(sourcePath)) {
-          const matchingAlias = findMatchingAlias(sourcePath, currentFile, options);
+          const matchingAlias = findMatchingAlias(sourcePath, context.filename, pick(options, ["alias", "resolvePath"]), {
+            cwd: context.cwd
+          });
           if (!matchingAlias) {
             return;
           }
@@ -108,7 +166,13 @@ export default createRule({
             node
           });
         }
-        const importWithoutAlias = options.resolvePath(sourcePath, currentFile, options);
+        const filteredAliases = Object.fromEntries(Object.entries(options.alias).flatMap(([aliasName, aliasInfos]) => aliasInfos.map(info => [aliasName, info])).filter(([, info]) => micromatch.isMatch(context.filename, info.includePatterns, {
+          cwd: info.configDir
+        })).map(([aliasName, info]) => [aliasName, info.path]));
+        const importWithoutAlias = options.resolvePath(sourcePath, context.filename, {
+          alias: filteredAliases,
+          cwd: options.cwd
+        });
         if (!isParentImport(importWithoutAlias) && hasAlias && !options.aliasForSubpaths) {
           return context.report({
             data: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dword-design/eslint-plugin-import-alias",
-  "version": "8.0.1",
+  "version": "8.1.1",
   "description": "An ESLint plugin that enforces the use of import aliases. Also supports autofixing.",
   "keywords": [
     "alias",
@@ -56,11 +56,13 @@
     "@types/babel__core": "^7.20.5",
     "@types/lodash-es": "^4.17.12",
     "@typescript-eslint/utils": "^8.50.1",
-    "babel-plugin-module-resolver": "^5.0.2"
+    "babel-plugin-module-resolver": "^5.0.2",
+    "micromatch": "^4.0.8"
   },
   "devDependencies": {
     "@dword-design/base": "^16.1.7",
     "@playwright/test": "^1.57.0",
+    "@types/micromatch": "^4.0.10",
     "depcheck-package-name": "^5.0.0",
     "endent": "npm:@dword-design/endent@^1.4.7",
     "eslint": "^9.39.2",