zemdomu 1.0.0 → 1.0.1

package/out/component-analyzer.js

@@ -0,0 +1,454 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentAnalyzer = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const component_path_resolver_1 = require("./component-path-resolver");
+class ComponentAnalyzer {
+    constructor(options, perf) {
+        this.componentRegistry = new Map();
+        this.importToComponentMap = new Map();
+        this.processingComponentStack = new Set(); // To prevent circular references
+        this.resolver = new component_path_resolver_1.ComponentPathResolver();
+        this.options = options;
+        this.perf = perf;
+    }
+    async analyzeFile(filePath) {
+        var _a;
+        const start = Date.now();
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            if (!/\.(jsx|tsx)$/.test(filePath))
+                return null;
+            const { component, timings } = await this.extractComponentInfo(content, filePath);
+            timings.total = Date.now() - start;
+            (_a = this.perf) === null || _a === void 0 ? void 0 : _a.record(filePath, timings);
+            return component;
+        }
+        catch (e) {
+            console.error(`[ZemDomu] Error analyzing file ${filePath}:`, e);
+            return null;
+        }
+    }
+    async extractComponentInfo(content, filePath) {
+        var _a, _b;
+        const timings = {};
+        let t0 = Date.now();
+        const ast = (0, parser_1.parse)(content, { sourceType: 'module', plugins: ['typescript', 'jsx'] });
+        timings.parse = Date.now() - t0;
+        const componentName = path.basename(filePath, path.extname(filePath));
+        const componentDef = {
+            name: componentName,
+            filePath,
+            issues: new Map(),
+            usesComponents: [],
+            headings: []
+        };
+        // Track imported components
+        const importedComponents = new Map();
+        // Collect imports
+        t0 = Date.now();
+        (0, traverse_1.default)(ast, {
+            ImportDeclaration(path) {
+                const source = path.node.source.value;
+                path.node.specifiers.forEach(spec => {
+                    if (t.isImportSpecifier(spec) || t.isImportDefaultSpecifier(spec)) {
+                        const name = spec.local.name;
+                        if (/^[A-Z]/.test(name)) {
+                            importedComponents.set(name, source);
+                        }
+                    }
+                });
+            }
+        });
+        timings.collectImports = Date.now() - t0;
+        // Collect JSX usages and headings
+        t0 = Date.now();
+        (0, traverse_1.default)(ast, {
+            JSXElement(path) {
+                var _a, _b;
+                const elt = path.node.openingElement.name;
+                if (t.isJSXIdentifier(elt)) {
+                    const name = elt.name;
+                    const tag = name.toLowerCase();
+                    // Record headings
+                    if (/^h[1-6]$/.test(tag)) {
+                        const level = parseInt(tag.charAt(1), 10);
+                        const loc = (_a = elt.loc) === null || _a === void 0 ? void 0 : _a.start;
+                        if (loc) {
+                            componentDef.headings.push({
+                                level,
+                                line: loc.line - 1,
+                                column: loc.column,
+                                filePath
+                            });
+                        }
+                    }
+                    // Record component usage (only for capitalized components)
+                    if (/^[A-Z]/.test(name)) {
+                        const existingRef = componentDef.usesComponents.find(c => c.name === name);
+                        const loc = (_b = elt.loc) === null || _b === void 0 ? void 0 : _b.start;
+                        const location = loc ? { line: loc.line - 1, column: loc.column } : { line: 0, column: 0 };
+                        if (existingRef) {
+                            // Add usage location to existing reference
+                            existingRef.usageLocations.push(location);
+                        }
+                        else {
+                            // Create new component reference
+                            const rawImportPath = importedComponents.get(name) || null;
+                            componentDef.usesComponents.push({
+                                name,
+                                path: null, // Will be resolved later
+                                rawImportPath,
+                                sourceLocation: location,
+                                usageLocations: [location]
+                            });
+                        }
+                    }
+                }
+            }
+        });
+        timings.jsxCollect = Date.now() - t0;
+        // Store import mappings for this file
+        this.importToComponentMap.set(filePath, importedComponents);
+        // Resolve import paths
+        t0 = Date.now();
+        for (const ref of componentDef.usesComponents) {
+            if (ref.rawImportPath) {
+                const t1 = Date.now();
+                ref.path = await this.resolveComponentPath(ref.rawImportPath, filePath);
+                timings[`resolve:${ref.rawImportPath}`] = Date.now() - t1;
+            }
+        }
+        timings.resolvePaths = Date.now() - t0;
+        // Check for heading order issues within this component
+        t0 = Date.now();
+        if ((_a = this.options.rules) === null || _a === void 0 ? void 0 : _a.enforceHeadingOrder) {
+            let lastHeadingLevel = 0;
+            const sortedHeadings = [...componentDef.headings].sort((a, b) => {
+                if (a.line !== b.line)
+                    return a.line - b.line;
+                return a.column - b.column;
+            });
+            for (const heading of sortedHeadings) {
+                if (lastHeadingLevel && heading.level > lastHeadingLevel + 1) {
+                    componentDef.issues.set('enforceHeadingOrder', [
+                        ...(componentDef.issues.get('enforceHeadingOrder') || []),
+                        {
+                            line: heading.line,
+                            column: heading.column,
+                            message: `Heading level skipped: <h${heading.level}> after <h${lastHeadingLevel}>`,
+                            rule: 'enforceHeadingOrder'
+                        }
+                    ]);
+                }
+                lastHeadingLevel = heading.level;
+            }
+        }
+        // Synthetic single-H1 issues
+        if ((_b = this.options.rules) === null || _b === void 0 ? void 0 : _b.singleH1) {
+            const h1Results = componentDef.headings
+                .filter(h => h.level === 1)
+                .map(h => ({ line: h.line, column: h.column, message: '<h1>', rule: 'singleH1' }));
+            if (h1Results.length > 0) {
+                componentDef.issues.set('singleH1', h1Results);
+            }
+        }
+        timings.headingAnalysis = Date.now() - t0;
+        // Register component
+        this.componentRegistry.set(filePath, componentDef);
+        return { component: componentDef, timings };
+    }
+    async resolveComponentPath(importPath, currentPath) {
+        return this.resolver.resolve(importPath, currentPath);
+    }
+    registerComponent(component, issues) {
+        for (const issue of issues) {
+            const rule = issue.rule || this.getRuleType(issue.message);
+            if (!component.issues.has(rule))
+                component.issues.set(rule, []);
+            component.issues.get(rule).push(issue);
+        }
+        this.componentRegistry.set(component.filePath, component);
+    }
+    getRuleType(msg) {
+        if (msg.includes('<h1>'))
+            return 'singleH1';
+        if (msg.includes('Heading level'))
+            return 'enforceHeadingOrder';
+        if (msg.includes('<section>'))
+            return 'requireSectionHeading';
+        if (msg.includes('<img>'))
+            return 'requireAltText';
+        if (msg.includes('missing title attribute'))
+            return 'requireIframeTitle';
+        if (msg.includes('missing alt attribute') && msg.includes('input type="image"'))
+            return 'requireImageInputAlt';
+        if (msg.includes('<html>'))
+            return 'requireHtmlLang';
+        if (msg.includes('<button>'))
+            return 'requireButtonText';
+        if (msg.includes('Form control'))
+            return 'requireLabelForFormControls';
+        if (msg.includes('<li>'))
+            return 'enforceListNesting';
+        if (msg.includes('<a>'))
+            return msg.includes('href') ? 'requireHrefOnAnchors' : 'requireLinkText';
+        if (msg.includes('<table>'))
+            return 'requireTableCaption';
+        if (msg.includes('should not be empty'))
+            return 'preventEmptyInlineTags';
+        return 'other';
+    }
+    analyzeComponentTree() {
+        var _a;
+        const results = [];
+        const cross = (_a = this.options.crossComponentAnalysis) !== null && _a !== void 0 ? _a : true;
+        const rules = this.options.rules || {};
+        if (!cross)
+            return results;
+        if (rules.singleH1)
+            this.findCrossComponentH1Issues(results);
+        if (rules.enforceHeadingOrder)
+            this.findCrossComponentHeadingOrderIssues(results);
+        return results;
+    }
+    findCrossComponentH1Issues(results) {
+        const entryPoints = this.findEntryPoints();
+        for (const entry of entryPoints) {
+            const comps = this.findComponentsWithRule(entry, 'singleH1');
+            if (comps.length > 1) {
+                for (let i = 1; i < comps.length; i++) {
+                    const comp = comps[i];
+                    const ref = this.findReferenceForComp(entry, comp.filePath);
+                    if (ref) {
+                        // Use first JSX usage location instead of import location
+                        const location = ref.usageLocations[0] || ref.sourceLocation;
+                        results.push({
+                            filePath: entry.filePath,
+                            line: location.line,
+                            column: location.column,
+                            message: `Multiple <h1> tags: component '${comp.name}' brings an extra <h1>. Use a lower-level heading.`,
+                            rule: 'singleH1'
+                        });
+                    }
+                    else {
+                        const issue = comp.issues.get('singleH1')[0];
+                        results.push({
+                            filePath: comp.filePath,
+                            line: issue.line,
+                            column: issue.column,
+                            message: `Multiple <h1> across components - consider using lower-level headings.`,
+                            rule: 'singleH1'
+                        });
+                    }
+                }
+            }
+        }
+    }
+    findReferenceForComp(root, targetPath) {
+        for (const ref of root.usesComponents) {
+            if (ref.path === targetPath)
+                return ref;
+        }
+        for (const ref of root.usesComponents) {
+            if (ref.path && this.componentRegistry.has(ref.path)) {
+                const nested = this.findReferenceForComp(this.componentRegistry.get(ref.path), targetPath);
+                if (nested)
+                    return ref;
+            }
+        }
+        return null;
+    }
+    /**
+     * Improved implementation to find heading order issues across components
+     */
+    findCrossComponentHeadingOrderIssues(results) {
+        const entryPoints = this.findEntryPoints();
+        for (const entry of entryPoints) {
+            // Process each entry point as a document root
+            this.processingComponentStack.clear();
+            this.analyzeHeadingHierarchy(entry, results);
+        }
+    }
+    /**
+     * Collects all headings from a component and its children in document order
+     * and checks for heading level issues
+     */
+    analyzeHeadingHierarchy(component, results) {
+        var _a, _b, _c;
+        if (this.processingComponentStack.has(component.filePath)) {
+            // Avoid circular references
+            return;
+        }
+        this.processingComponentStack.add(component.filePath);
+        // Build a flattened view of all headings in document order
+        const allHeadings = this.collectHeadingsInDocumentOrder(component);
+        // Check for heading level issues
+        let lastLevel = 0;
+        for (const heading of allHeadings) {
+            if (lastLevel > 0 && heading.heading.level > lastLevel + 1) {
+                // We found a heading level skip
+                results.push({
+                    filePath: ((_a = heading.usageLocation) === null || _a === void 0 ? void 0 : _a.filePath) || heading.heading.filePath,
+                    line: ((_b = heading.usageLocation) === null || _b === void 0 ? void 0 : _b.line) || heading.heading.line,
+                    column: ((_c = heading.usageLocation) === null || _c === void 0 ? void 0 : _c.column) || heading.heading.column,
+                    message: `Cross-component heading level skipped: <h${heading.heading.level}> after <h${lastLevel}>`,
+                    rule: 'enforceHeadingOrder'
+                });
+            }
+            lastLevel = heading.heading.level;
+        }
+        this.processingComponentStack.delete(component.filePath);
+    }
+    /**
+     * Collects all headings from a component and its children in document order
+     */
+    collectHeadingsInDocumentOrder(component) {
+        // Sort headings within this component by line/column
+        const localHeadings = [...component.headings].sort((a, b) => {
+            if (a.line !== b.line)
+                return a.line - b.line;
+            return a.column - b.column;
+        }).map(h => ({
+            heading: h,
+            usageLocation: null
+        }));
+        // Sort child components by their usage location
+        const childComponents = component.usesComponents
+            .filter(ref => ref.path && this.componentRegistry.has(ref.path))
+            .sort((a, b) => {
+            const aLoc = a.usageLocations[0] || a.sourceLocation;
+            const bLoc = b.usageLocations[0] || b.sourceLocation;
+            if (aLoc.line !== bLoc.line)
+                return aLoc.line - bLoc.line;
+            return aLoc.column - bLoc.column;
+        });
+        // Merge headings and child component headings in document order
+        const allHeadings = [];
+        let headingIndex = 0;
+        let childIndex = 0;
+        // This merges the local headings with child component headings
+        // based on their position in the document
+        while (headingIndex < localHeadings.length || childIndex < childComponents.length) {
+            if (headingIndex >= localHeadings.length) {
+                // No more local headings, process remaining children
+                const childRef = childComponents[childIndex++];
+                if (childRef.path && this.componentRegistry.has(childRef.path) && !this.processingComponentStack.has(childRef.path)) {
+                    const childComponent = this.componentRegistry.get(childRef.path);
+                    const usageLoc = childRef.usageLocations[0] || childRef.sourceLocation;
+                    const usageLocation = {
+                        filePath: component.filePath,
+                        line: usageLoc.line,
+                        column: usageLoc.column
+                    };
+                    this.processingComponentStack.add(childRef.path);
+                    const childHeadings = this.collectHeadingsInDocumentOrder(childComponent)
+                        .map(h => ({
+                        heading: h.heading,
+                        usageLocation: h.usageLocation || usageLocation
+                    }));
+                    this.processingComponentStack.delete(childRef.path);
+                    allHeadings.push(...childHeadings);
+                }
+            }
+            else if (childIndex >= childComponents.length) {
+                // No more children, add remaining local headings
+                allHeadings.push(localHeadings[headingIndex++]);
+            }
+            else {
+                // Compare positions to decide whether to add a local heading or process a child
+                const nextHeading = localHeadings[headingIndex];
+                const nextChild = childComponents[childIndex];
+                const childLoc = nextChild.usageLocations[0] || nextChild.sourceLocation;
+                if (nextHeading.heading.line < childLoc.line ||
+                    (nextHeading.heading.line === childLoc.line && nextHeading.heading.column < childLoc.column)) {
+                    // Local heading comes first
+                    allHeadings.push(nextHeading);
+                    headingIndex++;
+                }
+                else {
+                    // Child component comes first
+                    childIndex++;
+                    if (nextChild.path && this.componentRegistry.has(nextChild.path) && !this.processingComponentStack.has(nextChild.path)) {
+                        const childComponent = this.componentRegistry.get(nextChild.path);
+                        const usageLocation = {
+                            filePath: component.filePath,
+                            line: childLoc.line,
+                            column: childLoc.column
+                        };
+                        this.processingComponentStack.add(nextChild.path);
+                        const childHeadings = this.collectHeadingsInDocumentOrder(childComponent)
+                            .map(h => ({
+                            heading: h.heading,
+                            usageLocation: h.usageLocation || usageLocation
+                        }));
+                        this.processingComponentStack.delete(nextChild.path);
+                        allHeadings.push(...childHeadings);
+                    }
+                }
+            }
+        }
+        return allHeadings;
+    }
+    findEntryPoints() {
+        const all = Array.from(this.componentRegistry.values());
+        const imported = new Set();
+        all.forEach(c => c.usesComponents.forEach(r => r.path && imported.add(r.path)));
+        return all.filter(c => !imported.has(c.filePath));
+    }
+    findComponentsWithRule(root, rule) {
+        const res = [];
+        const visited = new Set();
+        const dfs = (c) => {
+            if (visited.has(c.filePath))
+                return;
+            visited.add(c.filePath);
+            if (c.issues.has(rule))
+                res.push(c);
+            c.usesComponents.forEach(r => r.path && this.componentRegistry.has(r.path) && dfs(this.componentRegistry.get(r.path)));
+        };
+        dfs(root);
+        return res;
+    }
+}
+exports.ComponentAnalyzer = ComponentAnalyzer;

