@bedrockio/eslint-plugin 1.4.9 → 1.5.0

package/src/resolvers/vite.js

@@ -0,0 +1,193 @@
+/**
+ * Patched Vite resolver for eslint-plugin-import.
+ *
+ * Based on `eslint-import-resolver-vite`:
+ * https://github.com/pzmosquito/eslint-import-resolver-vite
+ *
+ * The upstream resolver replaces every matching path segment when applying
+ * aliases. This breaks imports like `docs/components/...` when both `docs`
+ * and `components` are aliases, producing invalid paths.
+ *
+ * This version fixes the behavior so aliases only match the **leading prefix**
+ * of the import specifier, which matches how Vite/Rollup aliasing works.
+ *
+ * Additional improvements
+ * -----------------------
+ * - Supports both object and array alias forms used by Vite
+ * - Supports RegExp `find` entries in array aliases
+ * - Avoids rewriting absolute paths incorrectly
+ * - Cleans up root/publicDir resolution logic
+ *
+ */
+
+import path from 'node:path';
+import resolve from 'resolve';
+import createDebug from 'debug';
+import { existsSync } from 'node:fs';
+
+const namespace = 'eslint-plugin-import:resolver:vite';
+const log = createDebug(namespace);
+
+function loadViteConfig(config) {
+  if (!config) {
+    throw new Error("'config' option must be a path to a vite config file.");
+  }
+
+  const file = path.resolve(process.cwd(), config);
+
+  if (!existsSync(file)) {
+    return;
+  }
+
+  const mod = require(file);
+  return mod.default || mod;
+}
+
+function tryResolve(source, resolveOptions, label) {
+  log('resolving:\t', `(${label})`, source);
+  const resolvedPath = resolve.sync(source, resolveOptions);
+  log('resolved:\t', resolvedPath);
+  return { found: true, path: resolvedPath };
+}
+
+function normalizeAliasEntries(alias) {
+  if (!alias) {
+    return [];
+  }
+
+  if (Array.isArray(alias)) {
+    return alias.filter(Boolean).map((entry) => ({
+      find: entry.find,
+      replacement: entry.replacement,
+    }));
+  }
+
+  if (typeof alias === 'object') {
+    return Object.entries(alias).map(([find, replacement]) => ({
+      find,
+      replacement,
+    }));
+  }
+
+  throw new Error(
+    'The alias must be either an object, or an array of objects.',
+  );
+}
+
+function applyStringAlias(source, find, replacement) {
+  if (source === find) {
+    return replacement;
+  }
+
+  if (source.startsWith(find + '/')) {
+    return replacement + source.slice(find.length);
+  }
+
+  return null;
+}
+
+function processAlias(alias, source) {
+  const entries = normalizeAliasEntries(alias);
+
+  for (const { find, replacement } of entries) {
+    if (!find || !replacement) {
+      continue;
+    }
+
+    if (find instanceof RegExp) {
+      if (find.test(source)) {
+        return source.replace(find, replacement);
+      }
+      continue;
+    }
+
+    if (typeof find === 'string') {
+      const resolved = applyStringAlias(source, find, replacement);
+      if (resolved) {
+        return resolved;
+      }
+    }
+  }
+
+  return source;
+}
+
+function resolveRoot(root) {
+  if (!root) {
+    return process.cwd();
+  }
+
+  if (path.isAbsolute(root)) {
+    return root;
+  }
+
+  return path.resolve(process.cwd(), root);
+}
+
+export const interfaceVersion = 2;
+
+function resolveImport(source, file, config) {
+  log('\nin file:\t', file);
+
+  if (resolve.isCore(source)) {
+    log('resolved:\t', source);
+    return { found: true, path: null };
+  }
+
+  const viteConfig = loadViteConfig(config?.config);
+  if (!viteConfig) {
+    return { found: false };
+  }
+
+  const defaultExtensions = ['.mjs', '.js', '.ts', '.jsx', '.tsx', '.json'];
+  const viteResolve = viteConfig.resolve || {};
+  const extensions = viteResolve.extensions || defaultExtensions;
+  const resolveOptions = {
+    basedir: path.dirname(file),
+    extensions,
+  };
+
+  try {
+    return tryResolve(source, resolveOptions, 'as is');
+  } catch {}
+
+  const parsedSource = processAlias(viteResolve.alias, source);
+  if (parsedSource !== source) {
+    try {
+      return tryResolve(parsedSource, resolveOptions, 'with alias');
+    } catch {}
+  }
+
+  if (path.isAbsolute(parsedSource)) {
+    try {
+      return tryResolve(parsedSource, resolveOptions, 'absolute path');
+    } catch {}
+  }
+
+  if (viteConfig.publicDir !== false) {
+    const rootDir = resolveRoot(viteConfig.root);
+    const publicDir = viteConfig.publicDir || 'public';
+    const publicBase = path.isAbsolute(publicDir)
+      ? publicDir
+      : path.resolve(rootDir, publicDir);
+
+    const publicSource = path.resolve(publicBase, parsedSource);
+
+    try {
+      return tryResolve(publicSource, resolveOptions, 'in public directory');
+    } catch {}
+  }
+
+  log('ERROR:\t', 'Unable to resolve');
+  return { found: false };
+}
+
+export function createViteImportResolver(config) {
+  return {
+    interfaceVersion: 3,
+    name: 'eslint-import-resolver-vite',
+    resolve: (source, file) => resolveImport(source, file, config),
+  };
+}
+
+export { resolveImport as resolve };

