eslint-plugin-imports-regulation 0.2.2 → 0.2.4

package/dist/rules/imports-regulation.js

@@ -110,9 +110,33 @@ const rule = {
         const unmarkedTypeOnly = (node) => node.importKind === 'value'
             && node.specifiers.length > 0
             && node.specifiers.every(s => s.type === 'ImportSpecifier' && s.importKind === 'type');
+        /**
+         * Every binding is only used as a type, whether or not it says so yet.
+         *
+         * Memoised because `groupOf` asks once per import and the answer walks the scope chain.
+         */
+        const inferred = new Map();
+        const isInferredTypeOnly = (node) => {
+            const cached = inferred.get(node);
+            if (cached !== undefined)
+                return cached;
+            const typeOnly = typeOnlyBindings(node);
+            const result = node.specifiers.length > 0
+                && node.specifiers.every(specifier => typeOnly.has(specifier.local.name));
+            inferred.set(node, result);
+            return result;
+        };
         // `isTypeOnly`, not `typeOnly`: the option of that name is a spelling, this is a fact.
+        //
+        // 🚨 The inferred case has to count here, not just the written one. Classify by syntax alone
+        // and an import that is *about* to be marked type-only still sorts as a value import, so the
+        // order check fires on a classification that is one fix out of date and swaps two imports
+        // that both end up in the same group. Stable sorting then keeps them swapped, so the author
+        // loses their order for no reason and the file never settles back.
         const groupOf = (node) => {
-            const isTypeOnly = node.importKind === 'type' || unmarkedTypeOnly(node);
+            const isTypeOnly = node.importKind === 'type'
+                || unmarkedTypeOnly(node)
+                || (inferTypeOnlyImports && isInferredTypeOnly(node));
             const base = originOf(node.source.value) === 'internal' ? INTERNAL_TYPE : EXTERNAL_TYPE;
             return isTypeOnly ? base : base + 1;
         };
@@ -173,9 +197,9 @@ const rule = {
             const typeOnly = typeOnlyBindings(node);
             if (typeOnly.size === 0)
                 return false;
-            const everyBinding = node.specifiers.length > 0
-                && node.specifiers.every(specifier => typeOnly.has(specifier.local.name));
-            if (everyBinding && preferTypeDeclarations) {
+            // Not gated on `preferTypeDeclarations`: that option is about leaving a spelling you
+            // wrote alone. Here there is no spelling yet, and `import type` is the one to write.
+            if (isInferredTypeOnly(node)) {
                 const keyword = source.getFirstToken(node);
                 if (!keyword)
                     return false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-imports-regulation",
-  "version": "0.2.2",
-  "description": "Order imports: package type-only, package, blank line, local type-only, local — with type specifiers last inside each import.",
+  "version": "0.2.4",
+  "description": "Order imports: external type-only, external, blank line, internal type-only, internal — with type specifiers last inside each import.",
   "author": "Robert Sandiford",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
   "devDependencies": {
     "@types/node": "^22.19.15",
     "eslint": "^10.8.1",
-    "typescript-eslint": "^8.67.0"
+    "typescript-eslint": "^8.70.0"
   },
   "scripts": {
     "compile": "tsc",