eslint-plugin-imports-regulation 0.2.0 → 0.2.2

package/dist/rules/imports-regulation.d.ts

@@ -1,5 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'groupOrder' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'typeSpecifiersLast' | 'markTypeOnly' | 'blankLinesAfter';
+type MessageIds = 'groupOrder' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'typeSpecifiersLast' | 'markTypeOnly' | 'typeOnlyImport' | 'typeOnlySpecifier' | 'blankLinesAfter';
 type Origin = 'external' | 'internal';
 type Options = [
     {
@@ -8,10 +8,11 @@ type Options = [
             pattern: string;
             group: Origin;
         }[];
-        blankLinesBetweenExternalAndInternalImports?: number;
-        blankLinesAfterImports?: number;
+        blankLinesBetween?: number;
+        blankLinesAfter?: number;
         importsAddenda?: string[];
         preferTypeDeclarations?: boolean;
+        inferTypeOnlyImports?: boolean;
     }?
 ];
 declare const rule: TSESLint.RuleModule<MessageIds, Options>;

package/dist/rules/imports-regulation.js

@@ -47,15 +47,17 @@ const rule = {
                         },
                     },
                     // How many blank lines separate the external block from the internal block. 0 means none.
-                    blankLinesBetweenExternalAndInternalImports: { type: 'integer', minimum: 0 },
+                    blankLinesBetween: { type: 'integer', minimum: 0 },
                     // How many blank lines separate the imports from whatever follows them.
-                    blankLinesAfterImports: { type: 'integer', minimum: 0 },
+                    blankLinesAfter: { type: 'integer', minimum: 0 },
                     // Line globs that still count as part of the imports block, so the gap is measured
                     // after them rather than after the last import.
                     importsAddenda: { type: 'array', items: { type: 'string' }, uniqueItems: true },
                     // An import of nothing but types is rewritten `import type { A }`. Off, and the
                     // spelling is left alone either way.
                     preferTypeDeclarations: { type: 'boolean' },
+                    // Mark bindings that scope analysis shows are only ever used in type positions.
+                    inferTypeOnlyImports: { type: 'boolean' },
                 },
                 additionalProperties: false,
             },
@@ -66,6 +68,8 @@ const rule = {
             unexpectedBlankLine: 'Unexpected blank line between imports in the same group.',
             typeSpecifiersLast: 'Type specifiers must come after value specifiers.',
             markTypeOnly: 'An import of nothing but types must be written `import type { A }`.',
+            typeOnlyImport: 'Everything this imports is only used as a type — write `import type`.',
+            typeOnlySpecifier: '`{{name}}` is only used as a type — mark it `type`.',
             blankLinesAfter: 'Expected {{expected}} blank {{lines}} after the imports, found {{actual}}.',
         },
     },
@@ -77,10 +81,11 @@ const rule = {
             test: globToRegExp(entry.pattern),
             group: entry.group,
         }));
-        const blankLinesBetween = options?.blankLinesBetweenExternalAndInternalImports ?? DEFAULT_BLANK_LINES_BETWEEN;
-        const blankLinesAfter = options?.blankLinesAfterImports ?? DEFAULT_BLANK_LINES_AFTER;
+        const blankLinesBetween = options?.blankLinesBetween ?? DEFAULT_BLANK_LINES_BETWEEN;
+        const blankLinesAfter = options?.blankLinesAfter ?? DEFAULT_BLANK_LINES_AFTER;
         const addenda = (options?.importsAddenda ?? []).map(lineGlobToRegExp);
         const preferTypeDeclarations = options?.preferTypeDeclarations ?? true;
+        const inferTypeOnlyImports = options?.inferTypeOnlyImports ?? true;
         const eol = BREAK.exec(source.text)?.[0] ?? '\n';
         const originOf = (path) => {
             for (const { test, group } of patterns)
@@ -141,13 +146,78 @@ const rule = {
             }
             return `${imported} as ${specifier.local.name}`;
         };
+        /**
+         * Local names this import binds that are only ever referenced from a type position.
+         *
+         * Scope analysis, not type information: the parser's scope manager flags each reference as a
+         * value or a type one. A binding with *no* references says nothing either way, so it is left
+         * out — deciding it is a type would fight `no-unused-vars` over an import that is on its way
+         * out anyway. Under a non-TypeScript parser no reference is a type reference, so this yields
+         * nothing and the check quietly does not apply.
+         */
+        const typeOnlyBindings = (node) => {
+            const names = new Set();
+            for (const variable of source.getDeclaredVariables(node)) {
+                if (variable.references.length === 0)
+                    continue;
+                if (variable.references.every(reference => reference.isTypeReference))
+                    names.add(variable.name);
+            }
+            return names;
+        };
+        /** Returns whether it reported, so the syntax-only checks can stand down. */
+        const checkInferredTypes = (node, named) => {
+            // Already spelled with inline markers throughout: `markTypeOnly` owns that case.
+            if (unmarkedTypeOnly(node))
+                return false;
+            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) {
+                const keyword = source.getFirstToken(node);
+                if (!keyword)
+                    return false;
+                const range = braceInterior(named);
+                context.report({
+                    node,
+                    messageId: 'typeOnlyImport',
+                    fix: fixer => {
+                        const fixes = [fixer.insertTextAfter(keyword, ' type')];
+                        // An inline marker is redundant under `import type`, and illegal besides.
+                        if (range && named.some(specifier => specifier.importKind === 'type')) {
+                            fixes.push(fixer.replaceTextRange(range, rejoin(range, named.map(asValueSpecifier))));
+                        }
+                        return fixes;
+                    },
+                });
+                return true;
+            }
+            // A default or namespace binding has nowhere to put an inline marker, so only named
+            // specifiers can be marked one at a time.
+            const unmarked = named.filter(specifier => specifier.importKind !== 'type' && typeOnly.has(specifier.local.name));
+            if (unmarked.length === 0)
+                return false;
+            for (const specifier of unmarked) {
+                context.report({
+                    node: specifier,
+                    messageId: 'typeOnlySpecifier',
+                    data: { name: specifier.local.name },
+                    fix: fixer => fixer.insertTextBefore(specifier, 'type '),
+                });
+            }
+            return true;
+        };
         const checkSpecifiers = (node) => {
+            if (node.importKind === 'type')
+                return;
             const named = namedOf(node);
+            if (inferTypeOnlyImports && checkInferredTypes(node, named))
+                return;
             const range = braceInterior(named);
             if (!range)
                 return;
-            if (node.importKind === 'type')
-                return;
             if (preferTypeDeclarations && unmarkedTypeOnly(node)) {
                 const keyword = source.getFirstToken(node);
                 if (!keyword)
@@ -239,6 +309,13 @@ const rule = {
             const to = source.getIndexFromLoc({ line: next + 1, column: 0 });
             context.report({
                 node: last.node,
+                // The line that follows the gap, not the import above it: the import is where it
+                // belongs, and squiggling it reads as though it were the thing at fault. This also
+                // matches the between-imports checks, which report the import *after* their gap.
+                loc: {
+                    start: { line: next + 1, column: 0 },
+                    end: { line: next + 1, column: lineAt(next).length },
+                },
                 messageId: 'blankLinesAfter',
                 data: {
                     expected: String(blankLinesAfter),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-imports-regulation",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Order imports: package type-only, package, blank line, local type-only, local — with type specifiers last inside each import.",
   "author": "Robert Sandiford",
   "type": "module",