@bobfrankston/importgen 0.1.35 → 0.1.37

package/index.js

@@ -37,49 +37,122 @@ function resolveDependencyPath(packageDir, depName, depVersion) {
     }
 }
 /**
- * Resolve entry point from package.json
+ * Resolve entry point from package.json. Handles modern conditional
+ * exports (`{ ".": { "import": { "browser": "...", "default": "..." } } }`)
+ * by recursively walking the conditions until a string-valued leaf is
+ * found, preferring `import` / `browser` / `default` for our use case.
  */
 function resolveEntryPoint(pkg, packageDir) {
+    void packageDir;
     // 1. Check exports field (modern)
     if (pkg.exports) {
         if (typeof pkg.exports === 'string') {
             return pkg.exports;
         }
-        else if (pkg.exports['.']) {
-            const dotExport = pkg.exports['.'];
-            if (typeof dotExport === 'string') {
-                return dotExport;
-            }
-            else if (dotExport.import) {
-                return dotExport.import;
-            }
-            else if (dotExport.default) {
-                return dotExport.default;
-            }
-        }
+        const dotExport = pkg.exports['.'] ?? pkg.exports;
+        const found = pickConditionalExport(dotExport);
+        if (found)
+            return found;
     }
     // 2. Check module field (ESM)
-    if (pkg.module) {
+    if (typeof pkg.module === 'string')
         return pkg.module;
-    }
     // 3. Fall back to main field
-    if (pkg.main) {
+    if (typeof pkg.main === 'string')
         return pkg.main;
-    }
     // 4. Default to index.js
     return './index.js';
 }
+/** Walk a conditional-exports node looking for a string entry point.
+ *  Conditions traversed in priority order: `import`, `browser`, `module`,
+ *  `default`, then any other keys. Recurses through nested condition
+ *  objects. Returns null if no string leaf is found. */
+function pickConditionalExport(node) {
+    if (typeof node === 'string')
+        return node;
+    if (!node || typeof node !== 'object')
+        return null;
+    const conditions = ['import', 'browser', 'module', 'default'];
+    for (const cond of conditions) {
+        if (cond in node) {
+            const found = pickConditionalExport(node[cond]);
+            if (found)
+                return found;
+        }
+    }
+    // Fall back to any other key (rarely hit; covers exotic shapes).
+    for (const key of Object.keys(node)) {
+        if (conditions.includes(key))
+            continue;
+        const found = pickConditionalExport(node[key]);
+        if (found)
+            return found;
+    }
+    return null;
+}
 /**
  * Recursively collect all dependencies, avoiding circular references.
  * nodeModulesPrefix tracks the import map path prefix for nested deps
  * (e.g., './node_modules' for root, './node_modules/@scope/pkg/node_modules' for nested).
  */
