@blocksdiy/eslint-plugin-auto-import 1.0.0

package/README.md

@@ -0,0 +1 @@
+# @blocks/eslint-plugin-auto-import

package/dist/cjs/index.d.ts

@@ -0,0 +1,28 @@
+import { TSESLint } from "@typescript-eslint/utils";
+type ImportMapping = Record<string, {
+    path: string;
+    isDefault?: boolean;
+}>;
+interface ScanDir {
+    dir: string;
+    file?: string;
+    cacheable?: boolean;
+    barrelPattern?: boolean;
+    recursive?: boolean;
+}
+type ScanDirs = Record<string, ScanDir>;
+type Options = [
+    {
+        scanDirs?: ScanDirs;
+        mappings?: ImportMapping;
+    }
+];
+export declare const rules: {
+    "auto-import": TSESLint.RuleModule<"missingImport", Options, unknown, TSESLint.RuleListener>;
+};
+declare const _default: {
+    rules: {
+        "auto-import": TSESLint.RuleModule<"missingImport", Options, unknown, TSESLint.RuleListener>;
+    };
+};
+export default _default;

package/dist/cjs/index.js

@@ -0,0 +1,304 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+// Cache for scanned exports
+const exportCache = new Map();
+// Helper to scan a directory for TypeScript files
+function scanDirectory(dir, recursive) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && recursive) {
+            files.push(...scanDirectory(fullPath, recursive));
+        }
+        else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+// Helper to get exports from a TypeScript file
+function getExportsFromFile(filePath) {
+    const program = ts.createProgram([filePath], {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.CommonJS,
+    });
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) {
+        return new Map();
+    }
+    const exports = new Map();
+    function visit(node) {
+        if (ts.isExportDeclaration(node)) {
+            if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                node.exportClause.elements.forEach((element) => {
+                    exports.set(element.name.text, filePath);
+                });
+            }
+        }
+        else if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+            node.declarationList.declarations.forEach((decl) => {
+                if (ts.isIdentifier(decl.name)) {
+                    exports.set(decl.name.text, filePath);
+                }
+            });
+        }
+        else if (ts.isFunctionDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        else if (ts.isClassDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        else if (ts.isInterfaceDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        else if (ts.isTypeAliasDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return exports;
+}
+// Helper to scan directories and cache results
+function scanAndCacheExports(scanDirs) {
+    const cachePath = path.join(process.cwd(), "exportCache.json");
+    let cachedLoaded = false;
+    // Try to load from cache first
+    if (fs.existsSync(cachePath)) {
+        try {
+            const content = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+            for (const [importPrefix, exports] of Object.entries(content)) {
+                exportCache.set(importPrefix, new Map(Object.entries(exports)));
+            }
+            cachedLoaded = true;
+        }
+        catch (error) {
+            console.error("Error loading cache:", error);
+            // If cache loading fails, continue with scanning
+        }
+    }
+    const newPersistedCache = new Map();
+    // Scan directories and populate exportCache
+    for (const [importPrefix, scanDir] of Object.entries(scanDirs)) {
+        if (cachedLoaded && scanDir.cacheable) {
+            continue;
+        }
+        console.log("scanning dir", scanDir.dir);
+        let files = [];
+        const dir = scanDir.dir;
+        if (!scanDir.file) {
+            files = scanDirectory(dir, scanDir.recursive ?? true);
+        }
+        else {
+            files = [path.join(dir, scanDir.file)];
+        }
+        const exports = new Map();
+        for (const file of files) {
+            console.log("scanning file", file);
+            const fileExports = getExportsFromFile(file);
+            const relativePath = path
+                .relative(dir, file)
+                .replace(/\\/g, "/")
+                .replace(/\.(ts|tsx)$/, "");
+            const importPath = scanDir.barrelPattern ? `${importPrefix}` : `${importPrefix}/${relativePath}`;
+            fileExports.forEach((_, name) => {
+                exports.set(name, importPath);
+            });
+        }
+        if (scanDir.cacheable) {
+            newPersistedCache.set(importPrefix, exports);
+        }
+        exportCache.set(importPrefix, exports);
+    }
+    // Write to cache after populating exportCache
+    if (!cachedLoaded) {
+        try {
+            const cacheContent = Object.fromEntries(Array.from(newPersistedCache.entries()).map(([key, value]) => [key, Object.fromEntries(value.entries())]));
+            fs.writeFileSync(cachePath, JSON.stringify(cacheContent, null, 2));
+        }
+        catch (error) {
+            console.error("Error writing cache:", error);
+        }
+    }
+}
+const rule = {
+    defaultOptions: [{ scanDirs: {}, mappings: {} }],
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Automatically fix missing imports",
+        },
+        fixable: "code",
+        messages: {
+            missingImport: "Missing import for {{ identifier }}",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    scanDirs: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            properties: {
+                                dir: { type: "string" },
+                                file: { type: "string" },
+                                cacheable: { type: "boolean" },
+                                barrelPattern: { type: "boolean" },
+                            },
+                        },
+                    },
+                    mappings: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            properties: {
+                                path: { type: "string" },
+                                isDefault: { type: "boolean" },
+                            },
+                            required: ["path"],
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    create(context) {
+        const options = context.options[0];
+        const { scanDirs = {}, mappings = {} } = options;
+        // Scan directories and cache results on first run
+        if (exportCache.size === 0 && Object.keys(scanDirs).length > 0) {
+            scanAndCacheExports(scanDirs);
+        }
+        // Track existing imports
+        const existing = new Map(); // name -> true (already imported)
+        const importByPath = new Map(); // path -> ImportDeclaration node
+        function rememberImport(node) {
+            importByPath.set(node.source.value, node);
+            for (const spec of node.specifiers) {
+                if (spec.type === "ImportSpecifier") {
+                    existing.set(spec.local.name, true);
+                }
+                else if (spec.type === "ImportDefaultSpecifier") {
+                    existing.set(spec.local.name, true);
+                }
+            }
+        }
+        function buildNamedInsert(name, path, fixer, isDefault = false) {
+            const target = importByPath.get(path);
+            if (target) {
+                // Add to existing import
+                if (isDefault) {
+                    const firstNode = context.sourceCode.ast.body[0];
+                    return fixer.insertTextBefore(firstNode, `import ${name} from "${path}";\n`);
+                }
+                else {
+                    const lastSpecifier = target.specifiers[target.specifiers.length - 1];
+                    return fixer.insertTextAfter(lastSpecifier, `, ${name}`);
+                }
+            }
+            // Make a new top-of-file import
+            const firstNode = context.sourceCode.ast.body[0];
+            if (isDefault) {
+                return fixer.insertTextBefore(firstNode, `import ${name} from "${path}";\n`);
+            }
+            return fixer.insertTextBefore(firstNode, `import { ${name} } from "${path}";\n`);
+        }
+        return {
+            ImportDeclaration(node) {
+                rememberImport(node);
+            },
+            "Program:exit"(node) {
+                const globalScope = context.sourceCode.getScope(node);
+                for (const ref of globalScope.through) {
+                    const identifier = ref.identifier.name;
+                    // Skip if already imported
+                    if (existing.has(identifier)) {
+                        continue;
+                    }
+                    // First check explicit mappings
+                    let mapping = mappings[identifier];
+                    let importPath;
+                    // If no explicit mapping, check scanned exports
+                    if (!mapping) {
+                        for (const exports of exportCache.values()) {
+                            const foundPath = exports.get(identifier);
+                            if (foundPath) {
+                                importPath = foundPath;
+                                mapping = { path: foundPath, isDefault: false };
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        importPath = mapping.path;
+                    }
+                    if (mapping && importPath) {
+                        context.report({
+                            node: ref.identifier,
+                            messageId: "missingImport",
+                            data: {
+                                identifier,
+                            },
+                            fix(fixer) {
+                                return buildNamedInsert(identifier, importPath, fixer, mapping.isDefault);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+exports.rules = {
+    "auto-import": rule,
+};
+exports.default = {
+    rules: exports.rules,
+};

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { TSESLint } from "@typescript-eslint/utils";
+type ImportMapping = Record<string, {
+    path: string;
+    isDefault?: boolean;
+}>;
+interface ScanDir {
+    dir: string;
+    file?: string;
+    cacheable?: boolean;
+    barrelPattern?: boolean;
+    recursive?: boolean;
+}
+type ScanDirs = Record<string, ScanDir>;
+type Options = [
+    {
+        scanDirs?: ScanDirs;
+        mappings?: ImportMapping;
+    }
+];
+export declare const rules: {
+    "auto-import": TSESLint.RuleModule<"missingImport", Options, unknown, TSESLint.RuleListener>;
+};
+declare const _default: {
+    rules: {
+        "auto-import": TSESLint.RuleModule<"missingImport", Options, unknown, TSESLint.RuleListener>;
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,268 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as ts from "typescript";
+// Cache for scanned exports
+const exportCache = new Map();
+// Helper to scan a directory for TypeScript files
+function scanDirectory(dir, recursive) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && recursive) {
+            files.push(...scanDirectory(fullPath, recursive));
+        }
+        else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+// Helper to get exports from a TypeScript file
+function getExportsFromFile(filePath) {
+    const program = ts.createProgram([filePath], {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.CommonJS,
+    });
+    const sourceFile = program.getSourceFile(filePath);
+    if (!sourceFile) {
+        return new Map();
+    }
+    const exports = new Map();
+    function visit(node) {
+        if (ts.isExportDeclaration(node)) {
+            if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                node.exportClause.elements.forEach((element) => {
+                    exports.set(element.name.text, filePath);
+                });
+            }
+        }
+        else if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+            node.declarationList.declarations.forEach((decl) => {
+                if (ts.isIdentifier(decl.name)) {
+                    exports.set(decl.name.text, filePath);
+                }
+            });
+        }
+        else if (ts.isFunctionDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        else if (ts.isClassDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        else if (ts.isInterfaceDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        else if (ts.isTypeAliasDeclaration(node) &&
+            node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            node.name) {
+            exports.set(node.name.text, filePath);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return exports;
+}
+// Helper to scan directories and cache results
+function scanAndCacheExports(scanDirs) {
+    const cachePath = path.join(process.cwd(), "exportCache.json");
+    let cachedLoaded = false;
+    // Try to load from cache first
+    if (fs.existsSync(cachePath)) {
+        try {
+            const content = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+            for (const [importPrefix, exports] of Object.entries(content)) {
+                exportCache.set(importPrefix, new Map(Object.entries(exports)));
+            }
+            cachedLoaded = true;
+        }
+        catch (error) {
+            console.error("Error loading cache:", error);
+            // If cache loading fails, continue with scanning
+        }
+    }
+    const newPersistedCache = new Map();
+    // Scan directories and populate exportCache
+    for (const [importPrefix, scanDir] of Object.entries(scanDirs)) {
+        if (cachedLoaded && scanDir.cacheable) {
+            continue;
+        }
+        console.log("scanning dir", scanDir.dir);
+        let files = [];
+        const dir = scanDir.dir;
+        if (!scanDir.file) {
+            files = scanDirectory(dir, scanDir.recursive ?? true);
+        }
+        else {
+            files = [path.join(dir, scanDir.file)];
+        }
+        const exports = new Map();
+        for (const file of files) {
+            console.log("scanning file", file);
+            const fileExports = getExportsFromFile(file);
+            const relativePath = path
+                .relative(dir, file)
+                .replace(/\\/g, "/")
+                .replace(/\.(ts|tsx)$/, "");
+            const importPath = scanDir.barrelPattern ? `${importPrefix}` : `${importPrefix}/${relativePath}`;
+            fileExports.forEach((_, name) => {
+                exports.set(name, importPath);
+            });
+        }
+        if (scanDir.cacheable) {
+            newPersistedCache.set(importPrefix, exports);
+        }
+        exportCache.set(importPrefix, exports);
+    }
+    // Write to cache after populating exportCache
+    if (!cachedLoaded) {
+        try {
+            const cacheContent = Object.fromEntries(Array.from(newPersistedCache.entries()).map(([key, value]) => [key, Object.fromEntries(value.entries())]));
+            fs.writeFileSync(cachePath, JSON.stringify(cacheContent, null, 2));
+        }
+        catch (error) {
+            console.error("Error writing cache:", error);
+        }
+    }
+}
+const rule = {
+    defaultOptions: [{ scanDirs: {}, mappings: {} }],
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Automatically fix missing imports",
+        },
+        fixable: "code",
+        messages: {
+            missingImport: "Missing import for {{ identifier }}",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    scanDirs: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            properties: {
+                                dir: { type: "string" },
+                                file: { type: "string" },
+                                cacheable: { type: "boolean" },
+                                barrelPattern: { type: "boolean" },
+                            },
+                        },
+                    },
+                    mappings: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            properties: {
+                                path: { type: "string" },
+                                isDefault: { type: "boolean" },
+                            },
+                            required: ["path"],
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    create(context) {
+        const options = context.options[0];
+        const { scanDirs = {}, mappings = {} } = options;
+        // Scan directories and cache results on first run
+        if (exportCache.size === 0 && Object.keys(scanDirs).length > 0) {
+            scanAndCacheExports(scanDirs);
+        }
+        // Track existing imports
+        const existing = new Map(); // name -> true (already imported)
+        const importByPath = new Map(); // path -> ImportDeclaration node
+        function rememberImport(node) {
+            importByPath.set(node.source.value, node);
+            for (const spec of node.specifiers) {
+                if (spec.type === "ImportSpecifier") {
+                    existing.set(spec.local.name, true);
+                }
+                else if (spec.type === "ImportDefaultSpecifier") {
+                    existing.set(spec.local.name, true);
+                }
+            }
+        }
+        function buildNamedInsert(name, path, fixer, isDefault = false) {
+            const target = importByPath.get(path);
+            if (target) {
+                // Add to existing import
+                if (isDefault) {
+                    const firstNode = context.sourceCode.ast.body[0];
+                    return fixer.insertTextBefore(firstNode, `import ${name} from "${path}";\n`);
+                }
+                else {
+                    const lastSpecifier = target.specifiers[target.specifiers.length - 1];
+                    return fixer.insertTextAfter(lastSpecifier, `, ${name}`);
+                }
+            }
+            // Make a new top-of-file import
+            const firstNode = context.sourceCode.ast.body[0];
+            if (isDefault) {
+                return fixer.insertTextBefore(firstNode, `import ${name} from "${path}";\n`);
+            }
+            return fixer.insertTextBefore(firstNode, `import { ${name} } from "${path}";\n`);
+        }
+        return {
+            ImportDeclaration(node) {
+                rememberImport(node);
+            },
+            "Program:exit"(node) {
+                const globalScope = context.sourceCode.getScope(node);
+                for (const ref of globalScope.through) {
+                    const identifier = ref.identifier.name;
+                    // Skip if already imported
+                    if (existing.has(identifier)) {
+                        continue;
+                    }
+                    // First check explicit mappings
+                    let mapping = mappings[identifier];
+                    let importPath;
+                    // If no explicit mapping, check scanned exports
+                    if (!mapping) {
+                        for (const exports of exportCache.values()) {
+                            const foundPath = exports.get(identifier);
+                            if (foundPath) {
+                                importPath = foundPath;
+                                mapping = { path: foundPath, isDefault: false };
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        importPath = mapping.path;
+                    }
+                    if (mapping && importPath) {
+                        context.report({
+                            node: ref.identifier,
+                            messageId: "missingImport",
+                            data: {
+                                identifier,
+                            },
+                            fix(fixer) {
+                                return buildNamedInsert(identifier, importPath, fixer, mapping.isDefault);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+export const rules = {
+    "auto-import": rule,
+};
+export default {
+    rules,
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@blocksdiy/eslint-plugin-auto-import",
+  "blocksLinkIgnore": false,
+  "version": "1.0.0",
+  "type": "module",
+  "description": "",
+  "keywords": [],
+  "author": "Dan Ofir <dan@blocks.diy>",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "directories": {
+    "lib": "src"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "nx": {
+    "tags": [
+      "type:package"
+    ]
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist/ && rm -rf tsconfig.tsbuildinfo && rm -rf node_modules",
+    "build": "tsc && tsc --module commonjs --outDir dist/cjs",
+    "test": "jest --passWithNoTests",
+    "lint": "eslint .",
+    "lint-fix": "pnpm eslint src/ --fix"
+  },
+  "dependencies": {
+    "@typescript-eslint/parser": "^8.52.0",
+    "@typescript-eslint/utils": "^8.52.0",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@blockscom/eslint-config": "4.6.2",
+    "@types/node": "^24.9.2",
+    "jest": "^29.7.0",
+    "tsc-alias": "^1.8.15"
+  },
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "packageManager": "pnpm@10.20.0",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  }
+}