package/out/component-path-resolver.js

@@ -0,0 +1,259 @@
+"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.ComponentPathResolver = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const glob = require('glob');
+let vscodeApi;
+try {
+    vscodeApi = require('vscode');
+}
+catch {
+    vscodeApi = undefined;
+}
+class ComponentPathResolver {
+    static setRootDir(dir) {
+        this.rootDir = dir;
+    }
+    static updateDevMode(dev) {
+        this.devMode = dev;
+    }
+    static async loadTsconfig() {
+        var _a;
+        if (this.tsconfigLoaded)
+            return;
+        this.tsconfigLoaded = true;
+        const folder = (_a = vscodeApi === null || vscodeApi === void 0 ? void 0 : vscodeApi.workspace.workspaceFolders) === null || _a === void 0 ? void 0 : _a[0];
+        const root = folder ? folder.uri.fsPath : this.rootDir;
+        const tsconfigPath = path.join(root, 'tsconfig.json');
+        try {
+            const buf = await fs.readFile(tsconfigPath, 'utf8');
+            const json = JSON.parse(buf);
+            const opts = json.compilerOptions || {};
+            const baseUrl = opts.baseUrl ? path.resolve(root, opts.baseUrl) : root;
+            const paths = opts.paths || {};
+            for (const [alias, targets] of Object.entries(paths)) {
+                const prefix = alias.replace(/\*$/, '').replace(/\/$/, '');
+                const wildcard = alias.includes('*');
+                const mapped = [];
+                for (const t of targets) {
+                    const cleaned = t.replace(/\*$/, '').replace(/\/$/, '');
+                    mapped.push(path.resolve(baseUrl, cleaned));
+                }
+                this.tsAliases.push({ prefix, wildcard, targets: mapped });
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    async tryExtensions(base) {
+        if (path.extname(base)) {
+            if (await this.fileExists(base))
+                return base;
+        }
+        else {
+            const exts = ['.tsx', '.jsx', '.ts', '.js'];
+            for (const ext of exts) {
+                const candidate = `${base}${ext}`;
+                if (await this.fileExists(candidate))
+                    return candidate;
+            }
+            for (const ext of exts) {
+                const candidate = path.join(base, `index${ext}`);
+                if (await this.fileExists(candidate))
+                    return candidate;
+            }
+            if (await this.fileExists(base))
+                return base;
+        }
+        return null;
+    }
+    async resolveWithTsconfig(importPath) {
+        await ComponentPathResolver.loadTsconfig();
+        for (const entry of ComponentPathResolver.tsAliases) {
+            if (entry.wildcard) {
+                if (!importPath.startsWith(entry.prefix))
+                    continue;
+                const rest = importPath.substring(entry.prefix.length);
+                for (const tgt of entry.targets) {
+                    const base = path.join(tgt, rest);
+                    const r = await this.tryExtensions(base);
+                    if (r)
+                        return r;
+                }
+            }
+            else {
+                if (importPath === entry.prefix || importPath.startsWith(entry.prefix + '/')) {
+                    let rest = '';
+                    if (importPath.length > entry.prefix.length) {
+                        rest = importPath.substring(entry.prefix.length);
+                        if (rest.startsWith('/'))
+                            rest = rest.substring(1);
+                    }
+                    for (const tgt of entry.targets) {
+                        const base = rest ? path.join(tgt, rest) : tgt;
+                        const r = await this.tryExtensions(base);
+                        if (r)
+                            return r;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    static normalizeKey(p) {
+        return p
+            .replace(/\\/g, '/')
+            .replace(/\/+$/, '')
+            .replace(/\.(tsx|ts|jsx|js)$/, '')
+            .replace(/\/index$/, '')
+            .toLowerCase();
+    }
+    async fileExists(p) {
+        if (ComponentPathResolver.statCache.has(p)) {
+            return ComponentPathResolver.statCache.get(p);
+        }
+        try {
+            await fs.stat(p);
+            ComponentPathResolver.statCache.set(p, true);
+            return true;
+        }
+        catch {
+            ComponentPathResolver.statCache.set(p, false);
+            return false;
+        }
+    }
+    async resolve(importPath, currentPath) {
+        const tStart = Date.now();
+        const rawKey = importPath.startsWith('.')
+            ? path.resolve(path.dirname(currentPath), importPath)
+            : importPath;
+        const key = ComponentPathResolver.normalizeKey(rawKey);
+        if (ComponentPathResolver.unresolved.has(key))
+            return null;
+        if (ComponentPathResolver.resolveCache.has(key)) {
+            return ComponentPathResolver.resolveCache.get(key);
+        }
+        let result = null;
+        try {
+            if (importPath.startsWith('.')) {
+                const base = path.resolve(path.dirname(currentPath), importPath);
+                result = await this.tryExtensions(base);
+            }
+            else {
+                result = await this.resolveWithTsconfig(importPath);
+                if (!result) {
+                    const prefix = importPath.split('/')[0];
+                    let alias = ComponentPathResolver.aliasCache.get(prefix);
+                    if (!alias) {
+                        const pattern = `**/${prefix}/**/*.{tsx,jsx,ts,js}`;
+                        const files = await new Promise((resolve, reject) => {
+                            glob(pattern, { cwd: ComponentPathResolver.rootDir, ignore: '**/node_modules/**', nodir: true }, (err, matches) => (err ? reject(err) : resolve(matches)));
+                        });
+                        alias = new Map();
+                        for (const relPath of files.slice(0, ComponentPathResolver.aliasFileLimit)) {
+                            const rel = path.resolve(ComponentPathResolver.rootDir, relPath).replace(/\\/g, '/');
+                            const idx = rel.lastIndexOf(`/${prefix}/`);
+                            if (idx === -1)
+                                continue;
+                            const after = rel.substring(idx + prefix.length + 2).replace(/\.(tsx|ts|jsx|js)$/, '');
+                            const key1 = ComponentPathResolver.normalizeKey(`${prefix}/${after}`);
+                            alias.set(key1, rel);
+                            if (after.endsWith('/index')) {
+                                const trimmed = after.replace(/\/index$/, '');
+                                alias.set(ComponentPathResolver.normalizeKey(`${prefix}/${trimmed}`), rel);
+                            }
+                        }
+                        ComponentPathResolver.aliasCache.set(prefix, alias);
+                    }
+                    const normImport = ComponentPathResolver.normalizeKey(importPath);
+                    result = alias.get(normImport) || null;
+                    if (!result) {
+                        const patterns = [
+                            `**/${importPath}.{tsx,jsx,ts,js}`,
+                            `**/${importPath}/index.{tsx,jsx,ts,js}`
+                        ];
+                        for (const ptn of patterns) {
+                            const pKey = `glob:${ptn}`;
+                            if (ComponentPathResolver.resolveCache.has(pKey)) {
+                                const cached = ComponentPathResolver.resolveCache.get(pKey);
+                                if (cached) {
+                                    result = cached;
+                                    break;
+                                }
+                                continue;
+                            }
+                            const matches = await new Promise((resolve, reject) => {
+                                glob(ptn, { cwd: ComponentPathResolver.rootDir, ignore: '**/node_modules/**', nodir: true }, (err, files) => (err ? reject(err) : resolve(files)));
+                            });
+                            if (matches.length) {
+                                result = path.resolve(ComponentPathResolver.rootDir, matches[0]);
+                                ComponentPathResolver.resolveCache.set(pKey, result);
+                                break;
+                            }
+                            else {
+                                ComponentPathResolver.resolveCache.set(pKey, null);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            result = null;
+        }
+        ComponentPathResolver.resolveCache.set(key, result);
+        if (result === null)
+            ComponentPathResolver.unresolved.add(key);
+        const tTotal = Date.now() - tStart;
+        if (ComponentPathResolver.devMode) {
+            console.debug(`[ZemDomu] resolved ${importPath} -> ${result} (${tTotal}ms)`);
+        }
+        return result;
+    }
+}
+exports.ComponentPathResolver = ComponentPathResolver;
+ComponentPathResolver.resolveCache = new Map();
+ComponentPathResolver.statCache = new Map();
+ComponentPathResolver.aliasCache = new Map();
+ComponentPathResolver.unresolved = new Set();
+ComponentPathResolver.devMode = false;
+ComponentPathResolver.tsconfigLoaded = false;
+ComponentPathResolver.tsAliases = [];
+ComponentPathResolver.aliasFileLimit = 100;
+ComponentPathResolver.rootDir = process.cwd();

package/out/index.js

@@ -1,6 +1,10 @@
 "use strict";
 // Exposes the core lint function and types
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lint = void 0;
+exports.ComponentPathResolver = exports.ComponentAnalyzer = exports.lint = void 0;
 var linter_1 = require("./linter");
 Object.defineProperty(exports, "lint", { enumerable: true, get: function () { return linter_1.lint; } });
+var component_analyzer_1 = require("./component-analyzer");
+Object.defineProperty(exports, "ComponentAnalyzer", { enumerable: true, get: function () { return component_analyzer_1.ComponentAnalyzer; } });
+var component_path_resolver_1 = require("./component-path-resolver");
+Object.defineProperty(exports, "ComponentPathResolver", { enumerable: true, get: function () { return component_path_resolver_1.ComponentPathResolver; } });

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "zemdomu",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Hello",
   "main": "./out/index.js",
-  "files": ["out"],
+  "files": [
+    "out"
+  ],
   "private": false,
   "scripts": {
-    "build":   "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
+    "compile": "tsc -p tsconfig.json",
     "test": "npm run compile && node tests/linter-labels.test.js && node tests/unique-ids.test.js"
   },
   "keywords": [],
@@ -25,6 +28,7 @@
   "dependencies": {
     "@babel/parser": "^7.27.0",
     "@babel/traverse": "^7.27.0",
-    "@babel/types": "^7.27.0"
+    "@babel/types": "^7.27.0",
+    "glob": "^7.2.3"
   }
 }