@plugjs/eslint-plugin 0.2.23 → 0.2.24

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

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "node_modules/eslint-plugin-import-x/package.json"(exports2, module2) {
     module2.exports = {
       name: "eslint-plugin-import-x",
-      version: "4.3.1",
+      version: "4.4.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)",
@@ -682,11 +682,11 @@ var require_parse = __commonJS({
       return rest;
     }
     var log = (0, debug_1.default)("eslint-plugin-import-x:parse");
-    function keysFromParser(parserPath, parserInstance, parsedResult) {
+    function keysFromParser(_parserPath, parserInstance, parsedResult) {
       if (parsedResult && parsedResult.visitorKeys) {
         return parsedResult.visitorKeys;
       }
-      if (typeof parserPath === "string" && /.*espree.*/.test(parserPath)) {
+      if (parserInstance && "VisitorKeys" in parserInstance && parserInstance.VisitorKeys) {
         return parserInstance.VisitorKeys;
       }
       return null;
@@ -1207,7 +1207,9 @@ var require_export_map = __commonJS({
           return null;
         }
         exportMap.mtime = stats().mtime.valueOf();
-        exportCache.set(cacheKey, exportMap);
+        if (exportMap.visitorKeys) {
+          exportCache.set(cacheKey, exportMap);
+        }
         return exportMap;
       }
       static get(source, context) {
@@ -2706,26 +2708,17 @@ var require_dynamic_import_chunkname = __commonJS({
 var require_export = __commonJS({
   "node_modules/eslint-plugin-import-x/lib/rules/export.js"(exports2, module2) {
     "use strict";
-    var utils_1 = require_utils();
+    var utils_1 = require("@typescript-eslint/utils");
+    var utils_2 = require_utils();
     var rootProgram = "root";
     var tsTypePrefix = "type:";
-    function isTypescriptFunctionOverloads(nodes) {
-      const nodesArr = [...nodes];
-      const idents = nodesArr.flatMap((node) => "declaration" in node && node.declaration?.type === "TSDeclareFunction" ? node.declaration.id.name : []);
-      if (new Set(idents).size !== idents.length) {
-        return true;
-      }
-      const types = new Set(nodesArr.map((node) => `${node.parent.type}`));
-      if (!types.has("TSDeclareFunction")) {
-        return false;
-      }
-      if (types.size === 1) {
-        return true;
-      }
-      if (types.size === 2 && types.has("FunctionDeclaration")) {
-        return true;
+    function removeTypescriptFunctionOverloads(nodes) {
+      for (const node of nodes) {
+        const declType = node.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration ? node.declaration.type : node.parent?.type;
+        if (declType === utils_1.AST_NODE_TYPES.TSDeclareFunction) {
+          nodes.delete(node);
+        }
       }
-      return false;
     }
     function isTypescriptNamespaceMerging(nodes) {
       const types = new Set(Array.from(nodes, (node) => `${node.parent.type}`));
@@ -2736,7 +2729,7 @@ var require_export = __commonJS({
       const types = new Set(Array.from(nodes, (node2) => `${node2.parent.type}`));
       return !isTypescriptNamespaceMerging(nodes) && node.parent.type === "TSModuleDeclaration" && (types.has("TSEnumDeclaration") || types.has("ClassDeclaration") || types.has("FunctionDeclaration") || types.has("TSDeclareFunction"));
     }
-    module2.exports = (0, utils_1.createRule)({
+    module2.exports = (0, utils_2.createRule)({
       name: "export",
       meta: {
         type: "problem",
@@ -2778,7 +2771,7 @@ var require_export = __commonJS({
             addNamed("default", node, getParent(node));
           },
           ExportSpecifier(node) {
-            addNamed((0, utils_1.getValue)(node.exported), node.exported, getParent(node.parent));
+            addNamed((0, utils_2.getValue)(node.exported), node.exported, getParent(node.parent));
           },
           ExportNamedDeclaration(node) {
             if (node.declaration == null) {
@@ -2792,7 +2785,7 @@ var require_export = __commonJS({
             }
             if ("declarations" in node.declaration && node.declaration.declarations != null) {
               for (const declaration of node.declaration.declarations) {
-                (0, utils_1.recursivePatternCapture)(declaration.id, (v) => {
+                (0, utils_2.recursivePatternCapture)(declaration.id, (v) => {
                   addNamed(v.name, v, parent, isTypeVariableDecl);
                 });
               }
@@ -2805,7 +2798,7 @@ var require_export = __commonJS({
             if (node.exported && node.exported.name) {
               return;
             }
-            const remoteExports = utils_1.ExportMap.get(node.source.value, context);
+            const remoteExports = utils_2.ExportMap.get(node.source.value, context);
             if (remoteExports == null) {
               return;
             }
@@ -2832,10 +2825,14 @@ var require_export = __commonJS({
           "Program:exit"() {
             for (const [, named] of namespace) {
               for (const [name, nodes] of named) {
+                if (nodes.size === 0) {
+                  continue;
+                }
+                removeTypescriptFunctionOverloads(nodes);
                 if (nodes.size <= 1) {
                   continue;
                 }
-                if (isTypescriptFunctionOverloads(nodes) || isTypescriptNamespaceMerging(nodes)) {
+                if (isTypescriptNamespaceMerging(nodes)) {
                   continue;
                 }
                 for (const node of nodes) {
@@ -2940,6 +2937,9 @@ var require_extensions = __commonJS({
         pattern: patternProperties,
         ignorePackages: {
           type: "boolean"
+        },
+        checkTypeImports: {
+          type: "boolean"
         }
       }
     };
@@ -2947,14 +2947,15 @@ var require_extensions = __commonJS({
       const result = {
         defaultConfig: "never",
         pattern: {},
-        ignorePackages: false
+        ignorePackages: false,
+        checkTypeImports: false
       };
       for (const obj of context.options) {
         if (typeof obj === "string") {
           result.defaultConfig = obj;
           continue;
         }
-        if (obj.pattern === void 0 && obj.ignorePackages === void 0) {
+        if (obj.pattern === void 0 && obj.ignorePackages === void 0 && obj.checkTypeImports === void 0) {
           Object.assign(result.pattern, obj);
           continue;
         }
@@ -2964,6 +2965,9 @@ var require_extensions = __commonJS({
         if (obj.ignorePackages !== void 0) {
           result.ignorePackages = obj.ignorePackages;
         }
+        if (obj.checkTypeImports !== void 0) {
+          result.checkTypeImports = obj.checkTypeImports;
+        }
       }
       if (result.defaultConfig === "ignorePackages") {
         result.defaultConfig = "always";
@@ -3060,7 +3064,7 @@ var require_extensions = __commonJS({
           const extension = node_path_1.default.extname(resolvedPath || importPath).slice(1);
           const isPackage = (0, utils_1.isExternalModule)(importPath, (0, utils_1.resolve)(importPath, context), context) || (0, utils_1.isScoped)(importPath);
           if (!extension || !importPath.endsWith(`.${extension}`)) {
-            if ("importKind" in node && node.importKind === "type" || "exportKind" in node && node.exportKind === "type") {
+            if (!props.checkTypeImports && ("importKind" in node && node.importKind === "type" || "exportKind" in node && node.exportKind === "type")) {
               return;
             }
             const extensionRequired = isUseOfExtensionRequired(extension, isPackage);
@@ -4953,6 +4957,7 @@ var require_no_duplicates = __commonJS({
               imported: /* @__PURE__ */ new Map(),
               nsImported: /* @__PURE__ */ new Map(),
               defaultTypesImported: /* @__PURE__ */ new Map(),
+              namespaceTypesImported: /* @__PURE__ */ new Map(),
               namedTypesImported: /* @__PURE__ */ new Map()
             };
             moduleMaps.set(parent, map);
@@ -4961,6 +4966,9 @@ var require_no_duplicates = __commonJS({
             if (n.specifiers.length > 0 && n.specifiers[0].type === "ImportDefaultSpecifier") {
               return map.defaultTypesImported;
             }
+            if (n.specifiers.length > 0 && n.specifiers[0].type === "ImportNamespaceSpecifier") {
+              return map.namespaceTypesImported;
+            }
             if (!preferInline) {
               return map.namedTypesImported;
             }
@@ -5737,6 +5745,12 @@ var require_no_named_as_default = __commonJS({
               exportMapOfImported.reportErrors(context, declaration);
               return;
             }
+            if (!exportMapOfImported.hasDefault) {
+              return;
+            }
+            if (!exportMapOfImported.has(nameValue)) {
+              return;
+            }
             if (exportMapOfImported.exports.has("default") && exportMapOfImported.exports.has(nameValue)) {
               context.report({
                 node: defaultSpecifier,

package/bundles/stylistic-eslint-plugin.cjs

@@ -87,6 +87,7 @@ var require_utils = __commonJS({
           case "Property":
           case "PropertyDefinition":
           case "MethodDefinition":
+          case "ImportAttribute":
             prop = node.key;
             break;
           case "MemberExpression":
@@ -2505,7 +2506,7 @@ var require_comma_spacing = __commonJS({
           }
         }
         function validateCommaSpacing(commaToken, prevToken, nextToken) {
-          if (prevToken && astUtils.isTokenOnSameLine(prevToken, commaToken) && spaceBefore !== sourceCode.isSpaceBetweenTokens(prevToken, commaToken)) {
+          if (prevToken && astUtils.isTokenOnSameLine(prevToken, commaToken) && spaceBefore !== sourceCode.isSpaceBetween(prevToken, commaToken)) {
             context.report({
               node: commaToken,
               data: {
@@ -2518,14 +2519,7 @@ var require_comma_spacing = __commonJS({
               )
             });
           }
-          if (nextToken && astUtils.isClosingParenToken(nextToken))
-            return;
-          if (spaceAfter && nextToken && (astUtils.isClosingBraceToken(nextToken) || astUtils.isClosingBracketToken(nextToken))) {
-            return;
-          }
-          if (!spaceAfter && nextToken && nextToken.type === utils$1.AST_TOKEN_TYPES.Line)
-            return;
-          if (nextToken && astUtils.isTokenOnSameLine(commaToken, nextToken) && spaceAfter !== sourceCode.isSpaceBetweenTokens(commaToken, nextToken)) {
+          if (nextToken && astUtils.isTokenOnSameLine(commaToken, nextToken) && !astUtils.isClosingParenToken(nextToken) && !astUtils.isClosingBracketToken(nextToken) && !astUtils.isClosingBraceToken(nextToken) && !(!spaceAfter && nextToken.type === utils$1.AST_TOKEN_TYPES.Line) && spaceAfter !== sourceCode.isSpaceBetween(commaToken, nextToken)) {
             context.report({
               node: commaToken,
               data: {
@@ -3507,38 +3501,30 @@ var require_function_call_spacing = __commonJS({
       create(context, [option, config]) {
         const sourceCode = context.sourceCode;
         const text = sourceCode.getText();
-        function checkSpacing(node) {
+        function checkSpacing(node, leftToken, rightToken) {
           const isOptionalCall = astUtils.isOptionalCallExpression(node);
-          const closingParenToken = sourceCode.getLastToken(node);
-          const lastCalleeTokenWithoutPossibleParens = sourceCode.getLastToken(
-            node.typeArguments ?? node.callee
-          );
-          const openingParenToken = sourceCode.getFirstTokenBetween(
-            lastCalleeTokenWithoutPossibleParens,
-            closingParenToken,
-            astUtils.isOpeningParenToken
-          );
-          if (!openingParenToken || openingParenToken.range[1] >= node.range[1]) {
-            return;
-          }
-          const lastCalleeToken = sourceCode.getTokenBefore(
-            openingParenToken,
-            astUtils.isNotOptionalChainPunctuator
-          );
-          const textBetweenTokens = text.slice(lastCalleeToken.range[1], openingParenToken.range[0]).replace(/\/\*.*?\*\//gu, "");
+          const textBetweenTokens = text.slice(leftToken.range[1], rightToken.range[0]).replace(/\/\*.*?\*\//gu, "");
           const hasWhitespace = /\s/u.test(textBetweenTokens);
           const hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
           if (option === "never") {
             if (hasWhitespace) {
               return context.report({
                 node,
-                loc: lastCalleeToken.loc.start,
+                loc: leftToken.loc.start,
                 messageId: "unexpectedWhitespace",
                 fix(fixer) {
-                  if (!hasNewline && !isOptionalCall) {
+                  if (sourceCode.commentsExistBetween(leftToken, rightToken))
+                    return null;
+                  if (isOptionalCall) {
+                    return fixer.replaceTextRange([
+                      leftToken.range[1],
+                      rightToken.range[0]
+                    ], "?.");
+                  }
+                  if (!hasNewline) {
                     return fixer.removeRange([
-                      lastCalleeToken.range[1],
-                      openingParenToken.range[0]
+                      leftToken.range[1],
+                      rightToken.range[0]
                     ]);
                   }
                   return null;
@@ -3549,7 +3535,7 @@ var require_function_call_spacing = __commonJS({
             if (hasWhitespace || hasNewline) {
               context.report({
                 node,
-                loc: lastCalleeToken.loc.start,
+                loc: leftToken.loc.start,
                 messageId: "unexpectedWhitespace"
               });
             }
@@ -3557,20 +3543,22 @@ var require_function_call_spacing = __commonJS({
             if (!hasWhitespace) {
               context.report({
                 node,
-                loc: lastCalleeToken.loc.start,
+                loc: leftToken.loc.start,
                 messageId: "missing",
                 fix(fixer) {
-                  return fixer.insertTextBefore(openingParenToken, " ");
+                  return fixer.insertTextBefore(rightToken, " ");
                 }
               });
             } else if (!config.allowNewlines && hasNewline) {
               context.report({
                 node,
-                loc: lastCalleeToken.loc.start,
+                loc: leftToken.loc.start,
                 messageId: "unexpectedNewline",
                 fix(fixer) {
+                  if (sourceCode.commentsExistBetween(leftToken, rightToken))
+                    return null;
                   return fixer.replaceTextRange(
-                    [lastCalleeToken.range[1], openingParenToken.range[0]],
+                    [leftToken.range[1], rightToken.range[0]],
                     " "
                   );
                 }
@@ -3579,8 +3567,30 @@ var require_function_call_spacing = __commonJS({
           }
         }
         return {
-          CallExpression: checkSpacing,
-          NewExpression: checkSpacing
+          "CallExpression, NewExpression": function(node) {
+            const closingParenToken = sourceCode.getLastToken(node);
+            const lastCalleeTokenWithoutPossibleParens = sourceCode.getLastToken(
+              node.typeArguments ?? node.callee
+            );
+            const openingParenToken = sourceCode.getFirstTokenBetween(
+              lastCalleeTokenWithoutPossibleParens,
+              closingParenToken,
+              astUtils.isOpeningParenToken
+            );
+            if (!openingParenToken || openingParenToken.range[1] >= node.range[1]) {
+              return;
+            }
+            const lastCalleeToken = sourceCode.getTokenBefore(
+              openingParenToken,
+              astUtils.isNotOptionalChainPunctuator
+            );
+            checkSpacing(node, lastCalleeToken, openingParenToken);
+          },
+          ImportExpression(node) {
+            const leftToken = sourceCode.getFirstToken(node);
+            const rightToken = sourceCode.getTokenAfter(leftToken);
+            checkSpacing(node, leftToken, rightToken);
+          }
         };
       }
     });
@@ -4089,7 +4099,8 @@ var require_indent = __commonJS({
       "ImportSpecifier",
       "ImportDefaultSpecifier",
       "ImportNamespaceSpecifier",
-      "ImportExpression"
+      "ImportExpression",
+      "ImportAttribute"
     ]);
     var IndexMap = class {
       /**
@@ -4842,13 +4853,38 @@ var require_indent = __commonJS({
           },
           ExportNamedDeclaration(node) {
             if (node.declaration === null) {
-              const closingCurly = sourceCode.getLastToken(node, utils.isClosingBraceToken);
+              const closingCurly = node.source ? sourceCode.getTokenBefore(node.source, utils.isClosingBraceToken) : sourceCode.getLastToken(node, utils.isClosingBraceToken);
               addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);
               if (node.source) {
-                offsets.setDesiredOffsets([closingCurly.range[1], node.range[1]], sourceCode.getFirstToken(node), 1);
+                const fromToken = sourceCode.getTokenAfter(
+                  closingCurly,
+                  (token) => token.type === "Identifier" && token.value === "from"
+                );
+                const lastToken = sourceCode.getLastToken(node, utils.isNotSemicolonToken);
+                offsets.setDesiredOffsets([fromToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
+                const lastClosingCurly = sourceCode.getLastToken(node, utils.isClosingBraceToken);
+                if (lastClosingCurly && node.source.range[1] < lastClosingCurly.range[0]) {
+                  const openingCurly = sourceCode.getTokenAfter(node.source, utils.isOpeningBraceToken);
+                  const closingCurly2 = lastClosingCurly;
+                  addElementListIndent(node.attributes, openingCurly, closingCurly2, 1);
+                }
               }
             }
           },
+          ExportAllDeclaration(node) {
+            const fromToken = sourceCode.getTokenAfter(
+              node.exported || sourceCode.getFirstToken(node),
+              (token) => token.type === "Identifier" && token.value === "from"
+            );
+            const lastToken = sourceCode.getLastToken(node, utils.isNotSemicolonToken);
+            offsets.setDesiredOffsets([fromToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
+            const lastClosingCurly = sourceCode.getLastToken(node, utils.isClosingBraceToken);
+            if (lastClosingCurly && node.source.range[1] < lastClosingCurly.range[0]) {
+              const openingCurly = sourceCode.getTokenAfter(node.source, utils.isOpeningBraceToken);
+              const closingCurly = lastClosingCurly;
+              addElementListIndent(node.attributes, openingCurly, closingCurly, 1);
+            }
+          },
           ForStatement(node) {
             const forOpeningParen = sourceCode.getFirstToken(node, 1);
             if (node.init)
@@ -4912,15 +4948,23 @@ var require_indent = __commonJS({
           ImportDeclaration(node) {
             if (node.specifiers.some((specifier) => specifier.type === "ImportSpecifier")) {
               const openingCurly = sourceCode.getFirstToken(node, utils.isOpeningBraceToken);
-              const closingCurly = sourceCode.getLastToken(node, utils.isClosingBraceToken);
+              const closingCurly = sourceCode.getTokenBefore(node.source, utils.isClosingBraceToken);
               addElementListIndent(node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier"), openingCurly, closingCurly, options.ImportDeclaration);
             }
-            const fromToken = sourceCode.getLastToken(node, (token) => token.type === "Identifier" && token.value === "from");
-            const sourceToken = sourceCode.getLastToken(node, (token) => token.type === "String");
-            const semiToken = sourceCode.getLastToken(node, (token) => token.type === "Punctuator" && token.value === ";");
+            const fromToken = node.specifiers.length ? sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1], (token) => token.type === "Identifier" && token.value === "from") : sourceCode.getFirstToken(node, (token) => token.type === "Identifier" && token.value === "from");
+            const lastToken = sourceCode.getLastToken(node, utils.isNotSemicolonToken);
             if (fromToken) {
-              const end = semiToken && semiToken.range[1] === sourceToken.range[1] ? node.range[1] : sourceToken.range[1];
-              offsets.setDesiredOffsets([fromToken.range[0], end], sourceCode.getFirstToken(node), 1);
+              offsets.setDesiredOffsets([fromToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
+            }
+            const lastClosingCurly = sourceCode.getLastToken(node, utils.isClosingBraceToken);
+            if (lastClosingCurly && node.source.range[1] < lastClosingCurly.range[0]) {
+              const openingCurly = sourceCode.getTokenAfter(node.source, utils.isOpeningBraceToken);
+              const closingCurly = lastClosingCurly;
+              if (!fromToken) {
+                const withToken = sourceCode.getTokenBefore(openingCurly, (token) => token.value === "with");
+                offsets.setDesiredOffsets([withToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
+              }
+              addElementListIndent(node.attributes, openingCurly, closingCurly, 1);
             }
           },
           ImportExpression(node) {
@@ -5722,12 +5766,44 @@ var require_indent_binary_ops = __commonJS({
             return indentCache.get(line);
           return sourceCode.lines[line - 1].match(/^\s*/)?.[0] ?? "";
         }
+        function subtractionIndent(indent) {
+          if (options[0] === "tab") {
+            return indent.slice(1);
+          }
+          return indent.slice(options[0] ?? 2);
+        }
+        function getTargetIndent(indent, needAdditionIndent, needSubtractionIndent) {
+          if (needAdditionIndent && !needSubtractionIndent) {
+            return indent + indentStr;
+          }
+          if (!needAdditionIndent && needSubtractionIndent) {
+            return subtractionIndent(indent);
+          }
+          return indent;
+        }
         function firstTokenOfLine(line) {
           return sourceCode.tokensAndComments.find((token) => token.loc.start.line === line);
         }
         function lastTokenOfLine(line) {
           return [...sourceCode.tokensAndComments].reverse().find((token) => token.loc.end.line === line);
         }
+        function isGreaterThanCloseBracketOfLine(line) {
+          const tokensAndCommentsOfLine = sourceCode.tokensAndComments.filter((token) => token.loc.start.line === line);
+          let openBracketCount = 0;
+          let closeBracketCount = 0;
+          for (const token of tokensAndCommentsOfLine) {
+            if (token.value === "(") {
+              openBracketCount++;
+            }
+            if (token.value === ")") {
+              closeBracketCount++;
+            }
+          }
+          return openBracketCount < closeBracketCount;
+        }
+        function hasExclusivelyCloseBracketOfLine(line) {
+          return !sourceCode.tokensAndComments.some((token) => token.loc.start.line === line && ![")", "}", "]"].includes(token.value));
+        }
         function handler(node, right) {
           if (node.loc.start.line === node.loc.end.line)
             return;
@@ -5747,8 +5823,10 @@ var require_indent_binary_ops = __commonJS({
           const firstTokenOfLineLeft = firstTokenOfLine(tokenLeft.loc.start.line);
           const lastTokenOfLineLeft = lastTokenOfLine(tokenLeft.loc.start.line);
           const needAdditionIndent = firstTokenOfLineLeft?.type === "Keyword" && !["typeof", "instanceof", "this"].includes(firstTokenOfLineLeft.value) || firstTokenOfLineLeft?.type === "Identifier" && firstTokenOfLineLeft.value === "type" && node.parent?.type === "TSTypeAliasDeclaration" || [":", "[", "(", "<", "="].includes(lastTokenOfLineLeft?.value || "") || ["[", "(", "=>", ":"].includes(tokenBeforeAll?.value || "") && firstTokenOfLineLeft?.loc.start.line === tokenBeforeAll?.loc.start.line || ["||", "&&"].includes(lastTokenOfLineLeft?.value || "") && node.loc.start.line === tokenLeft.loc.start.line && node.loc.start.column !== getIndentOfLine(node.loc.start.line).length;
-          const indentTarget = getIndentOfLine(tokenLeft.loc.start.line) + (needAdditionIndent ? indentStr : "");
+          const needSubtractionIndent = lastTokenOfLineLeft?.value === ")" && isGreaterThanCloseBracketOfLine(tokenLeft.loc.start.line) && !hasExclusivelyCloseBracketOfLine(tokenLeft.loc.start.line);
+          const indentLeft = getIndentOfLine(tokenLeft.loc.start.line);
           const indentRight = getIndentOfLine(tokenRight.loc.start.line);
+          const indentTarget = getTargetIndent(indentLeft, needAdditionIndent, needSubtractionIndent);
           if (indentTarget !== indentRight) {
             const start = {
               line: tokenRight.loc.start.line,
@@ -6093,26 +6171,21 @@ var require_jsx_closing_bracket_location = __commonJS({
             openingStartOfLine
           };
         }
-        function getOpeningElementId(node) {
-          return node.range.join(":");
-        }
-        const lastAttributeNode = {};
         return {
-          JSXAttribute(node) {
-            lastAttributeNode[getOpeningElementId(node.parent)] = node;
-          },
-          JSXSpreadAttribute(node) {
-            lastAttributeNode[getOpeningElementId(node.parent)] = node;
-          },
           "JSXOpeningElement:exit": function(node) {
-            const attributeNode = lastAttributeNode[getOpeningElementId(node)];
-            const cachedLastAttributeEndPos = attributeNode ? attributeNode.range[1] : null;
+            const lastAttributeNode = node.attributes.at(-1);
+            const cachedLastAttributeEndPos = lastAttributeNode ? lastAttributeNode.range[1] : null;
             let expectedNextLine;
             const tokens = getTokensLocations(node);
-            const expectedLocation = getExpectedLocation(tokens);
+            let expectedLocation = getExpectedLocation(tokens);
             let usingSameIndentation = true;
             if (expectedLocation === "tag-aligned")
               usingSameIndentation = tokens.isTab.openTab === tokens.isTab.closeTab;
+            const lastComment = context.sourceCode.getCommentsInside(node).at(-1);
+            const hasTrailingComment = lastComment && lastComment.range[0] > (lastAttributeNode ?? node.name).range[1];
+            if ((expectedLocation === "after-props" || expectedLocation === "after-tag") && !(hasCorrectLocation(tokens, expectedLocation) && usingSameIndentation) && hasTrailingComment) {
+              expectedLocation = "line-aligned";
+            }
             if (hasCorrectLocation(tokens, expectedLocation) && usingSameIndentation)
               return;
             const data = {
@@ -6140,9 +6213,11 @@ var require_jsx_closing_bracket_location = __commonJS({
                     return fixer.replaceTextRange([cachedLastAttributeEndPos, node.range[1]], (expectedNextLine ? "\n" : "") + closingTag);
                   case "props-aligned":
                   case "tag-aligned":
-                  case "line-aligned":
-                    return fixer.replaceTextRange([cachedLastAttributeEndPos, node.range[1]], `
+                  case "line-aligned": {
+                    const rangeStart = hasTrailingComment ? lastComment.range[1] : cachedLastAttributeEndPos;
+                    return fixer.replaceTextRange([rangeStart, node.range[1]], `
 ${getIndentation(tokens, expectedLocation, correctColumn)}${closingTag}`);
+                  }
                 }
                 return null;
               }
@@ -9412,6 +9487,11 @@ var require_key_spacing = __commonJS({
     function isSingleLine(node) {
       return node.loc.end.line === node.loc.start.line;
     }
+    function isSingleLineImportAttributes(node, sourceCode) {
+      const openingBrace = sourceCode.getTokenBefore(node.attributes[0], utils.isOpeningBraceToken);
+      const closingBrace = sourceCode.getTokenAfter(node.attributes[node.attributes.length - 1], utils.isClosingBraceToken);
+      return closingBrace.loc.end.line === openingBrace.loc.start.line;
+    }
     function isSingleLineProperties(properties) {
       const [firstProp] = properties;
       const lastProp = last(properties);
@@ -9658,6 +9738,8 @@ var require_key_spacing = __commonJS({
         const alignmentOptions = ruleOptions.align || null;
         const sourceCode = context.sourceCode;
         function isKeyValueProperty(property) {
+          if (property.type === "ImportAttribute")
+            return true;
           return !("method" in property && property.method || "shorthand" in property && property.shorthand || "kind" in property && property.kind !== "init" || property.type !== "Property");
         }
         function getNextColon(node) {
@@ -9688,7 +9770,7 @@ var require_key_spacing = __commonJS({
         }
         function getKey(property) {
           const key = property.key;
-          if (property.computed)
+          if (property.type !== "ImportAttribute" && property.computed)
             return sourceCode.getText().slice(key.range[0], key.range[1]);
           return utils.getStaticPropertyName(property);
         }
@@ -9737,7 +9819,7 @@ var require_key_spacing = __commonJS({
               loc,
               messageId,
               data: {
-                computed: property.computed ? "computed " : "",
+                computed: property.type !== "ImportAttribute" && property.computed ? "computed " : "",
                 key: getKey(property)
               },
               fix
@@ -9762,10 +9844,10 @@ var require_key_spacing = __commonJS({
           }
           return null;
         }
-        function createGroups(node) {
-          if (node.properties.length === 1)
-            return [node.properties];
-          return node.properties.reduce((groups, property) => {
+        function createGroups(properties) {
+          if (properties.length === 1)
+            return [properties];
+          return properties.reduce((groups, property) => {
             const currentGroup = last(groups);
             const prev = last(currentGroup);
             if (!prev || continuesPropertyGroup(prev, property))
@@ -9822,39 +9904,55 @@ var require_key_spacing = __commonJS({
           for (let i = 0; i < length; i++)
             verifySpacing(properties[i], lineOptions);
         }
-        function verifyAlignment(node) {
-          createGroups(node).forEach((group) => {
-            const properties = group.filter(isKeyValueProperty);
-            if (properties.length > 0 && isSingleLineProperties(properties))
-              verifyListSpacing(properties, multiLineOptions);
+        function verifyAlignment(properties) {
+          createGroups(properties).forEach((group) => {
+            const properties2 = group.filter(isKeyValueProperty);
+            if (properties2.length > 0 && isSingleLineProperties(properties2))
+              verifyListSpacing(properties2, multiLineOptions);
             else
-              verifyGroupAlignment(properties);
+              verifyGroupAlignment(properties2);
           });
         }
+        function verifyImportAttributes(node) {
+          if (!node.attributes)
+            return;
+          if (isSingleLineImportAttributes(node, sourceCode))
+            verifyListSpacing(node.attributes, singleLineOptions);
+          else
+            verifyAlignment(node.attributes);
+        }
         if (alignmentOptions) {
           return {
             ObjectExpression(node) {
               if (isSingleLine(node))
                 verifyListSpacing(node.properties.filter(isKeyValueProperty), singleLineOptions);
               else
-                verifyAlignment(node);
+                verifyAlignment(node.properties);
+            },
+            ImportDeclaration(node) {
+              verifyImportAttributes(node);
+            },
+            ExportNamedDeclaration(node) {
+              verifyImportAttributes(node);
+            },
+            ExportAllDeclaration(node) {
+              verifyImportAttributes(node);
             }
           };
         }
         return {
           Property(node) {
             verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);
+          },
+          ImportAttribute(node) {
+            const parent = node.parent;
+            verifySpacing(node, isSingleLineImportAttributes(parent, sourceCode) ? singleLineOptions : multiLineOptions);
           }
         };
       }
     });
     var baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
     var baseSchema = Array.isArray(baseRule.meta.schema) ? baseRule.meta.schema[0] : baseRule.meta.schema;
-    function at(arr, position) {
-      if (position < 0)
-        return arr[arr.length + position];
-      return arr[position];
-    }
     var keySpacing = utils.createRule({
       name: "key-spacing",
       package: "ts",
@@ -9876,7 +9974,7 @@ var require_key_spacing = __commonJS({
         function adjustedColumn(position) {
           const line = position.line - 1;
           return utils.getStringLength(
-            at(sourceCode.lines, line).slice(0, position.column)
+            sourceCode.lines.at(line).slice(0, position.column)
           );
         }
         function getLastTokenBeforeColon(node) {
@@ -9896,14 +9994,14 @@ var require_key_spacing = __commonJS({
           return code.slice(
             0,
             sourceCode.getTokenAfter(
-              at(node.parameters, -1),
+              node.parameters.at(-1),
               astUtils.isClosingBracketToken
             ).range[1] - node.range[0]
           );
         }
         function getKeyLocEnd(node) {
           return getLastTokenBeforeColon(
-            node.type !== utils$1.AST_NODE_TYPES.TSIndexSignature ? node.key : at(node.parameters, -1)
+            node.type !== utils$1.AST_NODE_TYPES.TSIndexSignature ? node.key : node.parameters.at(-1)
           ).loc.end;
         }
         function checkBeforeColon(node, expectedWhitespaceBeforeColon, mode) {
@@ -9969,7 +10067,7 @@ var require_key_spacing = __commonJS({
           if (candidateValueStartLine - groupEndLine === 1)
             return true;
           const leadingComments = sourceCode.getCommentsBefore(candidate);
-          if (leadingComments.length && leadingComments[0].loc.start.line - groupEndLine <= 1 && candidateValueStartLine - at(leadingComments, -1).loc.end.line <= 1) {
+          if (leadingComments.length && leadingComments[0].loc.start.line - groupEndLine <= 1 && candidateValueStartLine - leadingComments.at(-1).loc.end.line <= 1) {
             for (let i = 1; i < leadingComments.length; i++) {
               if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {
                 return false;
@@ -10048,7 +10146,7 @@ var require_key_spacing = __commonJS({
             alignGroups.push(currentAlignGroup);
             let prevNode;
             for (const node of members) {
-              let prevAlignedNode = at(currentAlignGroup, -1);
+              let prevAlignedNode = currentAlignGroup.at(-1);
               if (prevAlignedNode !== prevNode)
                 prevAlignedNode = void 0;
               if (prevAlignedNode && continuesAlignGroup(prevAlignedNode, node)) {
@@ -11716,6 +11814,31 @@ var require_max_statements_per_line = __commonJS({
     require("eslint-visitor-keys");
     require("espree");
     require("estraverse");
+    var listeningNodes = [
+      "BreakStatement",
+      "ClassDeclaration",
+      "ContinueStatement",
+      "DebuggerStatement",
+      "DoWhileStatement",
+      "ExpressionStatement",
+      "ForInStatement",
+      "ForOfStatement",
+      "ForStatement",
+      "FunctionDeclaration",
+      "IfStatement",
+      "ImportDeclaration",
+      "LabeledStatement",
+      "ReturnStatement",
+      "SwitchStatement",
+      "ThrowStatement",
+      "TryStatement",
+      "VariableDeclaration",
+      "WhileStatement",
+      "WithStatement",
+      "ExportNamedDeclaration",
+      "ExportDefaultDeclaration",
+      "ExportAllDeclaration"
+    ];
     var maxStatementsPerLine = utils.createRule({
       name: "max-statements-per-line",
       package: "js",
@@ -11732,6 +11855,13 @@ var require_max_statements_per_line = __commonJS({
                 type: "integer",
                 minimum: 1,
                 default: 1
+              },
+              ignoredNodes: {
+                type: "array",
+                items: {
+                  type: "string",
+                  enum: listeningNodes
+                }
               }
             },
             additionalProperties: false
@@ -11745,6 +11875,7 @@ var require_max_statements_per_line = __commonJS({
         const sourceCode = context.sourceCode;
         const options = context.options[0] || {};
         const maxStatementsPerLine2 = typeof options.max !== "undefined" ? options.max : 1;
+        const ignoredNodes = options.ignoredNodes || [];
         let lastStatementLine = 0;
         let numberOfStatementsOnThisLine = 0;
         let firstExtraStatement = null;
@@ -11789,55 +11920,16 @@ var require_max_statements_per_line = __commonJS({
             lastStatementLine = line;
           }
         }
-        return {
-          "BreakStatement": enterStatement,
-          "ClassDeclaration": enterStatement,
-          "ContinueStatement": enterStatement,
-          "DebuggerStatement": enterStatement,
-          "DoWhileStatement": enterStatement,
-          "ExpressionStatement": enterStatement,
-          "ForInStatement": enterStatement,
-          "ForOfStatement": enterStatement,
-          "ForStatement": enterStatement,
-          "FunctionDeclaration": enterStatement,
-          "IfStatement": enterStatement,
-          "ImportDeclaration": enterStatement,
-          "LabeledStatement": enterStatement,
-          "ReturnStatement": enterStatement,
-          "SwitchStatement": enterStatement,
-          "ThrowStatement": enterStatement,
-          "TryStatement": enterStatement,
-          "VariableDeclaration": enterStatement,
-          "WhileStatement": enterStatement,
-          "WithStatement": enterStatement,
-          "ExportNamedDeclaration": enterStatement,
-          "ExportDefaultDeclaration": enterStatement,
-          "ExportAllDeclaration": enterStatement,
-          "BreakStatement:exit": leaveStatement,
-          "ClassDeclaration:exit": leaveStatement,
-          "ContinueStatement:exit": leaveStatement,
-          "DebuggerStatement:exit": leaveStatement,
-          "DoWhileStatement:exit": leaveStatement,
-          "ExpressionStatement:exit": leaveStatement,
-          "ForInStatement:exit": leaveStatement,
-          "ForOfStatement:exit": leaveStatement,
-          "ForStatement:exit": leaveStatement,
-          "FunctionDeclaration:exit": leaveStatement,
-          "IfStatement:exit": leaveStatement,
-          "ImportDeclaration:exit": leaveStatement,
-          "LabeledStatement:exit": leaveStatement,
-          "ReturnStatement:exit": leaveStatement,
-          "SwitchStatement:exit": leaveStatement,
-          "ThrowStatement:exit": leaveStatement,
-          "TryStatement:exit": leaveStatement,
-          "VariableDeclaration:exit": leaveStatement,
-          "WhileStatement:exit": leaveStatement,
-          "WithStatement:exit": leaveStatement,
-          "ExportNamedDeclaration:exit": leaveStatement,
-          "ExportDefaultDeclaration:exit": leaveStatement,
-          "ExportAllDeclaration:exit": leaveStatement,
+        const listeners = {
           "Program:exit": reportFirstExtraStatementAndClear
         };
+        for (const node of listeningNodes) {
+          if (ignoredNodes.includes(node))
+            continue;
+          listeners[node] = enterStatement;
+          listeners[`${node}:exit`] = leaveStatement;
+        }
+        return listeners;
       }
     });
     module2.exports = maxStatementsPerLine;
@@ -14145,7 +14237,7 @@ var require_no_multi_spaces = __commonJS({
         const sourceCode = context.sourceCode;
         const options = context.options[0] || {};
         const ignoreEOLComments = options.ignoreEOLComments;
-        const exceptions = Object.assign({ Property: true }, options.exceptions);
+        const exceptions = Object.assign({ Property: true, ImportAttribute: true }, options.exceptions);
         const hasExceptions = Object.keys(exceptions).some((key) => exceptions[key]);
         const spacesRe = options.includeTabs === false ? / {2}/ : /[ \t]{2}/;
         function formatReportedCommentValue(token) {
@@ -15991,9 +16083,11 @@ var require_padding_line_between_statements = __commonJS({
         test: (node, sourceCode) => node.loc.start.line !== node.loc.end.line && node.type === utils.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode)
       },
       "multiline-const": newMultilineKeywordTester("const"),
+      "multiline-export": newMultilineKeywordTester("export"),
       "multiline-let": newMultilineKeywordTester("let"),
       "multiline-var": newMultilineKeywordTester("var"),
       "singleline-const": newSinglelineKeywordTester("const"),
+      "singleline-export": newSinglelineKeywordTester("export"),
       "singleline-let": newSinglelineKeywordTester("let"),
       "singleline-var": newSinglelineKeywordTester("var"),
       "block": newNodeTypeTester(utils.AST_NODE_TYPES.BlockStatement),
@@ -16310,7 +16404,7 @@ var require_quote_props = __commonJS({
         }
         function checkUnnecessaryQuotes(node) {
           const key = node.key;
-          if (node.method || node.computed || node.shorthand)
+          if (node.type !== "ImportAttribute" && (node.method || node.computed || node.shorthand))
             return;
           if (key.type === "Literal" && typeof key.value === "string") {
             let tokens;
@@ -16349,26 +16443,39 @@ var require_quote_props = __commonJS({
           }
         }
         function checkOmittedQuotes(node) {
+          if (node.type !== "ImportAttribute" && (node.method || node.computed || node.shorthand))
+            return;
           const key = node.key;
-          if (!node.method && !node.computed && !node.shorthand && !(key.type === "Literal" && typeof key.value === "string")) {
-            context.report({
-              node,
-              messageId: "unquotedPropertyFound",
-              data: { property: key.name || key.value },
-              fix: (fixer) => fixer.replaceText(key, getQuotedKey(key))
-            });
-          }
+          if (key.type === "Literal" && typeof key.value === "string")
+            return;
+          context.report({
+            node,
+            messageId: "unquotedPropertyFound",
+            data: { property: key.name || key.value },
+            fix: (fixer) => fixer.replaceText(key, getQuotedKey(key))
+          });
+        }
+        function checkConsistencyForObject(node, checkQuotesRedundancy) {
+          checkConsistency(
+            node.properties.filter((property) => property.type !== "SpreadElement" && property.key && !property.method && !property.computed && !property.shorthand),
+            checkQuotesRedundancy
+          );
+        }
+        function checkImportAttributes(attributes) {
+          if (!attributes)
+            return;
+          if (MODE === "consistent")
+            checkConsistency(attributes, false);
+          if (MODE === "consistent-as-needed")
+            checkConsistency(attributes, true);
         }
-        function checkConsistency(node, checkQuotesRedundancy) {
+        function checkConsistency(properties, checkQuotesRedundancy) {
           const quotedProps = [];
           const unquotedProps = [];
           let keywordKeyName = null;
           let necessaryQuotes = false;
-          node.properties.forEach((rawProperty) => {
-            const property = rawProperty;
+          properties.forEach((property) => {
             const key = property.key;
-            if (!key || property.method || property.computed || property.shorthand)
-              return;
             if (key.type === "Literal" && typeof key.value === "string") {
               quotedProps.push(property);
               if (checkQuotesRedundancy) {
@@ -16427,9 +16534,24 @@ var require_quote_props = __commonJS({
           },
           ObjectExpression(node) {
             if (MODE === "consistent")
-              checkConsistency(node, false);
+              checkConsistencyForObject(node, false);
             if (MODE === "consistent-as-needed")
-              checkConsistency(node, true);
+              checkConsistencyForObject(node, true);
+          },
+          ImportAttribute(node) {
+            if (MODE === "always" || !MODE)
+              checkOmittedQuotes(node);
+            if (MODE === "as-needed")
+              checkUnnecessaryQuotes(node);
+          },
+          ImportDeclaration(node) {
+            checkImportAttributes(node.attributes);
+          },
+          ExportAllDeclaration(node) {
+            checkImportAttributes(node.attributes);
+          },
+          ExportNamedDeclaration(node) {
+            checkImportAttributes(node.attributes);
           }
         };
       }
@@ -17593,7 +17715,7 @@ var require_space_before_blocks = __commonJS({
         function checkPrecedingSpace(node) {
           const precedingToken = sourceCode.getTokenBefore(node);
           if (precedingToken && astUtils.isTokenOnSameLine(precedingToken, node)) {
-            const hasSpace = sourceCode.isSpaceBetweenTokens(
+            const hasSpace = sourceCode.isSpaceBetween(
               precedingToken,
               node
             );
@@ -17723,7 +17845,7 @@ var require_space_before_function_paren = __commonJS({
             rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
             leftToken = sourceCode.getTokenBefore(rightToken);
           }
-          const hasSpacing = sourceCode.isSpaceBetweenTokens(leftToken, rightToken);
+          const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
           if (hasSpacing && functionConfig === "never") {
             context.report({
               node,
@@ -19031,10 +19153,7 @@ var require_type_annotation_spacing = __commonJS({
             return;
           const { before, after } = getRules(ruleSet, typeAnnotation);
           if (type === ":" && previousToken.value === "?") {
-            if (
-              //  -- TODO - switch once our min ESLint version is 6.7.0
-              sourceCode.isSpaceBetweenTokens(previousToken, punctuatorTokenStart)
-            ) {
+            if (sourceCode.isSpaceBetween(previousToken, punctuatorTokenStart)) {
               context.report({
                 node: punctuatorTokenStart,
                 messageId: "unexpectedSpaceBetween",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plugjs/eslint-plugin",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "Shared ESLint configurations and extras",
   "main": "./index.mjs",
   "type": "module",
@@ -37,15 +37,15 @@
   "dependencies": {
     "@eslint/js": "9.13.0",
     "@nolyfill/is-core-module": "1.0.39",
-    "@typescript-eslint/utils": "8.11.0",
+    "@typescript-eslint/utils": "8.12.2",
     "debug": "4.3.7",
     "doctrine": "3.0.0",
     "enhanced-resolve": "5.17.1",
     "eslint": "9.13.0",
     "eslint-module-utils": "2.12.0",
     "eslint-plugin-unicorn": "56.0.0",
-    "eslint-visitor-keys": "4.1.0",
-    "espree": "10.2.0",
+    "eslint-visitor-keys": "4.2.0",
+    "espree": "10.3.0",
     "estraverse": "5.3.0",
     "fast-glob": "3.3.2",
     "get-tsconfig": "4.8.1",
@@ -58,8 +58,8 @@
     "resolve": "1.22.8",
     "semver": "7.6.3",
     "stable-hash": "0.0.4",
-    "tslib": "2.8.0",
+    "tslib": "2.8.1",
     "typescript": "5.6.3",
-    "typescript-eslint": "8.11.0"
+    "typescript-eslint": "8.12.2"
   }
 }