+/** Expand a single npm `workspaces` glob pattern under `rootDir` to a list
+ *  of absolute workspace member directories. Supports literal paths and a
+ *  trailing single `*` segment (the common npm-workspaces shapes:
+ *  `packages/*`, `apps/*`, `client`). Other glob shapes are not handled. */
+function expandWorkspacePattern(rootDir, pattern) {
+    const segs = pattern.split(/[\\/]/).filter(Boolean);
+    const globIdx = segs.findIndex(s => /[*?[]/.test(s));
+    if (globIdx === -1) {
+        const full = path.join(rootDir, ...segs);
+        return fs.existsSync(full) ? [full] : [];
+    }
+    if (globIdx === segs.length - 1 && segs[globIdx] === '*') {
+        const parentDir = path.join(rootDir, ...segs.slice(0, globIdx));
+        if (!fs.existsSync(parentDir))
+            return [];
+        return fs.readdirSync(parentDir, { withFileTypes: true })
+            .filter(e => e.isDirectory() || e.isSymbolicLink())
+            .map(e => path.join(parentDir, e.name));
+    }
+    return [];
+}
 function collectDependencies(packageJsonPath, visited, dependencies, htmlDir, nodeModulesPrefix, warnings, depPaths) {
     try {
         const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
         const packageDir = path.dirname(packageJsonPath);
-        const deps = packageJson.dependencies || {};
+        const declaredDeps = packageJson.dependencies || {};
         const dotDeps = packageJson['.dependencies'] || {};
+        // Bug 4: synthesize deps from the `workspaces` field. npm/pnpm
+        // workspaces convention is that sibling packages are reachable by
+        // package name without re-declaring them as deps. Each member's
+        // package.json `name` is added as a `file:`-protocol dep so the
+        // existing resolver finds it (via the junction npm puts in
+        // node_modules, or via the workspace path directly).
+        const workspaces = packageJson.workspaces;
+        let workspacePatterns = [];
+        if (Array.isArray(workspaces)) {
+            workspacePatterns = workspaces;
+        }
+        else if (workspaces && typeof workspaces === 'object' && Array.isArray(workspaces.packages)) {
+            workspacePatterns = workspaces.packages;
+        }
+        const syntheticDeps = {};
+        for (const pattern of workspacePatterns) {
+            for (const wsDir of expandWorkspacePattern(packageDir, pattern)) {
+                const wsPkgPath = path.join(wsDir, 'package.json');
+                if (!fs.existsSync(wsPkgPath))
+                    continue;
+                try {
+                    const wsPkg = JSON.parse(fs.readFileSync(wsPkgPath, 'utf-8'));
+                    if (typeof wsPkg.name === 'string' && !(wsPkg.name in declaredDeps)) {
+                        const rel = path.relative(packageDir, wsDir).split(path.sep).join('/');
+                        syntheticDeps[wsPkg.name] = `file:${rel}`;
+                    }
+                }
+                catch { /* malformed workspace pkg — skip */ }
+            }
+        }
+        const deps = { ...syntheticDeps, ...declaredDeps };
         for (const [depName, depVersion] of Object.entries(deps)) {
             // Skip if already processed (circular dependency protection)
             if (visited.has(depName)) {
@@ -138,10 +211,40 @@ function collectDependencies(packageJsonPath, visited, dependencies, htmlDir, no
                 searchDir = parent;
             }
             if (!depPrefix) {
-                // Fallback for deps not in any ancestor node_modules
-                depPrefix = `${nodeModulesPrefix}/${depName}`;
+                // Transitive dep that npm placed in a NESTED node_modules
+                // (not hoisted to an ancestor of htmlDir). nodeModulesPrefix
+                // tracks that nested location through the recursion. Use it
+                // when the package physically resolves there — this is a
+                // path under the app's node_modules tree that the browser
+                // can actually fetch (junctions traverse transparently).
+                const nestedCandidate = `${nodeModulesPrefix}/${depName}`;
+                if (fs.existsSync(path.join(htmlDir, nestedCandidate))) {
+                    depPrefix = nestedCandidate;
+                }
+            }
+            if (!depPrefix) {
+                // Last resort: not found in any node_modules at all (e.g. a
+                // file: dep with no junction). Use the resolved real path —
+                // which may escape the app dir; the RED FLAG below catches that.
+                const rel = path.relative(htmlDir, depPath).split(path.sep).join('/');
+                depPrefix = rel.startsWith('.') ? rel : `./${rel}`;
+            }
+            // RED FLAG: a `../`-escaping path leaves the HTML file's
+            // directory. The dev server's served root rarely extends
+            // above the app dir, so the browser will almost certainly
+            // 404 on it and the page breaks. We still emit the entry
+            // (it's the only real location we found), but flag it in
+            // the generated HTML so the breakage is not silent.
+            if (depPrefix.startsWith('../')) {
+                const warning = `${depName} -> ${depPrefix}/${entryFile} escapes the app directory; the browser will likely fail to load it unless the dev server serves a high-enough root. Add ${depName} to the app's node_modules.`;
+                console.warn(`${ts()} [generate-importmap] Warning: ${warning}`);
+                warnings.push(warning);
             }
             dependencies.set(depName, `${depPrefix}/${entryFile}`);
+            // Bug 3: trailing-slash variant for deep imports
+            // (`import "pkg/sub.js"` requires `"pkg/": "<root>/"`).
+            // Harmless when unused — browsers only fetch what's imported.
+            dependencies.set(`${depName}/`, `${depPrefix}/`);
             // Recursively process this dependency's dependencies
             collectDependencies(depPackageJsonPath, visited, dependencies, htmlDir, `${depPrefix}/node_modules`, warnings, depPaths);
         }
@@ -241,71 +344,113 @@ if (import.meta.main) {
     const unknownArgs = args.filter(a => a.startsWith('-') && !knownFlags.has(a));
     if (unknownArgs.length > 0) {
         console.error(`${ts()} [importgen] Error: unrecognized argument(s): ${unknownArgs.join(', ')}`);
-        console.error(`  Usage: importgen [htmlfile] [-w|--watch] [-v|--version]`);
+        console.error(`  Usage: importgen [htmlfile...] [-w|--watch] [-v|--version]`);
         process.exit(1);
     }
     const watchMode = args.includes('-w') || args.includes('--watch');
     const positionalArgs = args.filter(a => !a.startsWith('-'));
-    if (positionalArgs.length > 1) {
-        console.error(`${ts()} [importgen] Error: too many arguments: ${positionalArgs.join(', ')}`);
-        console.error(`  Usage: importgen [htmlfile] [-w|--watch] [-v|--version]`);
-        process.exit(1);
-    }
-    const htmlArg = positionalArgs[0];
-    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    // Bug 5: accept multiple HTML targets. Each gets its own import map
+    // with paths rewritten relative to that file's directory. Useful for
+    // multi-page apps where each html has its own document/module context
+    // (e.g. mailx: index.html, compose/compose.html, …).
     const possibleHtmlFiles = ['index.html', 'default.html', 'default.htm'];
-    const htmlFileName = htmlArg || possibleHtmlFiles.find(f => fs.existsSync(path.join(process.cwd(), f)));
-    const htmlFilePath = htmlFileName ? path.join(process.cwd(), htmlFileName) : null;
-    if (!fs.existsSync(packageJsonPath)) {
-        console.error(`${ts()} [generate-importmap] Error: package.json not found in current directory`);
+    const htmlFileNames = positionalArgs.length > 0
+        ? positionalArgs
+        : (() => {
+            const found = possibleHtmlFiles.find(f => fs.existsSync(path.join(process.cwd(), f)));
+            return found ? [found] : [];
+        })();
+    const htmlFilePaths = htmlFileNames.map(n => path.resolve(process.cwd(), n));
+    // Find the right package.json for resolving deps. Walking up to the
+    // FIRST one is wrong when the html lives in a workspace child (e.g.
+    // `app/client/index.html` — `client/package.json` declares only the
+    // local workspace's direct deps; the runtime deps the html actually
+    // uses are declared in the workspace ROOT's package.json one level up).
+    //
+    // Strategy: walk up; prefer the OUTERMOST package.json that has a
+    // `workspaces` field (= monorepo root). Fall back to the nearest one
+    // when no workspace ancestor exists. Both cases pick correctly.
+    function findEffectivePackageJson(startDir) {
+        let nearest = null;
+        let workspaceRoot = null;
+        let dir = startDir;
+        while (true) {
+            const candidate = path.join(dir, 'package.json');
+            if (fs.existsSync(candidate)) {
+                if (!nearest)
+                    nearest = candidate;
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+                    if (pkg.workspaces)
+                        workspaceRoot = candidate;
+                }
+                catch { /* malformed — skip */ }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return workspaceRoot ?? nearest;
+    }
+    if (htmlFilePaths.length === 0) {
+        console.error(`${ts()} [generate-importmap] Error: No HTML file found. Looking for: ${possibleHtmlFiles.join(', ')}`);
         process.exit(1);
     }
-    if (!htmlFilePath || !fs.existsSync(htmlFilePath)) {
-        if (htmlArg) {
-            console.error(`${ts()} [generate-importmap] Error: ${htmlArg} not found in current directory`);
+    for (const p of htmlFilePaths) {
+        if (!fs.existsSync(p)) {
+            console.error(`${ts()} [generate-importmap] Error: ${p} not found`);
+            process.exit(1);
         }
-        else {
-            console.error(`${ts()} [generate-importmap] Error: No HTML file found. Looking for: ${possibleHtmlFiles.join(', ')}`);
-        }
-        process.exit(1);
     }
+    // Resolve effective package.json per html file (typically the same
+    // for all targets in a single project, but compute per-file to handle
+    // mixed cases).
+    const targets = htmlFilePaths.map(htmlPath => {
+        const pkgPath = findEffectivePackageJson(path.dirname(htmlPath)) ?? path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            console.error(`${ts()} [generate-importmap] Error: no package.json found from ${path.dirname(htmlPath)} or any ancestor`);
+            process.exit(1);
+        }
+        return { htmlPath, pkgPath };
+    });
+    const uniquePkgPaths = Array.from(new Set(targets.map(t => t.pkgPath)));
     if (watchMode) {
-        let result = generateImportMap(packageJsonPath, htmlFilePath);
         let watchedDepDirs = new Set();
-        const watcher = chokidar.watch([packageJsonPath], {
+        const watcher = chokidar.watch(uniquePkgPaths, {
             persistent: true,
             ignoreInitial: true
         });
-        function syncWatchedDeps(depDirs) {
-            const newDirs = new Set(depDirs);
+        function regenerateAll() {
+            const newDirs = new Set();
+            for (const t of targets) {
+                const r = generateImportMap(t.pkgPath, t.htmlPath);
+                for (const d of r.depDirs)
+                    newDirs.add(d);
+            }
             for (const dir of watchedDepDirs) {
-                if (!newDirs.has(dir)) {
+                if (!newDirs.has(dir))
                     watcher.unwatch(dir);
-                }
             }
             for (const dir of newDirs) {
-                if (!watchedDepDirs.has(dir)) {
+                if (!watchedDepDirs.has(dir))
                     watcher.add(dir);
-                }
             }
             watchedDepDirs = newDirs;
         }
-        syncWatchedDeps(result.depDirs);
+        regenerateAll();
         let debounceTimer = null;
         const onChange = () => {
             if (debounceTimer)
                 clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(() => {
-                result = generateImportMap(packageJsonPath, htmlFilePath);
-                syncWatchedDeps(result.depDirs);
-            }, 100);
+            debounceTimer = setTimeout(regenerateAll, 100);
         };
         watcher.on('change', onChange);
         watcher.on('add', onChange);
         watcher.on('unlink', onChange);
         watcher.on('ready', () => {
-            const total = 1 + watchedDepDirs.size;
-            console.log(`${ts()} [generate-importmap] Watching ${total} directories for changes...`);
+            const total = uniquePkgPaths.length + watchedDepDirs.size;
+            console.log(`${ts()} [generate-importmap] Watching ${total} directories for changes (${targets.length} HTML target${targets.length === 1 ? '' : 's'})...`);
             if (watchedDepDirs.size > 0) {
                 for (const dir of watchedDepDirs) {
                     console.log(`  ${dir}`);
@@ -317,7 +462,9 @@ if (import.meta.main) {
         });
     }
     else {
-        generateImportMap(packageJsonPath, htmlFilePath);
+        for (const t of targets) {
+            generateImportMap(t.pkgPath, t.htmlPath);
+        }
     }
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/importgen",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Generate ES Module import maps from package.json dependencies for native browser module loading",
   "main": "index.js",
   "types": "./index.d.ts",