package/src/typescript.js

@@ -1,33 +1,30 @@
-let ts;
-let importError;
-
-try {
-  // This is to make this package optional.
-  ts = await import('typescript-eslint');
-} catch (err) {
-  // Package not installed. Capture error to
-  // allow re-throwing if plugin is accessed,
-  // otherwise allow it to export silently.
-  importError = err;
-}
+import ts from 'typescript-eslint';
 
 export default {
+  name: 'typescript',
   files: ['**/*.{ts,tsx}'],
   ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
   languageOptions: {
-    parser: ts?.parser,
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    parser: ts.parser,
   },
-  get plugins() {
-    if (importError) {
-      throw importError;
-    }
-    return {
-      '@typescript-eslint': ts?.plugin,
-    };
+  plugins: {
+    '@typescript-eslint': ts.plugin,
   },
   rules: {
-    ...ts?.plugin.configs.recommended.rules,
+    // Pull in `eslint-recommended` adjustments from typescript-eslint.
+    // This disables core ESLint rules that conflict with TypeScript (e.g. no-undef).
+    ...ts.plugin.configs['eslint-recommended'].overrides[0].rules,
+
+    // Pull in the TypeScript recommended rules themselves.
+    // Avoid the flat config version as it's an array.
+    ...ts.plugin.configs.recommended.rules,
     '@typescript-eslint/no-unused-vars': 'warn',
     '@typescript-eslint/no-explicit-any': 'off',
+
+    // The above configs try to slip this rule in there despite it
+    // not being part of eslint-recommended so force it off again.
+    'prefer-const': 'off',
   },
 };

package/src/vite.js

@@ -0,0 +1,23 @@
+import globals from 'globals';
+
+export default {
+  name: 'vite',
+  files: ['**/*.{js,jsx,ts,tsx,mdx}'],
+  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
+  languageOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    globals: globals.browser,
+  },
+  settings: {
+    'import/resolver': {
+      exports: true,
+      ['@bedrockio/eslint-plugin/resolvers/vite']: {
+        config: './vite.config.js',
+      },
+      node: {
+        moduleDirectory: ['node_modules', 'src'],
+      },
+    },
+  },
+};

package/src/{webpack-imports.js → webpack.js}

