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

package/README.md

@@ -85,7 +85,9 @@ $ yarn add @dword-design/eslint-plugin-import-alias
 
 Add the plugin to your ESLint config:
 
-```js
+```ts
+// eslint.config.ts
+
 import { defineConfig } from 'eslint/config';
 import importAlias from '@dword-design/import-alias';
 
@@ -94,9 +96,37 @@ export default defineConfig([
 ]);
 ```
 
-Alright, now you have to tell the plugin which aliases to use. In the simplest case, you are already using [babel-plugin-module-resolver](https://www.npmjs.com/package/babel-plugin-module-resolver) for your aliases. Your babel config would look something like this:
+Options can be passed by setting them in the `prefer-alias` rule:
+
+```ts
+// eslint.config.ts
+
+import { defineConfig } from 'eslint/config';
+import importAlias from '@dword-design/import-alias';
+
+export default defineConfig([
+  importAlias.configs.recommended,
+  {
+    rules: {
+      '@dword-design/import-alias/prefer-alias': ['error', /* options */],
+    },
+  },
+]);
+```
+
+Now you have multiple ways to tell the plugin about aliases.
+
+### `tsconfig.json` `paths` setting
+
+If you are a TypeScript user and you have aliases configured in your `tsconfig.json` via the `paths` setting, they will automatically be loaded. You can disable this behavior by setting `shouldReadTsConfig` to `false` in the plugin options.
+
+### [babel-plugin-module-resolver](https://www.npmjs.com/package/babel-plugin-module-resolver)
+
+If you are already using [babel-plugin-module-resolver](https://www.npmjs.com/package/babel-plugin-module-resolver), the plugin will load the Babel config and extract the `alias` and `resolvePath` options. You can disable this behavior by setting `shouldReadBabelConfig` to `false` in the plugin options.
 
 ```json
