@dcoder-x/plugin-shared 0.1.1 → 0.1.3

package/dist/extractors/ComponentExtractor.d.ts

@@ -6,6 +6,9 @@ export declare class ComponentExtractor {
     extract(): Promise<DiscoveredElement[]>;
     private getModuleFilesForRoute;
     private walkWebpackGraph;
+    private findWebpackModule;
+    private getWebpackDependencyPaths;
+    private getFileImportPaths;
     private walkRollupGraph;
     private extractFromSource;
     private readSource;

package/dist/extractors/ComponentExtractor.js

@@ -40,19 +40,127 @@ class ComponentExtractor {
             if (visited.has(current))
                 continue;
             visited.add(current);
-            const mod = compilation.moduleGraph.getModuleByIdentifier(current);
-            if (!mod)
-                continue;
-            for (const dep of compilation.moduleGraph.getOutgoingDependencies(mod)) {
-                const depModule = compilation.moduleGraph.getResolvedModule(dep);
-                const depPath = normalizeModulePath(depModule?.resource || depModule?.userRequest);
-                if (depPath && !depPath.includes('node_modules')) {
-                    queue.push(depPath);
+            const mod = this.findWebpackModule(compilation, current);
+            let queuedFromWebpackGraph = false;
+            if (mod) {
+                for (const depPath of this.getWebpackDependencyPaths(compilation, mod)) {
+                    if (depPath && !depPath.includes('node_modules')) {
+                        queue.push(depPath);
+                        queuedFromWebpackGraph = true;
+                    }
+                }
+            }
+            // Fallback for webpack variants where moduleGraph helpers are unavailable.
+            if (!queuedFromWebpackGraph) {
+                for (const depPath of this.getFileImportPaths(current)) {
+                    if (depPath && !depPath.includes('node_modules')) {
+                        queue.push(depPath);
+                    }
                 }
             }
         }
         return Array.from(visited);
     }
+    findWebpackModule(compilation, filePath) {
+        const graph = compilation?.moduleGraph;
+        if (graph?.getModuleByIdentifier) {
+            const byIdentifier = graph.getModuleByIdentifier(filePath);
+            if (byIdentifier)
+                return byIdentifier;
+        }
+        const modules = Array.isArray(compilation?.modules)
+            ? compilation.modules
+            : compilation?.modules
+                ? Array.from(compilation.modules)
+                : [];
+        for (const mod of modules) {
+            const resource = normalizeModulePath(mod?.resource || mod?.userRequest);
+            if (resource === filePath)
+                return mod;
+            const id = normalizeModulePath(typeof mod?.identifier === 'function' ? mod.identifier() : mod?.id);
+            if (id === filePath)
+                return mod;
+        }
+        return null;
+    }
+    getWebpackDependencyPaths(compilation, mod) {
+        const graph = compilation?.moduleGraph;
+        if (graph?.getOutgoingDependencies && graph?.getResolvedModule) {
+            const out = [];
+            for (const dep of graph.getOutgoingDependencies(mod)) {
+                const depModule = graph.getResolvedModule(dep);
+                const depPath = normalizeModulePath(depModule?.resource || depModule?.userRequest);
+                if (depPath)
+                    out.push(depPath);
+            }
+            return out;
+        }
+        const fallbackDeps = Array.isArray(mod?.dependencies) ? mod.dependencies : [];
+        const out = [];
+        for (const dep of fallbackDeps) {
+            let depModule = null;
+            if (graph?.getModule) {
+                depModule = graph.getModule(dep);
+            }
+            // Legacy fallback for older webpack versions.
+            if (!depModule) {
+                try {
+                    depModule = dep?.module || dep?._module;
+                }
+                catch {
+                    depModule = null;
+                }
+            }
+            const depPath = normalizeModulePath(depModule?.resource || depModule?.userRequest);
+            if (depPath)
+                out.push(depPath);
+        }
+        return out;
+    }
+    getFileImportPaths(filePath) {
+        const source = this.readSource(filePath);
+        if (!source)
+            return [];
+        let ast;
+        try {
+            ast = (0, parser_1.parse)(source, { sourceType: 'module', plugins: ['typescript', 'jsx'] });
+        }
+        catch {
+            return [];
+        }
+        const importIds = new Set();
+        (0, traverse_1.default)(ast, {
+            ImportDeclaration(nodePath) {
+                const value = nodePath.node.source?.value;
+                if (typeof value === 'string')
+                    importIds.add(value);
+            },
+            ExportNamedDeclaration(nodePath) {
+                const value = nodePath.node.source?.value;
+                if (typeof value === 'string')
+                    importIds.add(value);
+            },
+            ExportAllDeclaration(nodePath) {
+                const value = nodePath.node.source?.value;
+                if (typeof value === 'string')
+                    importIds.add(value);
+            },
+            CallExpression(nodePath) {
+                if (nodePath.node.callee?.type !== 'Import')
+                    return;
+                const arg = nodePath.node.arguments?.[0];
+                if (arg?.type === 'StringLiteral')
+                    importIds.add(arg.value);
+            },
+        });
+        const resolved = [];
+        for (const importId of importIds) {
+            const depPath = resolveImportFile(importId, filePath);
+            if (depPath)
+                resolved.push(depPath);
+        }
+        return resolved;
+    }
     walkRollupGraph(entryFilePath, graph) {
         const visited = new Set();
         const queue = [entryFilePath];
@@ -192,3 +300,35 @@ function inferInteractions(tag, props) {
         return ['submit'];
     return ['click'];
 }
+function resolveImportFile(importId, fromFile) {
+    if (!importId)
+        return null;
+    if (!importId.startsWith('.') && !importId.startsWith('/'))
+        return null;
+    const base = importId.startsWith('/')
+        ? path_1.default.normalize(importId)
+        : path_1.default.resolve(path_1.default.dirname(fromFile), importId);
+    const candidates = [
+        base,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        `${base}.mts`,
+        `${base}.cts`,
+        path_1.default.join(base, 'index.ts'),
+        path_1.default.join(base, 'index.tsx'),
+        path_1.default.join(base, 'index.js'),
+        path_1.default.join(base, 'index.jsx'),
+        path_1.default.join(base, 'index.mjs'),
+        path_1.default.join(base, 'index.cjs'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isFile()) {
+            return path_1.default.normalize(candidate);
+        }
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcoder-x/plugin-shared",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",