@@ -1,17 +1,15 @@
-import * as plugin from 'eslint-plugin-import';
-import importRules from './importRules.js';
+import globals from 'globals';
 
 export default {
-  ...plugin.flatConfigs.recommended,
-  files: ['**/*.{js,jsx,ts,tsx}'],
+  name: 'webpack',
+  files: ['**/*.{js,jsx,ts,tsx,mdx}'],
   ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
   languageOptions: {
     ecmaVersion: 'latest',
     sourceType: 'module',
+    globals: globals.browser,
   },
   rules: {
-    ...plugin.flatConfigs.recommended.rules,
-    ...importRules,
     'import/no-unresolved': [
       'warn',
       {

package/dist/cjs/importRules.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = exports.default = {
-  'import/no-unresolved': 'warn',
-  'import/no-named-as-default-member': 'off',
-  'import/first': 'warn',
-  'import/order': ['warn', {
-    'newlines-between': 'always-and-inside-groups',
-    sortTypesGroup: true,
-    alphabetize: {
-      order: 'asc',
-      caseInsensitive: false
-    },
-    named: true,
-    warnOnUnassignedImports: true,
-    consolidateIslands: 'inside-groups',
-    groups: ['builtin', 'unknown', 'external', 'internal', ['parent', 'sibling'], 'index', 'object', 'type'],
-    pathGroups: [{
-      pattern: 'semantic',
-      group: 'external'
-    }, {
-      pattern: '+(stores|helpers|layouts|@stores|@helpers|@layouts){,/**}',
-      group: 'internal',
-      position: 'before'
-    }, {
-      pattern: '+(screens|modals|components|@screens|@modals|@components){,/**}',
-      group: 'internal'
-    }, {
-      pattern: '+(hooks|@hooks|utils|@utils){,/**}',
-      group: 'internal',
-      position: 'after'
-    }, {
-      pattern: '+(assets|@assets){,**}',
-      group: 'sibling',
-      position: 'after'
-    }, {
-      pattern: '**/*.+(css|less|scss|png|jpg|svg|json)',
-      group: 'type',
-      position: 'after'
-    }, {
-      pattern: './**/*.+(css|less|scss|png|jpg|svg|json)',
-      group: 'type',
-      position: 'after'
-    }]
-  }]
-};

package/dist/cjs/node-imports.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var plugin = _interopRequireWildcard(require("eslint-plugin-import"));
-var _importRules = _interopRequireDefault(require("./importRules.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-var _default = exports.default = {
-  ...plugin.flatConfigs.recommended,
-  files: ['**/*.{js,jsx}'],
-  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
-  languageOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module'
-  },
-  rules: {
-    ..._importRules.default
-  },
-  settings: {
-    'import/resolver': {
-      exports: true,
-      node: {
-        moduleDirectory: ['node_modules', 'src'],
-        extensions: ['.js', '.jsx', '.ts', '.tsx', '.json', '.css', '.less', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.webm', '.mp4']
-      }
-    }
-  }
-};

package/dist/cjs/vite-imports.js

@@ -1,47 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _path = _interopRequireDefault(require("path"));
-var plugin = _interopRequireWildcard(require("eslint-plugin-import"));
-var _importRules = _interopRequireDefault(require("./importRules.js"));
-var _fs = require("fs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-async function loadConfig() {
-  const file = _path.default.join(process.cwd(), 'vite.config.js');
-  if (!(0, _fs.existsSync)(file)) {
-    // This file will be imported from index.js so
-    // bail if no vite.config.js file exists.
-    return;
-  }
-  const module = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(file);
-  return module.default;
-}
-const viteConfig = await loadConfig();
-var _default = exports.default = {
-  ...plugin.flatConfigs.recommended,
-  files: ['**/*.{js,jsx,ts,tsx}'],
-  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
-  languageOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module'
-  },
-  rules: {
-    ...plugin.flatConfigs.recommended.rules,
-    ..._importRules.default
-  },
-  settings: {
-    'import/resolver': {
-      exports: true,
-      vite: {
-        viteConfig
-      },
-      node: {
-        moduleDirectory: ['node_modules', 'src']
-      }
-    }
-  }
-};

package/dist/cjs/webpack-imports.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var plugin = _interopRequireWildcard(require("eslint-plugin-import"));
-var _importRules = _interopRequireDefault(require("./importRules.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-var _default = exports.default = {
-  ...plugin.flatConfigs.recommended,
-  files: ['**/*.{js,jsx,ts,tsx}'],
-  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
-  languageOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module'
-  },
-  rules: {
-    ...plugin.flatConfigs.recommended.rules,
-    ..._importRules.default,
-    'import/no-unresolved': ['warn', {
-      // package.json "style" may be used here which
-      // will resolve for webpack but not within the
-      // eslint plugin
-      ignore: ['\\.css$']
-    }]
-  },
-  settings: {
-    'import/resolver': {
-      webpack: {
-        config: './webpack.config.js'
-      },
-      node: {
-        moduleDirectory: ['node_modules', 'src']
-      }
-    }
-  }
-};

package/src/importRules.js

@@ -1,65 +0,0 @@
-export default {
-  'import/no-unresolved': 'warn',
-  'import/no-named-as-default-member': 'off',
-  'import/first': 'warn',
-  'import/order': [
-    'warn',
-    {
-      'newlines-between': 'always-and-inside-groups',
-      sortTypesGroup: true,
-      alphabetize: {
-        order: 'asc',
-        caseInsensitive: false,
-      },
-      named: true,
-      warnOnUnassignedImports: true,
-      consolidateIslands: 'inside-groups',
-      groups: [
-        'builtin',
-        'unknown',
-        'external',
-        'internal',
-        ['parent', 'sibling'],
-        'index',
-        'object',
-        'type',
-      ],
-      pathGroups: [
-        {
-          pattern: 'semantic',
-          group: 'external',
-        },
-        {
-          pattern: '+(stores|helpers|layouts|@stores|@helpers|@layouts){,/**}',
-          group: 'internal',
-          position: 'before',
-        },
-        {
-          pattern:
-            '+(screens|modals|components|@screens|@modals|@components){,/**}',
-          group: 'internal',
-        },
-        {
-          pattern: '+(hooks|@hooks|utils|@utils){,/**}',
-          group: 'internal',
-          position: 'after',
-        },
-        {
-          pattern: '+(assets|@assets){,**}',
-          group: 'sibling',
-          position: 'after',
-        },
-        {
-          pattern: '**/*.+(css|less|scss|png|jpg|svg|json)',
-          group: 'type',
-          position: 'after',
-        },
-        {
-          pattern: './**/*.+(css|less|scss|png|jpg|svg|json)',
-          group: 'type',
-          position: 'after',
-        },
-      ],
-    },
-  ],
-};

package/src/vite-imports.js

@@ -1,45 +0,0 @@
-import path from 'path';
-import * as plugin from 'eslint-plugin-import';
-import importRules from './importRules.js';
-import { existsSync } from 'fs';
-
-async function loadConfig() {
-  const file = path.join(process.cwd(), 'vite.config.js');
-
-  if (!existsSync(file)) {
-    // This file will be imported from index.js so
-    // bail if no vite.config.js file exists.
-    return;
-  }
-
-  const module = await import(file);
-
-  return module.default;
-}
-
-const viteConfig = await loadConfig();
-
-export default {
-  ...plugin.flatConfigs.recommended,
-  files: ['**/*.{js,jsx,ts,tsx}'],
-  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
-  languageOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-  },
-  rules: {
-    ...plugin.flatConfigs.recommended.rules,
-    ...importRules,
-  },
-  settings: {
-    'import/resolver': {
-      exports: true,
-      vite: {
-        viteConfig,
-      },
-      node: {
-        moduleDirectory: ['node_modules', 'src'],
-      },
-    },
-  },
-};