@bedrockio/eslint-plugin 1.4.9 → 1.5.0

package/dist/esm/react.js

@@ -0,0 +1,37 @@
+import react from 'eslint-plugin-react';
+export default {
+  name: 'react',
+  files: ['**/*.{js,jsx,ts,tsx,mdx}'],
+  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
+  plugins: {
+    react
+  },
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true
+      }
+    }
+  },
+  rules: {
+    ...react.configs['recommended'].rules,
+    ...react.configs['jsx-runtime'].rules,
+    'no-console': 'warn',
+    'react/prop-types': 'off',
+    'react/display-name': 'off',
+    'react/no-unescaped-entities': ['error', {
+      forbid: [{
+        char: '>',
+        alternatives: ['>']
+      }, {
+        char: '<',
+        alternatives: ['&lt;']
+      }]
+    }]
+  },
+  settings: {
+    react: {
+      version: 'detect'
+    }
+  }
+};

package/dist/esm/recommended.js

@@ -0,0 +1,17 @@
+import js from '@eslint/js';
+export default {
+  name: 'recommended',
+  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
+  languageOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module'
+  },
+  rules: {
+    ...js.configs.recommended.rules,
+    'no-console': 'warn',
+    curly: ['error', 'multi-line', 'consistent'],
+    'no-unused-vars': ['warn', {
+      ignoreRestSiblings: true
+    }]
+  }
+};

package/dist/esm/resolvers/vite.js

@@ -0,0 +1,167 @@
+/**
+ * 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/dist/esm/typescript.js

@@ -0,0 +1,27 @@
+import ts from 'typescript-eslint';
+export default {
+  name: 'typescript',
+  files: ['**/*.{ts,tsx}'],
+  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
+  languageOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    parser: ts.parser
+  },
+  plugins: {
+    '@typescript-eslint': ts.plugin
+  },
+  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/dist/esm/vite.js

@@ -0,0 +1,22 @@
+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/dist/esm/webpack.js

@@ -0,0 +1,29 @@
+import globals from 'globals';
+export default {
+  name: 'webpack',
+  files: ['**/*.{js,jsx,ts,tsx,mdx}'],
+  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
+  languageOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    globals: globals.browser
+  },
+  rules: {
+    '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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/eslint-plugin",
-  "version": "1.4.9",
+  "version": "1.5.0",
   "description": "Common ESLint plugin for Bedrock projects.",
   "license": "MIT",
   "type": "module",
@@ -16,8 +16,14 @@
   "main": "./dist/cjs/index.js",
   "module": "./src/index.js",
   "exports": {
-    "import": "./src/index.js",
-    "require": "./dist/cjs/index.js"
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./resolvers/vite": {
+      "import": "./dist/esm/resolvers/vite.js",
+      "require": "./dist/cjs/resolvers/vite.js"
+    }
   },
   "dependencies": {
     "@eslint/js": "^10.0.1",
@@ -28,7 +34,8 @@
     "eslint-plugin-jest": "^29.15.0",
     "eslint-plugin-mdx": "^3.7.0",
     "eslint-plugin-react": "^7.37.5",
-    "globals": "^17.3.0"
+    "globals": "^17.3.0",
+    "typescript-eslint": "^8.57.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.28.6",
@@ -36,20 +43,15 @@
     "@babel/preset-env": "^7.29.0",
     "@bedrockio/prettier-config": "^1.1.1",
     "eslint": "^9.39.2",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.55.0"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "eslint": ">=9",
-    "eslint-import-resolver-webpack": "^0.13.10",
-    "typescript-eslint": "^8.55.0"
+    "eslint-import-resolver-webpack": "^0.13.10"
   },
   "peerDependenciesMeta": {
     "eslint-import-resolver-webpack": {
       "optional": true
-    },
-    "typescript-eslint": {
-      "optional": true
     }
   },
   "prettier": "@bedrockio/prettier-config",

package/src/imports.js

@@ -0,0 +1,79 @@
+import * as plugin from 'eslint-plugin-import';
+
+export default {
+  ...plugin.flatConfigs.recommended,
+  name: 'imports',
+  ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
+  languageOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+  },
+  rules: {
+    ...plugin.flatConfigs.recommended.rules,
+    'import/namespace': 'off',
+    '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/index.js

@@ -3,17 +3,19 @@ import { default as react } from './react.js';
 import { default as jest } from './jest.js';
 import { default as mdx } from './mdx.js';
 import { default as typescript } from './typescript.js';
-import { default as nodeImports } from './node-imports.js';
-import { default as viteImports } from './vite-imports.js';
-import { default as webpackImports } from './webpack-imports.js';
+import { default as node } from './node.js';
+import { default as vite } from './vite.js';
+import { default as webpack } from './webpack.js';
+import { default as imports } from './imports.js';
 
 export {
   mdx,
   jest,
   react,
+  node,
+  vite,
+  webpack,
+  imports,
   typescript,
   recommended,
-  nodeImports,
-  viteImports,
-  webpackImports,
 };

package/src/jest.js

@@ -2,8 +2,7 @@ import plugin from 'eslint-plugin-jest';
 
 export default {
   ...plugin.configs['flat/recommended'],
-
-  files: ['**/*.{js,jsx,ts,tsx}'],
+  name: 'jest',
   files: [
     '**/test*/**/*.{js,jsx,ts,tsx}',
     '**/__tests__/**/*.{js,jsx,ts,tsx}',

package/src/mdx.js

@@ -2,6 +2,7 @@ import * as mdx from 'eslint-plugin-mdx';
 
 const plugin = {
   ...mdx.flat,
+  name: 'mdx',
   files: ['**/*.mdx'],
   ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
   processor: mdx.createRemarkProcessor({
@@ -9,8 +10,9 @@ const plugin = {
   }),
   rules: {
     ...mdx.flat.rules,
-    semi: 'off',
-    'no-undef': 'off',
+    // Note this seems to be causing
+    // issues in the resolve so disable it.
+    'import/named': 'off',
     'no-unused-expressions': 'off',
   },
 };

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

@@ -1,16 +1,15 @@
-import * as plugin from 'eslint-plugin-import';
-import importRules from './importRules.js';
+import globals from 'globals';
 
 export default {
-  ...plugin.flatConfigs.recommended,
+  name: 'node',
   files: ['**/*.{js,jsx}'],
   ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
   languageOptions: {
     ecmaVersion: 'latest',
     sourceType: 'module',
   },
-  rules: {
-    ...importRules,
+  languageOptions: {
+    globals: globals.node,
   },
   settings: {
     'import/resolver': {

package/src/react.js

@@ -1,7 +1,8 @@
 import react from 'eslint-plugin-react';
 
 export default {
-  files: ['**/*.{js,jsx,ts,tsx}'],
+  name: 'react',
+  files: ['**/*.{js,jsx,ts,tsx,mdx}'],
   ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
   plugins: {
     react,

package/src/recommended.js

@@ -1,20 +1,14 @@
 import js from '@eslint/js';
-import globals from 'globals';
 
 export default {
-  files: ['**/*.{js,jsx}'],
+  name: 'recommended',
   ignores: ['node_modules/**/*', '**/dist/**/*', '**/*.d.ts'],
   languageOptions: {
     ecmaVersion: 'latest',
     sourceType: 'module',
-    globals: {
-      ...globals.node,
-      ...globals.browser,
-    },
   },
   rules: {
     ...js.configs.recommended.rules,
-    semi: 'error',
     'no-console': 'warn',
     curly: ['error', 'multi-line', 'consistent'],
     'no-unused-vars': [