+// .babelrc.json
+
 {
   "plugins": {
     ["module-resolver", {
@@ -108,32 +138,54 @@ Alright, now you have to tell the plugin which aliases to use. In the simplest c
 }
 ```
 
-In this case lucky you, you don't have to do anything else. The plugin should work out of the box.
+### Plugin `alias` option
 
-If you have a special project setup that does not have a babel config in the project path, you can still use the plugin by passing the aliases directly to the rule. In this case you define the rule additionally in the `rules` section:
+You can also just pass the aliases to the plugin as an option.
 
-```json
-"rules": {
-  "@dword-design/import-alias/prefer-alias": [
-    "error",
-    {
-      "alias": {
-        "@": "./src",
-        "@components": "./src/components"
-      }
-    }
-  ]
-}
+```ts
+// eslint.config.ts
+
+import { defineConfig } from 'eslint/config';
+import importAlias from '@dword-design/import-alias';
+
+export default defineConfig([
+  importAlias.configs.recommended,
+  {
+    rules: {
+      '@dword-design/import-alias/prefer-alias': [
+        'error',
+        {
+          'alias': {
+            '@': './src',
+            '@components': './src/components',
+          },
+        },
+      ],
+    },
+  },
+]);
 ```
 
+## Alias resolution
+
 By default, the plugin will convert parent paths to aliases (like `../model/foo`), but will keep subpath imports relative. You can change that to also convert subpaths to aliased imports by passing the `aliasForSubpaths` option to the rule like so:
 
-```json
-"rules": {
-  "@dword-design/import-alias/prefer-alias": ["error", { "aliasForSubpaths": true }]
+```ts
+rules: {
+  '@dword-design/import-alias/prefer-alias': ['error', { aliasForSubpaths: true }],
+}
+```
+
+Also, inner alias paths are preferred to outer ones. Example:
+
+```ts
+rules: {
+  '@dword-design/import-alias/prefer-alias': ['error', { alias: { '@': './app', '@@': '.' }],
 }
 ```
 
+If an import resolves to a file insode `app`, `@` will be preferred over `@@` although both aliases match. This is convenient for the use case where you have a lot of aliases for top-level folders like `components`, `utils` etc where you usually want those instead of a generic root alias. If you have other use cases, please let me know.
+
 <!-- LICENSE/ -->
 ## Contribute
 

package/dist/index.d.ts

@@ -4,16 +4,15 @@ declare const _default: {
             plugins: {
                 '@dword-design/import-alias': {
                     rules: {
-                        'prefer-alias': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"parentImport" | "subpathImport", [Partial<import("./rules/prefer-alias").Options> & {
-                            babelOptions?: Record<string, unknown>;
-                        }], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+                        'prefer-alias': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"parentImport" | "subpathImport", [import("./rules/prefer-alias").OptionsInput], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
                     };
                 };
             };
             rules: {
-                '@dword-design/import-alias/prefer-alias': string;
+                '@dword-design/import-alias/prefer-alias': "error";
             };
         };
     };
 };
 export default _default;
+export { type OptionsInput } from './rules/prefer-alias';

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

@@ -1,3 +1,4 @@
+import { loadOptions } from '@babel/core';
 import { ESLintUtils } from '@typescript-eslint/utils';
 export interface BabelPluginModuleResolverOptions {
     alias?: Record<string, string>;
@@ -7,11 +8,14 @@ export interface BabelPluginModuleResolverOptions {
 export interface Options {
     alias: Record<string, string>;
     aliasForSubpaths: boolean;
+    shouldReadTsConfig: boolean;
+    shouldReadBabelConfig: boolean;
     resolvePath: (sourcePath: string, currentFile: string, options: Pick<BabelPluginModuleResolverOptions, 'alias' | 'cwd'>) => string;
     cwd: string;
 }
-type OptionsInput = Partial<Options> & {
-    babelOptions?: Record<string, unknown>;
+type BabelOptions = Exclude<Parameters<typeof loadOptions>[0], undefined>;
+export type OptionsInput = Partial<Options> & {
+    babelOptions?: BabelOptions;
 };
 declare const _default: ESLintUtils.RuleModule<"parentImport" | "subpathImport", [OptionsInput], unknown, ESLintUtils.RuleListener>;
 export default _default;

package/dist/rules/prefer-alias.js

@@ -3,20 +3,59 @@ 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, pick } from "lodash-es";
+import { omit, orderBy, pick } from "lodash-es";
+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) {
+    return {};
+  }
+  const configText = ts.sys.readFile(configPath);
+  if (!configText) {
+    return {};
+  }
+  const result = ts.parseConfigFileTextToJson(configPath, configText);
+  if (!result.config) {
+    return {};
+  }
+  const parsedConfig = ts.parseJsonConfigFileContent(result.config, ts.sys, pathLib.dirname(configPath), void 0, configPath);
+  const {
+    baseUrl,
+    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 aliasKey = key.replace(/\/\*$/, "");
+    const absoluteAliasPath = pathLib.resolve(basePath, values[0].replace(/\/\*$/, ""));
+    const relativeAliasPath = pathLib.relative(cwd, absoluteAliasPath);
+    return [aliasKey, `./${relativeAliasPath}`];
+  }));
+  return aliases;
+};
 const createRule = ESLintUtils.RuleCreator(() => "");
 const isParentImport = path => /^(\.\/)?\.\.\//.test(path);
 const findMatchingAlias = (sourcePath, currentFile, options) => {
   const absoluteSourcePath = pathLib.resolve(pathLib.dirname(currentFile), sourcePath);
-  for (const aliasName of Object.keys(options.alias)) {
+  const matches = Object.keys(options.alias).map(aliasName => {
     const path = pathLib.resolve(pathLib.dirname(currentFile), options.resolvePath(`${aliasName}/`, currentFile, pick(options, ["alias", "cwd"])));
     if (absoluteSourcePath.startsWith(path)) {
       return {
         name: aliasName,
-        path
+        path,
+        segmentCount: path.split(pathLib.sep).length
       };
     }
-  }
+    return null;
+  }).filter(match => !!match);
+  const sortedMatches = orderBy(matches, ["segmentCount"], ["desc"]);
+  return sortedMatches?.[0] ?? null;
 };
 export default createRule({
   create: context => {
@@ -24,23 +63,29 @@ export default createRule({
     const folder = pathLib.dirname(currentFile);
     if (currentFile === "<text>") return {};
     const optionsFromRule = defaults(context.options[0] ?? {}, {
-      babelOptions: {}
-    });
-    const babelConfig = loadOptions({
-      filename: currentFile,
-      ...optionsFromRule.babelOptions
+      babelOptions: {},
+      shouldReadBabelConfig: true,
+      shouldReadTsConfig: true
     });
-    const babelPlugin = babelConfig?.plugins?.find?.(iteratedPlugin => iteratedPlugin.key === "module-resolver") ?? null;
-    const babelPluginOptions = babelPlugin?.options ?? {};
-    const optionsFromPlugin = pick(babelPluginOptions, ["alias", "resolvePath"]);
-    const options = defaults(omit(optionsFromRule, ["babelOptions"]), optionsFromPlugin, {
+    const optionsFromBabelPlugin = optionsFromRule.shouldReadBabelConfig ? (() => {
+      const babelConfig = loadOptions({
+        filename: currentFile,
+        ...optionsFromRule.babelOptions
+      });
+      const babelPlugin = babelConfig?.plugins?.find?.(iteratedPlugin => iteratedPlugin.key === "module-resolver") ?? null;
+      const babelPluginOptions = babelPlugin?.options ?? {};
+      return pick(babelPluginOptions, ["alias", "resolvePath"]);
+    })() : {};
+    const options = defaults(omit(optionsFromRule, ["babelOptions"]), {
+      alias: optionsFromRule.shouldReadTsConfig ? loadTsConfigPaths(currentFile, context.cwd) : {}
+    }, optionsFromBabelPlugin, {
       alias: {},
       aliasForSubpaths: false,
       cwd: context.cwd,
       resolvePath: defaultResolvePath
     });
     if (Object.keys(options.alias).length === 0) {
-      throw new Error("No alias configured. You have to define aliases by either passing them to the babel-plugin-module-resolver plugin in your Babel config, or directly to the prefer-alias rule.");
+      throw new Error("No alias configured. You have to define aliases by either passing them to the babel-plugin-module-resolver plugin in your Babel config, defining them in your tsconfig.json paths, or passing them directly to the prefer-alias rule.");
     }
     return {
       ImportDeclaration: node => {
@@ -101,6 +146,14 @@ export default createRule({
         },
         babelOptions: {
           type: "object"
+        },
+        shouldReadBabelConfig: {
+          default: true,
+          type: "boolean"
+        },
+        shouldReadTsConfig: {
+          default: true,
+          type: "boolean"
         }
       },
       type: "object"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dword-design/eslint-plugin-import-alias",
-  "version": "7.0.0",
+  "version": "8.0.1",
   "description": "An ESLint plugin that enforces the use of import aliases. Also supports autofixing.",
   "keywords": [
     "alias",
@@ -59,15 +59,24 @@
     "babel-plugin-module-resolver": "^5.0.2"
   },
   "devDependencies": {
-    "@dword-design/base": "^16.1.5",
+    "@dword-design/base": "^16.1.7",
     "@playwright/test": "^1.57.0",
     "depcheck-package-name": "^5.0.0",
     "endent": "npm:@dword-design/endent@^1.4.7",
     "eslint": "^9.39.2",
     "lodash-es": "^4.17.22",
     "output-files": "^3.0.0",
+    "typescript": "^5.0.0",
     "typescript-eslint": "^8.50.0"
   },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
   "packageManager": "pnpm@10.11.1+sha512.e519b9f7639869dc8d5c3c5dfef73b3f091094b0a006d7317353c72b124e80e1afd429732e28705ad6bfa1ee879c1fce46c128ccebd3192101f43dd67c667912",
   "engines": {
     "node": ">=22"