@bobfrankston/importgen 0.1.23 → 0.1.24

package/.claude/settings.local.json

@@ -6,7 +6,9 @@
       "Bash(npx tsc)",
       "Bash(node index.js:*)",
       "Bash(dir:*)",
-      "Bash(ls:*)"
+      "Bash(ls:*)",
+      "Bash(where extractids:*)",
+      "Bash(cd \"y:/dev/utils/importgen\" && npx tsc --noEmit 2>&1222)"
     ]
   }
 }

package/index.js

@@ -135,6 +135,7 @@ function collectDependencies(packageJsonPath, visited, dependencies, htmlDir, no
     }
     catch (e) {
         console.error(`[generate-importmap] Error processing ${packageJsonPath}:`, e.message);
+        throw e; // Propagate so callers can avoid overwriting HTML with empty map
     }
 }
 function generateImportMap(packageJsonPath, htmlFilePath) {
@@ -146,7 +147,13 @@ function generateImportMap(packageJsonPath, htmlFilePath) {
         const depPaths = new Set();
         const warnings = [];
         // Recursively collect all dependencies
-        collectDependencies(packageJsonPath, visited, dependencies, htmlDir, './node_modules', warnings, depPaths);
+        try {
+            collectDependencies(packageJsonPath, visited, dependencies, htmlDir, './node_modules', warnings, depPaths);
+        }
+        catch {
+            // Root package.json unreadable (e.g., mid-write) — skip update to preserve existing HTML
+            return result;
+        }
         result.depDirs = Array.from(depPaths);
         // Convert Map to plain object for JSON
         const imports = {};
@@ -188,6 +195,88 @@ function generateImportMap(packageJsonPath, htmlFilePath) {
     }
     return result;
 }
+/**
+ * Freeze dependencies: replace junctions/symlinks in node_modules with real copies.
+ * Also adds a preinstall guard to package.json to prevent npm install from undoing the freeze.
+ */
+function freezeDependencies(packageJsonPath) {
+    const nodeModulesDir = path.join(process.cwd(), 'node_modules');
+    if (!fs.existsSync(nodeModulesDir)) {
+        console.error('[importgen] Error: node_modules not found');
+        process.exit(1);
+    }
+    /** Check if a directory entry is a junction or symlink by comparing realpath to its path */
+    function isLinked(entryPath) {
+        try {
+            const stat = fs.lstatSync(entryPath);
+            // Symlink check (works on Linux/Mac symlinks)
+            if (stat.isSymbolicLink())
+                return true;
+            // Junction check (Windows): realpath differs from the entry path
+            if (stat.isDirectory()) {
+                const real = fs.realpathSync(entryPath);
+                return path.resolve(real) !== path.resolve(entryPath);
+            }
+        }
+        catch (e) {
+            console.error(`[importgen] Error checking ${entryPath}: ${e.message}`);
+        }
+        return false;
+    }
+    /** Freeze a single entry if it's a junction/symlink */
+    function freezeEntry(entryPath, displayName) {
+        if (!isLinked(entryPath))
+            return;
+        const target = fs.realpathSync(entryPath);
+        console.log(`  Freezing ${displayName} (${target})`);
+        fs.rmSync(entryPath, { recursive: true });
+        fs.cpSync(target, entryPath, { recursive: true });
+    }
+    console.log('[importgen] Freezing dependencies...');
+    let frozenCount = 0;
+    const entries = fs.readdirSync(nodeModulesDir);
+    for (const entry of entries) {
+        const entryPath = path.join(nodeModulesDir, entry);
+        if (entry.startsWith('@')) {
+            // Scoped package — walk one level deeper
+            if (!fs.statSync(entryPath).isDirectory())
+                continue;
+            const scopedEntries = fs.readdirSync(entryPath);
+            for (const scoped of scopedEntries) {
+                const scopedPath = path.join(entryPath, scoped);
+                const before = isLinked(scopedPath);
+                freezeEntry(scopedPath, `${entry}/${scoped}`);
+                if (before)
+                    frozenCount++;
+            }
+        }
+        else {
+            const before = isLinked(entryPath);
+            freezeEntry(entryPath, entry);
+            if (before)
+                frozenCount++;
+        }
+    }
+    console.log(`[importgen] Frozen ${frozenCount} linked packages`);
+    // Add preinstall guard to package.json
+    try {
+        const pkgRaw = fs.readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(pkgRaw);
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        if (pkg.scripts.preinstall) {
+            console.warn('[importgen] Warning: preinstall script already exists, skipping guard');
+        }
+        else {
+            pkg.scripts.preinstall = 'echo FROZEN: dependencies were frozen by importgen. Remove this script before running npm install. && exit 1';
+            fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+            console.log('[importgen] Added preinstall guard to package.json');
+        }
+    }
+    catch (e) {
+        console.error(`[importgen] Error updating package.json: ${e.message}`);
+    }
+}
 // Parse CLI arguments
 const args = process.argv.slice(2);
 if (args.includes('-v') || args.includes('--version')) {
@@ -195,6 +284,7 @@ if (args.includes('-v') || args.includes('--version')) {
     process.exit(0);
 }
 const watchMode = args.includes('-w') || args.includes('--watch');
+const freezeMode = args.includes('--freeze');
 const htmlArg = args.find(a => !a.startsWith('-'));
 const packageJsonPath = path.join(process.cwd(), 'package.json');
 // Resolve HTML file: explicit argument, or search for common names
@@ -206,6 +296,10 @@ if (!fs.existsSync(packageJsonPath)) {
     console.error('[generate-importmap] Error: package.json not found in current directory');
     process.exit(1);
 }
+if (freezeMode) {
+    freezeDependencies(packageJsonPath);
+    process.exit(0);
+}
 if (!htmlFilePath || !fs.existsSync(htmlFilePath)) {
     if (htmlArg) {
         console.error(`[generate-importmap] Error: ${htmlArg} not found in current directory`);
@@ -240,9 +334,14 @@ if (watchMode) {
         watchedDepDirs = newDirs;
     }
     syncWatchedDeps(result.depDirs);
+    let debounceTimer = null;
     const onChange = () => {
-        result = generateImportMap(packageJsonPath, htmlFilePath);
-        syncWatchedDeps(result.depDirs);
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            result = generateImportMap(packageJsonPath, htmlFilePath);
+            syncWatchedDeps(result.depDirs);
+        }, 100);
     };
     watcher.on('change', onChange);
     watcher.on('add', onChange);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/importgen",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Generate ES Module import maps from package.json dependencies for native browser module loading",
   "main": "index.js",
   "bin": {
@@ -12,8 +12,10 @@
     "watch": "tsc -w",
     "preversion": "npm run build",
     "postversion": "echo Version updated to $(node -p \"require('./package.json').version\")",
-    "release": "git add -A && git diff-index --quiet HEAD || git commit -m 'Build for release' && npm version patch",
-    "installer": "npm run release && npm install -g ."
+    "release": "npmglobalize",
+    "installer": "npm run release && npm install -g .",
+    "old-release": "git add -A && git diff-index --quiet HEAD || git commit -m 'Build for release' && npm version patch",
+    "old-installer": "npm run release && npm install -g ."
   },
   "keywords": [
     "import-map",