@macklenc/eslint-plugin-absolute-imports 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Christopher Macklen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# @macklenc/eslint-plugin-absolute-imports
+
+An ESLint plugin that automatically replaces relative imports with absolute imports based on your project's structure.
+
+## Installation
+
+You'll first need to install [ESLint](https://eslint.org/):
+
+```sh
+npm i eslint --save-dev
+```
+
+Next, install `@macklenc/eslint-plugin-absolute-imports`:
+
+```sh
+npm install @macklenc/eslint-plugin-absolute-imports --save-dev
+```
+
+## Usage
+
+Add `absolute-imports` to the plugins section of your [ESLint configuration file](https://eslint.org/docs/latest/use/configure/configuration-files).
+
+### For ESLint v9+ (flat config)
+
+```js
+import absoluteImports from "@macklenc/eslint-plugin-absolute-imports";
+
+export default [
+  {
+    plugins: {
+      "absolute-imports": absoluteImports,
+    },
+    rules: {
+      "absolute-imports/absolute-imports": [
+        "error",
+        {
+          // Optional: specify the base path for your project
+          // basePath: "./src",
+          // Optional: specify the path to your tsconfig.json for path mapping
+          // tsconfigPath: "./tsconfig.json"
+        },
+      ],
+    },
+  },
+];
+```
+
+### For ESLint v8 (legacy config)
+
+```js
+module.exports = {
+  plugins: ["absolute-imports"],
+  rules: {
+    "absolute-imports/absolute-imports": [
+      "error",
+      {
+        // Optional: specify the base path for your project
+        // basePath: "./src",
+        // Optional: specify the path to your tsconfig.json for path mapping
+        // tsconfigPath: "./tsconfig.json"
+      },
+    ],
+  },
+};
+```
+
+## Rules
+
+### absolute-imports
+
+This rule identifies relative imports in your code and suggests replacing them with absolute imports.
+
+#### Options
+
+The rule accepts an options object with the following properties:
+
+- `basePath` (optional): The base path of your project. Defaults to the current working directory.
+- `tsconfigPath` (optional): Path to your tsconfig.json file for path mapping. Defaults to `<projectRoot>/tsconfig.json`.
+
+#### Examples
+
+Given a project structure:
+
+```
+/project
+  /src
+    /components
+      Component.ts
+    /pages
+      Page.ts
+```
+
+With the rule configured as:
+
+```js
+"absolute-imports/absolute-imports": ["error", { basePath: "./src" }]
+```
+
+The following code in `/src/pages/Page.ts`:
+
+```js
+import { Component } from "../components/Component";
+```
+
+Will be converted to:
+
+```js
+import { Component } from "/components/Component";
+```
+
+#### When the rule is triggered
+
+The rule will be triggered when:
+
+- You use relative imports (starting with `./` or `../`)
+- The import can be converted to an absolute path based on your project structure
+
+The rule will not be triggered for:
+
+- Already absolute imports
+- Imports using aliases (e.g., `@components/Component`)
+- External package imports (e.g., `react`, `lodash`)
+
+## Development
+
+### Commit Guidelines
+
+This project follows [Conventional Commits](https://www.conventionalcommits.org/) for commit messages. This helps with automatic versioning and changelog generation.
+
+To create a properly formatted commit, run:
+
+```sh
+npm run commit
+# or
+pnpm run commit
+```
+
+This will guide you through creating a conventional commit message.
+
+### Versioning and Releases
+
+This project uses [standard-version](https://github.com/conventional-changelog/standard-version) for versioning and changelog generation based on commit messages.
+
+To create a new release:
+
+```sh
+# Automatically determine version bump based on commits
+npm run release
+# or
+pnpm run release
+
+# Specific version bumps
+npm run release:patch  # 0.0.1 -> 0.0.2
+npm run release:minor  # 0.0.1 -> 0.1.0
+npm run release:major  # 0.0.1 -> 1.0.0
+
+# Preview what the release would do
+npm run release:dry-run
+```
+
+The release process will:
+
+1. Bump the version in package.json
+2. Update CHANGELOG.md with all notable changes
+3. Create a git tag for the new version
+4. Create a commit with these changes
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,205 @@
+'use strict';
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === 'object') || typeof from === 'function') {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, 'default', { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = mod => __copyProps(__defProp({}, '__esModule', { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs = __toESM(require('fs'), 1);
+var import_path = __toESM(require('path'), 1);
+
+// lib/rules/absolute-imports.ts
+var import_types = require('@typescript-eslint/types');
+var import_utils = require('@typescript-eslint/utils');
+var path = __toESM(require('path'), 1);
+var fs = __toESM(require('fs'), 1);
+var createRule = import_utils.ESLintUtils.RuleCreator(name => `absolute-imports/${name}`);
+var absoluteImports = createRule({
+  name: 'absolute-imports',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Convert relative imports to absolute imports based on a configured base path and tsconfig paths.',
+    },
+    messages: {
+      relativeImport:
+        "Relative import '{{ importPath }}' should be converted to absolute import '{{ absolutePath }}'.",
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          basePath: {
+            type: 'string',
+          },
+          tsconfigPath: {
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    fixable: 'code',
+  },
+  defaultOptions: [{}],
+  create(context) {
+    const options = context.options[0] || {};
+    const basePath = options.basePath || process.cwd();
+    const tsconfigPath = options.tsconfigPath || path.join(process.cwd(), 'tsconfig.json');
+    const projectRoot = path.dirname(tsconfigPath);
+    let tsconfigPaths = null;
+    try {
+      const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
+      const tsconfigRaw = tsconfigContent.replace(
+        /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
+        (m, g) => (g ? '' : m)
+      );
+      const tsconfig = JSON.parse(tsconfigRaw);
+      if (tsconfig.compilerOptions && tsconfig.compilerOptions.paths) {
+        tsconfigPaths = tsconfig.compilerOptions.paths;
+      }
+    } catch (err) {
+      tsconfigPaths = null;
+    }
+    function tryAliasMapping(relativePath) {
+      if (!tsconfigPaths) return null;
+      let matchedAlias = null;
+      let longestMatch = -1;
+      for (const aliasPattern in tsconfigPaths) {
+        for (const targetPattern of tsconfigPaths[aliasPattern]) {
+          let normalizedTarget = targetPattern.replace(/^\.\//, '');
+          if (normalizedTarget.endsWith('/*')) {
+            normalizedTarget = normalizedTarget.slice(0, -2);
+          }
+          if (relativePath.startsWith(normalizedTarget)) {
+            if (normalizedTarget.length > longestMatch) {
+              longestMatch = normalizedTarget.length;
+              let aliasBase = aliasPattern;
+              if (aliasBase.endsWith('/*')) {
+                aliasBase = aliasBase.slice(0, -2);
+              }
+              const remainder = relativePath.slice(normalizedTarget.length);
+              const cleanRemainder = remainder.replace(/^\/+/, '');
+              matchedAlias = aliasBase + (cleanRemainder ? '/' + cleanRemainder : '');
+            }
+          }
+        }
+      }
+      return matchedAlias;
+    }
+    function toAbsolute(importPath, filePath) {
+      const fileDir = path.dirname(filePath);
+      const resolvedPath = path.resolve(fileDir, importPath);
+      let relativeToRoot = path.relative(projectRoot, resolvedPath);
+      relativeToRoot = relativeToRoot.replace(/\\/g, '/');
+      const aliasPath = tryAliasMapping(relativeToRoot);
+      if (aliasPath) {
+        return aliasPath;
+      }
+      let relativeToBase = path.relative(basePath, resolvedPath);
+      relativeToBase = relativeToBase.replace(/\\/g, '/');
+      if (!relativeToBase.startsWith('/')) {
+        relativeToBase = '/' + relativeToBase;
+      }
+      return relativeToBase;
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source && typeof node.source.value === 'string') {
+          const importPath = node.source.value;
+          if (importPath.startsWith('.')) {
+            const fileName = context.getFilename();
+            const absolutePath = toAbsolute(importPath, fileName);
+            context.report({
+              node: node.source,
+              messageId: 'relativeImport',
+              data: { importPath, absolutePath },
+              fix(fixer) {
+                return fixer.replaceText(node.source, `'${absolutePath}'`);
+              },
+            });
+          }
+        }
+      },
+      // Optionally handle dynamic imports.
+      CallExpression(node) {
+        if (
+          // Check if this is a dynamic import
+          node.callee.name === 'import' &&
+          node.arguments.length === 1 &&
+          node.arguments[0].type === import_types.TSESTree.AST_NODE_TYPES.Literal &&
+          typeof node.arguments[0].value === 'string'
+        ) {
+          const importPath = node.arguments[0].value;
+          if (importPath.startsWith('.')) {
+            const fileName = context.getFilename();
+            const absolutePath = toAbsolute(importPath, fileName);
+            context.report({
+              node: node.arguments[0],
+              messageId: 'relativeImport',
+              data: { importPath, absolutePath },
+              fix(fixer) {
+                return fixer.replaceText(node.arguments[0], `'${absolutePath}'`);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+});
+
+// lib/rules/index.ts
+var rules = {
+  'absolute-imports': absoluteImports,
+};
+
+// index.ts
+var pkg = JSON.parse(
+  import_fs.default.readFileSync(import_path.default.resolve(__dirname, './package.json'), 'utf8')
+);
+var plugin = {
+  meta: {
+    name: pkg.name,
+    version: pkg.version,
+  },
+  rules,
+};
+var index_default = plugin;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts","../lib/rules/absolute-imports.ts","../lib/rules/index.ts"],"sourcesContent":["'use strict';\n\nimport fs from 'fs';\nimport path from 'path';\nimport { ESLint } from 'eslint';\nimport { RuleModule } from '@typescript-eslint/utils/ts-eslint';\nimport { rules } from '@/lib/rules/index.js';\n\ntype RuleKey = keyof typeof rules;\n\ninterface Plugin extends Omit<ESLint.Plugin, 'rules'> {\n  rules: Record<RuleKey, RuleModule<any, any, any>>;\n}\n\nconst pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, './package.json'), 'utf8'));\n\nconst plugin: Plugin = {\n  meta: {\n    name: pkg.name,\n    version: pkg.version,\n  },\n  rules,\n};\n\nexport default plugin;\n","import { TSESTree } from '@typescript-eslint/types';\nimport { ESLintUtils } from '@typescript-eslint/utils';\nimport * as path from 'path';\nimport * as fs from 'fs';\n\n// Define the options type\ntype Options = [\n  {\n    basePath?: string;\n    tsconfigPath?: string;\n  },\n];\n\nexport const createRule = ESLintUtils.RuleCreator(name => `absolute-imports/${name}`);\n\nexport const absoluteImports = createRule<Options, 'relativeImport'>({\n  name: 'absolute-imports',\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Convert relative imports to absolute imports based on a configured base path and tsconfig paths.',\n    },\n    messages: {\n      relativeImport:\n        \"Relative import '{{ importPath }}' should be converted to absolute import '{{ absolutePath }}'.\",\n    },\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          basePath: {\n            type: 'string',\n          },\n          tsconfigPath: {\n            type: 'string',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    fixable: 'code',\n  },\n  defaultOptions: [{}],\n  create(context) {\n    const options = context.options[0] || {};\n    // basePath is used for fallback when alias mapping doesn't apply.\n    const basePath = options.basePath || process.cwd();\n    // tsconfigPath defaults to <projectRoot>/tsconfig.json.\n    const tsconfigPath = options.tsconfigPath || path.join(process.cwd(), 'tsconfig.json');\n\n    // Use the directory of the tsconfig as the project root.\n    const projectRoot = path.dirname(tsconfigPath);\n\n    let tsconfigPaths: Record<string, string[]> | null = null;\n    try {\n      const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');\n      const tsconfigRaw = tsconfigContent.replace(\n        /\\\\\"|\"(?:\\\\\"|[^\"])*\"|(\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\/)/g,\n        (m, g) => (g ? '' : m)\n      );\n      const tsconfig = JSON.parse(tsconfigRaw);\n      if (tsconfig.compilerOptions && tsconfig.compilerOptions.paths) {\n        tsconfigPaths = tsconfig.compilerOptions.paths;\n      }\n    } catch (err) {\n      // If tsconfig.json cannot be read, ignore alias mapping.\n      tsconfigPaths = null;\n    }\n\n    /**\n     * Given a file path relative to the project root (without a leading slash),\n     * try to find a matching alias from tsconfig paths.\n     */\n    function tryAliasMapping(relativePath: string): string | null {\n      if (!tsconfigPaths) return null;\n      let matchedAlias: string | null = null;\n      let longestMatch = -1;\n      for (const aliasPattern in tsconfigPaths) {\n        for (const targetPattern of tsconfigPaths[aliasPattern]) {\n          // Normalize target: remove leading \"./\" if present.\n          let normalizedTarget = targetPattern.replace(/^\\.\\//, '');\n          // Remove trailing \"/*\" if present.\n          if (normalizedTarget.endsWith('/*')) {\n            normalizedTarget = normalizedTarget.slice(0, -2);\n          }\n          // If the file path starts with the target, it's a match.\n          if (relativePath.startsWith(normalizedTarget)) {\n            if (normalizedTarget.length > longestMatch) {\n              longestMatch = normalizedTarget.length;\n              let aliasBase = aliasPattern;\n              if (aliasBase.endsWith('/*')) {\n                aliasBase = aliasBase.slice(0, -2);\n              }\n              const remainder = relativePath.slice(normalizedTarget.length);\n              const cleanRemainder = remainder.replace(/^\\/+/, '');\n              matchedAlias = aliasBase + (cleanRemainder ? '/' + cleanRemainder : '');\n            }\n          }\n        }\n      }\n      return matchedAlias;\n    }\n\n    /**\n     * Convert the relative import path to an absolute one.\n     * First, compute the file's path relative to the project root (from tsconfig).\n     * If an alias is found via tsconfig paths, return that alias.\n     * Otherwise, fall back to computing a path relative to the configured basePath.\n     */\n    function toAbsolute(importPath: string, filePath: string): string {\n      const fileDir = path.dirname(filePath);\n      const resolvedPath = path.resolve(fileDir, importPath);\n\n      // Compute relative path from the project root.\n      let relativeToRoot = path.relative(projectRoot, resolvedPath);\n      relativeToRoot = relativeToRoot.replace(/\\\\/g, '/');\n      const aliasPath = tryAliasMapping(relativeToRoot);\n      if (aliasPath) {\n        return aliasPath;\n      }\n\n      // Fallback: compute relative to the configured basePath.\n      let relativeToBase = path.relative(basePath, resolvedPath);\n      relativeToBase = relativeToBase.replace(/\\\\/g, '/');\n      if (!relativeToBase.startsWith('/')) {\n        relativeToBase = '/' + relativeToBase;\n      }\n      return relativeToBase;\n    }\n\n    return {\n      ImportDeclaration(node) {\n        if (node.source && typeof node.source.value === 'string') {\n          const importPath = node.source.value;\n          if (importPath.startsWith('.')) {\n            const fileName = context.getFilename();\n            const absolutePath = toAbsolute(importPath, fileName);\n            context.report({\n              node: node.source,\n              messageId: 'relativeImport',\n              data: { importPath, absolutePath },\n              fix(fixer) {\n                return fixer.replaceText(node.source, `'${absolutePath}'`);\n              },\n            });\n          }\n        }\n      },\n      // Optionally handle dynamic imports.\n      CallExpression(node) {\n        // For dynamic imports, node.callee is an Identifier with name 'import'\n        if (\n          // Check if this is a dynamic import\n          (node.callee as any).name === 'import' &&\n          node.arguments.length === 1 &&\n          node.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal &&\n          typeof node.arguments[0].value === 'string'\n        ) {\n          const importPath = node.arguments[0].value;\n          if (importPath.startsWith('.')) {\n            const fileName = context.getFilename();\n            const absolutePath = toAbsolute(importPath, fileName);\n            context.report({\n              node: node.arguments[0],\n              messageId: 'relativeImport',\n              data: { importPath, absolutePath },\n              fix(fixer) {\n                return fixer.replaceText(node.arguments[0], `'${absolutePath}'`);\n              },\n            });\n          }\n        }\n      },\n    };\n  },\n});\n","import { absoluteImports } from './absolute-imports.js';\n\nexport const rules = {\n  'absolute-imports': absoluteImports,\n};\n"],"mappings":"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","names":["fs","path"]}

package/dist/index.d.cts

@@ -0,0 +1,11 @@
+import { ESLint } from 'eslint';
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+import { rules } from './lib/rules/index.cjs';
+
+type RuleKey = keyof typeof rules;
+interface Plugin extends Omit<ESLint.Plugin, 'rules'> {
+    rules: Record<RuleKey, RuleModule<any, any, any>>;
+}
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { ESLint } from 'eslint';
+import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+import { rules } from './lib/rules/index.js';
+
+type RuleKey = keyof typeof rules;
+interface Plugin extends Omit<ESLint.Plugin, 'rules'> {
+    rules: Record<RuleKey, RuleModule<any, any, any>>;
+}
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,163 @@
+// index.ts
+import fs2 from 'fs';
+import path2 from 'path';
+
+// lib/rules/absolute-imports.ts
+import { TSESTree } from '@typescript-eslint/types';
+import { ESLintUtils } from '@typescript-eslint/utils';
+import * as path from 'path';
+import * as fs from 'fs';
+var createRule = ESLintUtils.RuleCreator(name => `absolute-imports/${name}`);
+var absoluteImports = createRule({
+  name: 'absolute-imports',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Convert relative imports to absolute imports based on a configured base path and tsconfig paths.',
+    },
+    messages: {
+      relativeImport:
+        "Relative import '{{ importPath }}' should be converted to absolute import '{{ absolutePath }}'.",
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          basePath: {
+            type: 'string',
+          },
+          tsconfigPath: {
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    fixable: 'code',
+  },
+  defaultOptions: [{}],
+  create(context) {
+    const options = context.options[0] || {};
+    const basePath = options.basePath || process.cwd();
+    const tsconfigPath = options.tsconfigPath || path.join(process.cwd(), 'tsconfig.json');
+    const projectRoot = path.dirname(tsconfigPath);
+    let tsconfigPaths = null;
+    try {
+      const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
+      const tsconfigRaw = tsconfigContent.replace(
+        /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
+        (m, g) => (g ? '' : m)
+      );
+      const tsconfig = JSON.parse(tsconfigRaw);
+      if (tsconfig.compilerOptions && tsconfig.compilerOptions.paths) {
+        tsconfigPaths = tsconfig.compilerOptions.paths;
+      }
+    } catch (err) {
+      tsconfigPaths = null;
+    }
+    function tryAliasMapping(relativePath) {
+      if (!tsconfigPaths) return null;
+      let matchedAlias = null;
+      let longestMatch = -1;
+      for (const aliasPattern in tsconfigPaths) {
+        for (const targetPattern of tsconfigPaths[aliasPattern]) {
+          let normalizedTarget = targetPattern.replace(/^\.\//, '');
+          if (normalizedTarget.endsWith('/*')) {
+            normalizedTarget = normalizedTarget.slice(0, -2);
+          }
+          if (relativePath.startsWith(normalizedTarget)) {
+            if (normalizedTarget.length > longestMatch) {
+              longestMatch = normalizedTarget.length;
+              let aliasBase = aliasPattern;
+              if (aliasBase.endsWith('/*')) {
+                aliasBase = aliasBase.slice(0, -2);
+              }
+              const remainder = relativePath.slice(normalizedTarget.length);
+              const cleanRemainder = remainder.replace(/^\/+/, '');
+              matchedAlias = aliasBase + (cleanRemainder ? '/' + cleanRemainder : '');
+            }
+          }
+        }
+      }
+      return matchedAlias;
+    }
+    function toAbsolute(importPath, filePath) {
+      const fileDir = path.dirname(filePath);
+      const resolvedPath = path.resolve(fileDir, importPath);
+      let relativeToRoot = path.relative(projectRoot, resolvedPath);
+      relativeToRoot = relativeToRoot.replace(/\\/g, '/');
+      const aliasPath = tryAliasMapping(relativeToRoot);
+      if (aliasPath) {
+        return aliasPath;
+      }
+      let relativeToBase = path.relative(basePath, resolvedPath);
+      relativeToBase = relativeToBase.replace(/\\/g, '/');
+      if (!relativeToBase.startsWith('/')) {
+        relativeToBase = '/' + relativeToBase;
+      }
+      return relativeToBase;
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source && typeof node.source.value === 'string') {
+          const importPath = node.source.value;
+          if (importPath.startsWith('.')) {
+            const fileName = context.getFilename();
+            const absolutePath = toAbsolute(importPath, fileName);
+            context.report({
+              node: node.source,
+              messageId: 'relativeImport',
+              data: { importPath, absolutePath },
+              fix(fixer) {
+                return fixer.replaceText(node.source, `'${absolutePath}'`);
+              },
+            });
+          }
+        }
+      },
+      // Optionally handle dynamic imports.
+      CallExpression(node) {
+        if (
+          // Check if this is a dynamic import
+          node.callee.name === 'import' &&
+          node.arguments.length === 1 &&
+          node.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal &&
+          typeof node.arguments[0].value === 'string'
+        ) {
+          const importPath = node.arguments[0].value;
+          if (importPath.startsWith('.')) {
+            const fileName = context.getFilename();
+            const absolutePath = toAbsolute(importPath, fileName);
+            context.report({
+              node: node.arguments[0],
+              messageId: 'relativeImport',
+              data: { importPath, absolutePath },
+              fix(fixer) {
+                return fixer.replaceText(node.arguments[0], `'${absolutePath}'`);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+});
+
+// lib/rules/index.ts
+var rules = {
+  'absolute-imports': absoluteImports,
+};
+
+// index.ts
+var pkg = JSON.parse(fs2.readFileSync(path2.resolve(__dirname, './package.json'), 'utf8'));
+var plugin = {
+  meta: {
+    name: pkg.name,
+    version: pkg.version,
+  },
+  rules,
+};
+var index_default = plugin;
+export { index_default as default };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts","../lib/rules/absolute-imports.ts","../lib/rules/index.ts"],"sourcesContent":["'use strict';\n\nimport fs from 'fs';\nimport path from 'path';\nimport { ESLint } from 'eslint';\nimport { RuleModule } from '@typescript-eslint/utils/ts-eslint';\nimport { rules } from '@/lib/rules/index.js';\n\ntype RuleKey = keyof typeof rules;\n\ninterface Plugin extends Omit<ESLint.Plugin, 'rules'> {\n  rules: Record<RuleKey, RuleModule<any, any, any>>;\n}\n\nconst pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, './package.json'), 'utf8'));\n\nconst plugin: Plugin = {\n  meta: {\n    name: pkg.name,\n    version: pkg.version,\n  },\n  rules,\n};\n\nexport default plugin;\n","import { TSESTree } from '@typescript-eslint/types';\nimport { ESLintUtils } from '@typescript-eslint/utils';\nimport * as path from 'path';\nimport * as fs from 'fs';\n\n// Define the options type\ntype Options = [\n  {\n    basePath?: string;\n    tsconfigPath?: string;\n  },\n];\n\nexport const createRule = ESLintUtils.RuleCreator(name => `absolute-imports/${name}`);\n\nexport const absoluteImports = createRule<Options, 'relativeImport'>({\n  name: 'absolute-imports',\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Convert relative imports to absolute imports based on a configured base path and tsconfig paths.',\n    },\n    messages: {\n      relativeImport:\n        \"Relative import '{{ importPath }}' should be converted to absolute import '{{ absolutePath }}'.\",\n    },\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          basePath: {\n            type: 'string',\n          },\n          tsconfigPath: {\n            type: 'string',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    fixable: 'code',\n  },\n  defaultOptions: [{}],\n  create(context) {\n    const options = context.options[0] || {};\n    // basePath is used for fallback when alias mapping doesn't apply.\n    const basePath = options.basePath || process.cwd();\n    // tsconfigPath defaults to <projectRoot>/tsconfig.json.\n    const tsconfigPath = options.tsconfigPath || path.join(process.cwd(), 'tsconfig.json');\n\n    // Use the directory of the tsconfig as the project root.\n    const projectRoot = path.dirname(tsconfigPath);\n\n    let tsconfigPaths: Record<string, string[]> | null = null;\n    try {\n      const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');\n      const tsconfigRaw = tsconfigContent.replace(\n        /\\\\\"|\"(?:\\\\\"|[^\"])*\"|(\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\/)/g,\n        (m, g) => (g ? '' : m)\n      );\n      const tsconfig = JSON.parse(tsconfigRaw);\n      if (tsconfig.compilerOptions && tsconfig.compilerOptions.paths) {\n        tsconfigPaths = tsconfig.compilerOptions.paths;\n      }\n    } catch (err) {\n      // If tsconfig.json cannot be read, ignore alias mapping.\n      tsconfigPaths = null;\n    }\n\n    /**\n     * Given a file path relative to the project root (without a leading slash),\n     * try to find a matching alias from tsconfig paths.\n     */\n    function tryAliasMapping(relativePath: string): string | null {\n      if (!tsconfigPaths) return null;\n      let matchedAlias: string | null = null;\n      let longestMatch = -1;\n      for (const aliasPattern in tsconfigPaths) {\n        for (const targetPattern of tsconfigPaths[aliasPattern]) {\n          // Normalize target: remove leading \"./\" if present.\n          let normalizedTarget = targetPattern.replace(/^\\.\\//, '');\n          // Remove trailing \"/*\" if present.\n          if (normalizedTarget.endsWith('/*')) {\n            normalizedTarget = normalizedTarget.slice(0, -2);\n          }\n          // If the file path starts with the target, it's a match.\n          if (relativePath.startsWith(normalizedTarget)) {\n            if (normalizedTarget.length > longestMatch) {\n              longestMatch = normalizedTarget.length;\n              let aliasBase = aliasPattern;\n              if (aliasBase.endsWith('/*')) {\n                aliasBase = aliasBase.slice(0, -2);\n              }\n              const remainder = relativePath.slice(normalizedTarget.length);\n              const cleanRemainder = remainder.replace(/^\\/+/, '');\n              matchedAlias = aliasBase + (cleanRemainder ? '/' + cleanRemainder : '');\n            }\n          }\n        }\n      }\n      return matchedAlias;\n    }\n\n    /**\n     * Convert the relative import path to an absolute one.\n     * First, compute the file's path relative to the project root (from tsconfig).\n     * If an alias is found via tsconfig paths, return that alias.\n     * Otherwise, fall back to computing a path relative to the configured basePath.\n     */\n    function toAbsolute(importPath: string, filePath: string): string {\n      const fileDir = path.dirname(filePath);\n      const resolvedPath = path.resolve(fileDir, importPath);\n\n      // Compute relative path from the project root.\n      let relativeToRoot = path.relative(projectRoot, resolvedPath);\n      relativeToRoot = relativeToRoot.replace(/\\\\/g, '/');\n      const aliasPath = tryAliasMapping(relativeToRoot);\n      if (aliasPath) {\n        return aliasPath;\n      }\n\n      // Fallback: compute relative to the configured basePath.\n      let relativeToBase = path.relative(basePath, resolvedPath);\n      relativeToBase = relativeToBase.replace(/\\\\/g, '/');\n      if (!relativeToBase.startsWith('/')) {\n        relativeToBase = '/' + relativeToBase;\n      }\n      return relativeToBase;\n    }\n\n    return {\n      ImportDeclaration(node) {\n        if (node.source && typeof node.source.value === 'string') {\n          const importPath = node.source.value;\n          if (importPath.startsWith('.')) {\n            const fileName = context.getFilename();\n            const absolutePath = toAbsolute(importPath, fileName);\n            context.report({\n              node: node.source,\n              messageId: 'relativeImport',\n              data: { importPath, absolutePath },\n              fix(fixer) {\n                return fixer.replaceText(node.source, `'${absolutePath}'`);\n              },\n            });\n          }\n        }\n      },\n      // Optionally handle dynamic imports.\n      CallExpression(node) {\n        // For dynamic imports, node.callee is an Identifier with name 'import'\n        if (\n          // Check if this is a dynamic import\n          (node.callee as any).name === 'import' &&\n          node.arguments.length === 1 &&\n          node.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal &&\n          typeof node.arguments[0].value === 'string'\n        ) {\n          const importPath = node.arguments[0].value;\n          if (importPath.startsWith('.')) {\n            const fileName = context.getFilename();\n            const absolutePath = toAbsolute(importPath, fileName);\n            context.report({\n              node: node.arguments[0],\n              messageId: 'relativeImport',\n              data: { importPath, absolutePath },\n              fix(fixer) {\n                return fixer.replaceText(node.arguments[0], `'${absolutePath}'`);\n              },\n            });\n          }\n        }\n      },\n    };\n  },\n});\n","import { absoluteImports } from './absolute-imports.js';\n\nexport const rules = {\n  'absolute-imports': absoluteImports,\n};\n"],"mappings":"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","names":["fs","path","fs","path"]}