@plugjs/eslint-plugin 0.2.1 → 0.2.3

package/bundles/eslint-plugin-import-x.cjs

@@ -180,7 +180,7 @@ var require_package = __commonJS({
   "node_modules/eslint-plugin-import-x/package.json"(exports2, module2) {
     module2.exports = {
       name: "eslint-plugin-import-x",
-      version: "0.5.2",
+      version: "3.0.0",
       description: "Import with sanity.",
       repository: "git+https://github.com/un-ts/eslint-plugin-import-x",
       author: "JounQin <admin@1stg.me> (https://www.1stG.me)",
@@ -236,6 +236,7 @@ var require_package = __commonJS({
         "is-glob": "^4.0.3",
         minimatch: "^9.0.3",
         semver: "^7.6.0",
+        "stable-hash": "^0.0.4",
         tslib: "^2.6.2"
       },
       devDependencies: {
@@ -964,6 +965,7 @@ var require_export_map = __commonJS({
     var doctrine_1 = tslib_12.__importDefault(require("doctrine"));
     var eslint_1 = require("eslint");
     var get_tsconfig_1 = require("get-tsconfig");
+    var stable_hash_1 = tslib_12.__importDefault(require("stable-hash"));
     var get_value_1 = require_get_value();
     var hash_1 = require_hash();
     var ignore_1 = require_ignore();
@@ -1621,29 +1623,28 @@ var require_export_map = __commonJS({
       }
     }
     exports2.recursivePatternCapture = recursivePatternCapture;
-    var parserOptionsHash = "";
-    var prevParserOptions = "";
-    var settingsHash = "";
-    var prevSettings = "";
     function childContext(path, context) {
-      const { settings, parserOptions, parserPath } = context;
-      if (JSON.stringify(settings) !== prevSettings) {
-        settingsHash = (0, hash_1.hashObject)({ settings }).digest("hex");
-        prevSettings = JSON.stringify(settings);
-      }
-      if (JSON.stringify(parserOptions) !== prevParserOptions) {
-        parserOptionsHash = (0, hash_1.hashObject)({ parserOptions }).digest("hex");
-        prevParserOptions = JSON.stringify(parserOptions);
-      }
+      const { settings, parserOptions, parserPath, languageOptions } = context;
       return {
-        cacheKey: String(parserPath) + parserOptionsHash + settingsHash + String(path),
+        cacheKey: makeContextCacheKey(context) + String(path),
         settings,
         parserOptions,
         parserPath,
+        languageOptions,
         path,
         filename: "physicalFilename" in context ? context.physicalFilename : context.filename
       };
     }
+    function makeContextCacheKey(context) {
+      var _a, _b, _c;
+      const { settings, parserPath, parserOptions, languageOptions } = context;
+      let hash = (0, stable_hash_1.default)(settings) + (0, stable_hash_1.default)((_a = languageOptions === null || languageOptions === void 0 ? void 0 : languageOptions.parserOptions) !== null && _a !== void 0 ? _a : parserOptions);
+      if (languageOptions) {
+        hash += String(languageOptions.ecmaVersion) + String(languageOptions.sourceType);
+      }
+      hash += (0, stable_hash_1.default)((_c = parserPath !== null && parserPath !== void 0 ? parserPath : (_b = languageOptions === null || languageOptions === void 0 ? void 0 : languageOptions.parser) === null || _b === void 0 ? void 0 : _b.meta) !== null && _c !== void 0 ? _c : languageOptions === null || languageOptions === void 0 ? void 0 : languageOptions.parser);
+      return hash;
+    }
     function makeSourceCode(text, ast) {
       if (eslint_1.SourceCode.length > 1) {
         return new eslint_1.SourceCode(text, ast);
@@ -2295,6 +2296,7 @@ var require_dynamic_import_chunkname = __commonJS({
           category: "Style guide",
           description: "Enforce a leading comment with the webpackChunkName for dynamic imports."
         },
+        hasSuggestions: true,
         schema: [
           {
             type: "object",
@@ -2320,16 +2322,21 @@ var require_dynamic_import_chunkname = __commonJS({
           blockComment: "dynamic imports require a /* foo */ style comment, not a // foo comment",
           paddedSpaces: "dynamic imports require a block comment padded with spaces - /* foo */",
           webpackComment: 'dynamic imports require a "webpack" comment with valid syntax',
-          chunknameFormat: "dynamic imports require a leading comment in the form /*{{format}}*/"
+          chunknameFormat: "dynamic imports require a leading comment in the form /* {{format}} */",
+          webpackEagerModeNoChunkName: "dynamic imports using eager mode do not need a webpackChunkName",
+          webpackRemoveEagerMode: "Remove webpackMode",
+          webpackRemoveChunkName: "Remove webpackChunkName"
         }
       },
       defaultOptions: [],
       create(context) {
         const { importFunctions = [], allowEmpty = false, webpackChunknameFormat = "([0-9a-zA-Z-_/.]|\\[(request|index)\\])+" } = context.options[0] || {};
         const paddedCommentRegex = /^ (\S[\S\s]+\S) $/;
-        const commentStyleRegex = /^( ((webpackChunkName: .+)|((webpackPrefetch|webpackPreload): (true|false|-?\d+))|(webpackIgnore: (true|false))|((webpackInclude|webpackExclude): \/.*\/)|(webpackMode: ["'](lazy|lazy-once|eager|weak)["'])|(webpackExports: (["']\w+["']|\[(["']\w+["'], *)+(["']\w+["']*)]))),?)+ $/;
-        const chunkSubstrFormat = ` webpackChunkName: ["']${webpackChunknameFormat}["'],? `;
+        const commentStyleRegex = /^( (((webpackChunkName|webpackFetchPriority): .+)|((webpackPrefetch|webpackPreload): (true|false|-?\d+))|(webpackIgnore: (true|false))|((webpackInclude|webpackExclude): \/.+\/)|(webpackMode: ["'](lazy|lazy-once|eager|weak)["'])|(webpackExports: (["']\w+["']|\[(["']\w+["'], *)+(["']\w+["']*)]))),?)+ $/;
+        const chunkSubstrFormat = `webpackChunkName: ["']${webpackChunknameFormat}["'],?`;
         const chunkSubstrRegex = new RegExp(chunkSubstrFormat);
+        const eagerModeFormat = `webpackMode: ["']eager["'],?`;
+        const eagerModeRegex = new RegExp(eagerModeFormat);
         function run(node, arg) {
           const { sourceCode } = context;
           const leadingComments = sourceCode.getCommentsBefore(arg);
@@ -2341,6 +2348,7 @@ var require_dynamic_import_chunkname = __commonJS({
             return;
           }
           let isChunknamePresent = false;
+          let isEagerModePresent = false;
           for (const comment of leadingComments) {
             if (comment.type !== "Block") {
               context.report({
@@ -2372,11 +2380,60 @@ var require_dynamic_import_chunkname = __commonJS({
               });
               return;
             }
+            if (eagerModeRegex.test(comment.value)) {
+              isEagerModePresent = true;
+            }
             if (chunkSubstrRegex.test(comment.value)) {
               isChunknamePresent = true;
             }
           }
-          if (!isChunknamePresent && !allowEmpty) {
+          const removeCommentsAndLeadingSpaces = (fixer, comment) => {
+            const leftToken = sourceCode.getTokenBefore(comment);
+            const leftComments = sourceCode.getCommentsBefore(comment);
+            if (leftToken) {
+              if (leftComments.length > 0) {
+                return fixer.removeRange([
+                  Math.max(leftToken.range[1], leftComments[leftComments.length - 1].range[1]),
+                  comment.range[1]
+                ]);
+              }
+              return fixer.removeRange([leftToken.range[1], comment.range[1]]);
+            }
+            return fixer.remove(comment);
+          };
+          if (isChunknamePresent && isEagerModePresent) {
+            context.report({
+              node,
+              messageId: "webpackEagerModeNoChunkName",
+              suggest: [
+                {
+                  messageId: "webpackRemoveChunkName",
+                  fix(fixer) {
+                    for (const comment of leadingComments) {
+                      if (chunkSubstrRegex.test(comment.value)) {
+                        const replacement = comment.value.replace(chunkSubstrRegex, "").trim().replace(/,$/, "");
+                        return replacement === "" ? removeCommentsAndLeadingSpaces(fixer, comment) : fixer.replaceText(comment, `/* ${replacement} */`);
+                      }
+                    }
+                    return null;
+                  }
+                },
+                {
+                  messageId: "webpackRemoveEagerMode",
+                  fix(fixer) {
+                    for (const comment of leadingComments) {
+                      if (eagerModeRegex.test(comment.value)) {
+                        const replacement = comment.value.replace(eagerModeRegex, "").trim().replace(/,$/, "");
+                        return replacement === "" ? removeCommentsAndLeadingSpaces(fixer, comment) : fixer.replaceText(comment, `/* ${replacement} */`);
+                      }
+                    }
+                    return null;
+                  }
+                }
+              ]
+            });
+          }
+          if (!isChunknamePresent && !allowEmpty && !isEagerModePresent) {
             context.report({
               node,
               messageId: "chunknameFormat",
@@ -4387,6 +4444,27 @@ var require_no_deprecated = __commonJS({
   }
 });
 
+// node_modules/eslint-plugin-import-x/lib/utils/lazy-value.js
+var require_lazy_value = __commonJS({
+  "node_modules/eslint-plugin-import-x/lib/utils/lazy-value.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.lazy = void 0;
+    var lazy = (cb) => {
+      let isCalled = false;
+      let result;
+      return () => {
+        if (!isCalled) {
+          isCalled = true;
+          result = cb();
+        }
+        return result;
+      };
+    };
+    exports2.lazy = lazy;
+  }
+});
+
 // node_modules/eslint-plugin-import-x/lib/rules/no-duplicates.js
 var require_no_duplicates = __commonJS({
   "node_modules/eslint-plugin-import-x/lib/rules/no-duplicates.js"(exports2, module2) {
@@ -4394,69 +4472,67 @@ var require_no_duplicates = __commonJS({
     var tslib_12 = require("tslib");
     var semver_1 = tslib_12.__importDefault(require("semver"));
     var utils_1 = require_utils();
-    var typescriptPkg;
-    try {
-      typescriptPkg = require("typescript/package.json");
-    } catch (_a) {
-    }
+    var lazy_value_1 = require_lazy_value();
+    var isTypeScriptVersionSupportPreferInline = (0, lazy_value_1.lazy)(() => {
+      let typescriptPkg;
+      try {
+        typescriptPkg = require("typescript/package.json");
+      } catch (_a) {
+      }
+      return !typescriptPkg || !semver_1.default.satisfies(typescriptPkg.version, ">= 4.5");
+    });
     function checkImports(imported, context) {
-      for (const [module3, nodes] of imported.entries()) {
-        if (nodes.length > 1) {
-          const [first, ...rest] = nodes;
-          const { sourceCode } = context;
-          const fix = getFix(first, rest, sourceCode, context);
+      imported.forEach((nodes, module3) => {
+        if (nodes.length <= 1) {
+          return;
+        }
+        for (let i = 0, len = nodes.length; i < len; i++) {
+          const node = nodes[i];
           context.report({
-            node: first.source,
+            node: node.source,
             messageId: "duplicate",
             data: {
               module: module3
             },
-            fix
+            fix: i === 0 ? getFix(nodes, context.sourceCode, context) : null
           });
-          for (const node of rest) {
-            context.report({
-              node: node.source,
-              messageId: "duplicate",
-              data: {
-                module: module3
-              }
-            });
-          }
         }
-      }
+      });
     }
-    function getFix(first, rest, sourceCode, context) {
-      if (typeof sourceCode.getCommentsBefore !== "function") {
-        return;
-      }
+    function getFix(nodes, sourceCode, context) {
+      const first = nodes[0];
       if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) {
-        return;
+        return null;
       }
-      const defaultImportNames = new Set([first, ...rest].flatMap((x) => getDefaultImportName(x) || []));
+      const defaultImportNames = new Set(nodes.flatMap((x) => getDefaultImportName(x) || []));
       if (defaultImportNames.size > 1) {
-        return;
+        return null;
       }
-      const restWithoutComments = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));
-      const specifiers = restWithoutComments.map((node) => {
+      const rest = nodes.slice(1);
+      const restWithoutCommentsAndNamespaces = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));
+      const restWithoutCommentsAndNamespacesHasSpecifiers = restWithoutCommentsAndNamespaces.map(hasSpecifiers);
+      const specifiers = restWithoutCommentsAndNamespaces.reduce((acc, node, nodeIndex) => {
         const tokens = sourceCode.getTokens(node);
         const openBrace = tokens.find((token) => isPunctuator(token, "{"));
         const closeBrace = tokens.find((token) => isPunctuator(token, "}"));
         if (openBrace == null || closeBrace == null) {
-          return;
+          return acc;
         }
-        return {
+        acc.push({
           importNode: node,
           identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(","),
-          isEmpty: !hasSpecifiers(node)
-        };
-      }).filter(Boolean);
-      const unnecessaryImports = restWithoutComments.filter((node) => !hasSpecifiers(node) && !hasNamespace(node) && !specifiers.some((specifier) => "importNode" in specifier && specifier.importNode === node));
-      const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;
+          isEmpty: !restWithoutCommentsAndNamespacesHasSpecifiers[nodeIndex]
+        });
+        return acc;
+      }, []);
+      const unnecessaryImports = restWithoutCommentsAndNamespaces.filter((node, nodeIndex) => !restWithoutCommentsAndNamespacesHasSpecifiers[nodeIndex] && !specifiers.some((specifier) => specifier.importNode === node));
       const shouldAddSpecifiers = specifiers.length > 0;
       const shouldRemoveUnnecessary = unnecessaryImports.length > 0;
-      if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) {
-        return;
+      const shouldAddDefault = (0, lazy_value_1.lazy)(() => getDefaultImportName(first) == null && defaultImportNames.size === 1);
+      if (!shouldAddSpecifiers && !shouldRemoveUnnecessary && !shouldAddDefault()) {
+        return null;
       }
+      const preferInline = context.options[0] && context.options[0]["prefer-inline"];
       return (fixer) => {
         const tokens = sourceCode.getTokens(first);
         const openBrace = tokens.find((token) => isPunctuator(token, "{"));
@@ -4468,8 +4544,7 @@ var require_no_duplicates = __commonJS({
         const firstExistingIdentifiers = firstIsEmpty ? /* @__PURE__ */ new Set() : new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(",").map((x) => x.trim()));
         const [specifiersText] = specifiers.reduce(([result, needsComma, existingIdentifiers], specifier) => {
           const isTypeSpecifier = "importNode" in specifier && specifier.importNode.importKind === "type";
-          const preferInline = context.options[0] && context.options[0]["prefer-inline"];
-          if (preferInline && (!typescriptPkg || !semver_1.default.satisfies(typescriptPkg.version, ">= 4.5"))) {
+          if (preferInline && isTypeScriptVersionSupportPreferInline()) {
             throw new Error("Your version of TypeScript does not support inline type imports.");
           }
           const [specifierText, updatedExistingIdentifiers] = specifier.identifiers.reduce(([text, set], cur) => {
@@ -4490,22 +4565,22 @@ var require_no_duplicates = __commonJS({
           ];
         }, ["", !firstHasTrailingComma && !firstIsEmpty, firstExistingIdentifiers]);
         const fixes = [];
-        if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {
+        if (openBrace == null && shouldAddSpecifiers && shouldAddDefault()) {
           fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`));
-        } else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {
+        } else if (openBrace == null && !shouldAddSpecifiers && shouldAddDefault()) {
           fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));
-        } else if (shouldAddDefault && openBrace != null && closeBrace != null) {
+        } else if (openBrace != null && closeBrace != null && shouldAddDefault()) {
           fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));
           if (shouldAddSpecifiers) {
             fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
           }
-        } else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {
+        } else if (openBrace == null && shouldAddSpecifiers && !shouldAddDefault()) {
           if (first.specifiers.length === 0) {
             fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));
           } else {
             fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));
           }
-        } else if (!shouldAddDefault && openBrace != null && closeBrace != null) {
+        } else if (openBrace != null && closeBrace != null && !shouldAddDefault()) {
           fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
         }
         for (const specifier of specifiers) {
@@ -4536,15 +4611,13 @@ var require_no_duplicates = __commonJS({
     }
     function getDefaultImportName(node) {
       const defaultSpecifier = node.specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
-      return defaultSpecifier == null ? void 0 : defaultSpecifier.local.name;
+      return defaultSpecifier === null || defaultSpecifier === void 0 ? void 0 : defaultSpecifier.local.name;
     }
     function hasNamespace(node) {
-      const specifiers = node.specifiers.filter((specifier) => specifier.type === "ImportNamespaceSpecifier");
-      return specifiers.length > 0;
+      return node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier");
     }
     function hasSpecifiers(node) {
-      const specifiers = node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
-      return specifiers.length > 0;
+      return node.specifiers.some((specifier) => specifier.type === "ImportSpecifier");
     }
     function hasProblematicComments(node, sourceCode) {
       return hasCommentBefore(node, sourceCode) || hasCommentAfter(node, sourceCode) || hasCommentInsideNonSpecifiers(node, sourceCode);
@@ -4594,8 +4667,9 @@ var require_no_duplicates = __commonJS({
       },
       defaultOptions: [],
       create(context) {
-        var _a;
-        const considerQueryStringOption = (_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.considerQueryString;
+        var _a, _b;
+        const preferInline = (_a = context.options[0]) === null || _a === void 0 ? void 0 : _a["prefer-inline"];
+        const considerQueryStringOption = (_b = context.options[0]) === null || _b === void 0 ? void 0 : _b.considerQueryString;
         const defaultResolver = (sourcePath) => (0, utils_1.resolve)(sourcePath, context) || sourcePath;
         const resolver = considerQueryStringOption ? (sourcePath) => {
           const parts = sourcePath.match(/^([^?]*)\?(.*)$/);
@@ -4606,18 +4680,19 @@ var require_no_duplicates = __commonJS({
         } : defaultResolver;
         const moduleMaps = /* @__PURE__ */ new Map();
         function getImportMap(n) {
-          var _a2;
           const parent = n.parent;
-          if (!moduleMaps.has(parent)) {
-            moduleMaps.set(parent, {
+          let map;
+          if (moduleMaps.has(parent)) {
+            map = moduleMaps.get(parent);
+          } else {
+            map = {
               imported: /* @__PURE__ */ new Map(),
               nsImported: /* @__PURE__ */ new Map(),
               defaultTypesImported: /* @__PURE__ */ new Map(),
               namedTypesImported: /* @__PURE__ */ new Map()
-            });
+            };
+            moduleMaps.set(parent, map);
           }
-          const map = moduleMaps.get(parent);
-          const preferInline = (_a2 = context.options[0]) === null || _a2 === void 0 ? void 0 : _a2["prefer-inline"];
           if (!preferInline && n.importKind === "type") {
             return n.specifiers.length > 0 && n.specifiers[0].type === "ImportDefaultSpecifier" ? map.defaultTypesImported : map.namedTypesImported;
           }
@@ -4863,8 +4938,11 @@ var require_no_extraneous_dependencies = __commonJS({
     }
     function getPackageDepFields(packageJsonPath, throwAtRead) {
       if (!depFieldCache.has(packageJsonPath)) {
-        const depFields = extractDepFields(readJSON(packageJsonPath, throwAtRead));
-        depFieldCache.set(packageJsonPath, depFields);
+        const packageJson = readJSON(packageJsonPath, throwAtRead);
+        if (packageJson) {
+          const depFields = extractDepFields(packageJson);
+          depFieldCache.set(packageJsonPath, depFields);
+        }
       }
       return depFieldCache.get(packageJsonPath);
     }
@@ -4884,10 +4962,12 @@ var require_no_extraneous_dependencies = __commonJS({
         if (paths.length > 0) {
           for (const dir of paths) {
             const packageJsonPath = node_path_1.default.resolve(dir, "package.json");
-            const packageContent_ = getPackageDepFields(packageJsonPath, true);
-            for (const depsKey of Object.keys(packageContent)) {
-              const key = depsKey;
-              Object.assign(packageContent[key], packageContent_[key]);
+            const packageContent_ = getPackageDepFields(packageJsonPath, paths.length === 1);
+            if (packageContent_) {
+              for (const depsKey of Object.keys(packageContent)) {
+                const key = depsKey;
+                Object.assign(packageContent[key], packageContent_[key]);
+              }
             }
           }
         } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plugjs/eslint-plugin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Shared ESLint configurations and extras",
   "main": "./eslint.config.mjs",
   "type": "module",
@@ -10,7 +10,7 @@
     "build": "eslint build.mjs eslint.config.mjs configs"
   },
   "peerDependencies": {
-    "eslint": "^9.5.0"
+    "eslint": "^9.6.0"
   },
   "files": [
     "*.md",
@@ -19,12 +19,12 @@
     "configs/"
   ],
   "dependencies": {
-    "@eslint/js": "9.5.0",
-    "@typescript-eslint/utils": "8.0.0-alpha.33",
+    "@eslint/js": "9.6.0",
+    "@typescript-eslint/utils": "8.0.0-alpha.41",
     "debug": "4.3.5",
     "doctrine": "2.1.0",
     "enhanced-resolve": "5.17.0",
-    "eslint": "9.5.0",
+    "eslint": "9.6.0",
     "eslint-module-utils": "2.8.1",
     "eslint-plugin-unicorn": "54.0.0",
     "eslint-visitor-keys": "4.0.0",
@@ -32,15 +32,16 @@
     "estraverse": "5.3.0",
     "fast-glob": "3.3.2",
     "get-tsconfig": "4.7.5",
-    "globals": "15.6.0",
+    "globals": "15.8.0",
     "is-core-module": "2.14.0",
     "is-glob": "4.0.3",
-    "minimatch": "9.0.4",
+    "minimatch": "9.0.5",
     "picomatch": "4.0.2",
     "resolve": "1.22.8",
     "semver": "7.6.2",
+    "stable-hash": "0.0.4",
     "tslib": "2.6.3",
-    "typescript": "5.5.2",
-    "typescript-eslint": "8.0.0-alpha.33"
+    "typescript": "5.5.3",
+    "typescript-eslint": "8.0.0-alpha.41"
   }
 }