@bobfrankston/importgen 0.1.27 → 0.1.29

package/README.md

@@ -103,6 +103,25 @@ The browser sees `date-utils`, looks it up in the import map, and loads `./node_
 
 The key point: your TypeScript source files are the same whether they run in Node or the browser. `importgen` just provides the mapping the browser needs to find the packages.
 
+## Programmatic API
+
+`importgen` can be called from another application (e.g., `npmglobalize`) instead of the CLI:
+
+```typescript
+import { importgen } from "@bobfrankston/importgen";
+
+// Generate import map for a specific directory
+importgen("/path/to/my/app");
+
+// With explicit HTML filename
+importgen("/path/to/my/app", "default.htm");
+
+// Uses process.cwd() if no directory given
+importgen();
+```
+
+The function throws on missing `package.json` or HTML file (instead of calling `process.exit`), so callers can handle errors. Returns a `GenerateResult` with resolved dependency directories.
+
 ## How Entry Points Are Resolved
 
 For each dependency, `importgen` reads that package's `package.json` and picks the entry point in this order:

package/index.d.ts

@@ -3,5 +3,15 @@
  * Generate ES Module import map from package.json dependencies
  * Injects into HTML files for native browser module loading
  */
-export {};
+/** Result from generateImportMap including paths for watch mode */
+export interface GenerateResult {
+    depDirs: string[]; /** Resolved dependency directories */
+}
+/**
+ * API: run importgen on a directory.
+ * @param appDir - directory containing package.json and HTML file (defaults to cwd)
+ * @param htmlFile - HTML filename to update (auto-detected if omitted)
+ * @returns GenerateResult with resolved dependency directories
+ */
+export declare function importgen(appDir?: string, htmlFile?: string): GenerateResult;
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -5,7 +5,6 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { execSync } from 'node:child_process';
 import chokidar from 'chokidar';
 import packageJson from './package.json' with { type: 'json' };
 /** Timestamp prefix for log messages */
@@ -201,226 +200,115 @@ 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.
+ * API: run importgen on a directory.
+ * @param appDir - directory containing package.json and HTML file (defaults to cwd)
+ * @param htmlFile - HTML filename to update (auto-detected if omitted)
+ * @returns GenerateResult with resolved dependency directories
  */
-function freezeDependencies(packageJsonPath) {
-    const nodeModulesDir = path.join(process.cwd(), 'node_modules');
-    if (!fs.existsSync(nodeModulesDir)) {
-        console.error(`${ts()} [importgen] Error: node_modules not found`);
-        process.exit(1);
+export function importgen(appDir, htmlFile) {
+    const dir = appDir || process.cwd();
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error(`package.json not found in ${dir}`);
     }
-    /** 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(`${ts()} [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(`${ts()}   Freezing ${displayName} (${target})`);
-        fs.rmSync(entryPath, { recursive: true });
-        fs.cpSync(target, entryPath, { recursive: true });
-    }
-    console.log(`${ts()} [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(`${ts()} [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) {
-            // Rename existing preinstall so unfreeze can restore it
-            pkg.scripts['frozen-preinstall'] = pkg.scripts.preinstall;
-            console.log(`${ts()} [importgen] Saved existing preinstall script as "frozen-preinstall"`);
-        }
-        pkg.scripts.preinstall = 'echo FROZEN: dependencies were frozen by importgen. Use importgen --unfreeze to restore. && exit 1';
-        fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
-        console.log(`${ts()} [importgen] Added preinstall guard to package.json`);
-    }
-    catch (e) {
-        console.error(`${ts()} [importgen] Error updating package.json: ${e.message}`);
+    const possibleHtmlFiles = ['index.html', 'default.html', 'default.htm'];
+    const htmlName = htmlFile || possibleHtmlFiles.find(f => fs.existsSync(path.join(dir, f)));
+    const htmlPath = htmlName ? path.join(dir, htmlName) : null;
+    if (!htmlPath || !fs.existsSync(htmlPath)) {
+        throw new Error(htmlFile
+            ? `${htmlFile} not found in ${dir}`
+            : `No HTML file found in ${dir}. Looking for: ${possibleHtmlFiles.join(', ')}`);
     }
+    return generateImportMap(pkgPath, htmlPath);
 }
-/**
- * Unfreeze: remove preinstall guard, restore original preinstall if saved, then run npm install.
- */
-function unfreezeDependencies(packageJsonPath) {
-    try {
-        const pkgRaw = fs.readFileSync(packageJsonPath, 'utf-8');
-        const pkg = JSON.parse(pkgRaw);
-        if (!pkg.scripts?.preinstall) {
-            console.log(`${ts()} [importgen] No preinstall guard found — nothing to unfreeze`);
-            return;
-        }
-        if (pkg.scripts['frozen-preinstall']) {
-            pkg.scripts.preinstall = pkg.scripts['frozen-preinstall'];
-            delete pkg.scripts['frozen-preinstall'];
-            console.log(`${ts()} [importgen] Restored original preinstall script`);
-        }
-        else {
-            delete pkg.scripts.preinstall;
-            console.log(`${ts()} [importgen] Removed preinstall guard`);
-        }
-        fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+// CLI entry point
+if (import.meta.main) {
+    const args = process.argv.slice(2);
+    if (args.includes('-v') || args.includes('--version')) {
+        console.log(`importgen ${packageJson.version}`);
+        process.exit(0);
     }
-    catch (e) {
-        console.error(`${ts()} [importgen] Error updating package.json: ${e.message}`);
+    const knownFlags = new Set(['-w', '--watch', '-v', '--version']);
+    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]`);
         process.exit(1);
     }
-    // Run npm install to restore proper dependencies
-    console.log(`${ts()} [importgen] Running npm install...`);
-    try {
-        execSync('npm install', { stdio: 'inherit', cwd: process.cwd() });
-        console.log(`${ts()} [importgen] Unfreeze complete`);
-    }
-    catch (e) {
-        console.error(`${ts()} [importgen] npm install failed: ${e.message}`);
+    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);
     }
-}
-// Parse CLI arguments
-const args = process.argv.slice(2);
-if (args.includes('-v') || args.includes('--version')) {
-    console.log(`importgen ${packageJson.version}`);
-    process.exit(0);
-}
-const knownFlags = new Set(['-w', '--watch', '--freeze', '-freeze', '--unfreeze', '-unfreeze', '-v', '--version']);
-// Report unrecognized flags as errors
-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] [--freeze] [--unfreeze] [-v|--version]`);
-    process.exit(1);
-}
-const watchMode = args.includes('-w') || args.includes('--watch');
-const freezeMode = args.includes('--freeze') || args.includes('-freeze');
-const unfreezeMode = args.includes('--unfreeze') || args.includes('-unfreeze');
-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] [--freeze] [--unfreeze] [-v|--version]`);
-    process.exit(1);
-}
-const htmlArg = positionalArgs[0];
-const packageJsonPath = path.join(process.cwd(), 'package.json');
-// Resolve HTML file: explicit argument, or search for common names
-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;
-// Check if files exist
-if (!fs.existsSync(packageJsonPath)) {
-    console.error(`${ts()} [generate-importmap] Error: package.json not found in current directory`);
-    process.exit(1);
-}
-if (freezeMode) {
-    freezeDependencies(packageJsonPath);
-    process.exit(0);
-}
-if (unfreezeMode) {
-    unfreezeDependencies(packageJsonPath);
-    process.exit(0);
-}
-if (!htmlFilePath || !fs.existsSync(htmlFilePath)) {
-    if (htmlArg) {
-        console.error(`${ts()} [generate-importmap] Error: ${htmlArg} not found in current directory`);
-    }
-    else {
-        console.error(`${ts()} [generate-importmap] Error: No HTML file found. Looking for: ${possibleHtmlFiles.join(', ')}`);
+    const htmlArg = positionalArgs[0];
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    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`);
+        process.exit(1);
     }
-    process.exit(1);
-}
-if (watchMode) {
-    let result = generateImportMap(packageJsonPath, htmlFilePath);
-    let watchedDepDirs = new Set();
-    const watcher = chokidar.watch([packageJsonPath], {
-        persistent: true,
-        ignoreInitial: true
-    });
-    /** Update watcher to include/remove dependency directories */
-    function syncWatchedDeps(depDirs) {
-        const newDirs = new Set(depDirs);
-        // Remove dirs no longer in dependency list
-        for (const dir of watchedDepDirs) {
-            if (!newDirs.has(dir)) {
-                watcher.unwatch(dir);
-            }
+    if (!htmlFilePath || !fs.existsSync(htmlFilePath)) {
+        if (htmlArg) {
+            console.error(`${ts()} [generate-importmap] Error: ${htmlArg} not found in current directory`);
         }
-        // Add new dirs
-        for (const dir of newDirs) {
-            if (!watchedDepDirs.has(dir)) {
-                watcher.add(dir);
-            }
+        else {
+            console.error(`${ts()} [generate-importmap] Error: No HTML file found. Looking for: ${possibleHtmlFiles.join(', ')}`);
         }
-        watchedDepDirs = newDirs;
+        process.exit(1);
     }
-    syncWatchedDeps(result.depDirs);
-    let debounceTimer = null;
-    const onChange = () => {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
-            result = generateImportMap(packageJsonPath, htmlFilePath);
-            syncWatchedDeps(result.depDirs);
-        }, 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...`);
-        if (watchedDepDirs.size > 0) {
+    if (watchMode) {
+        let result = generateImportMap(packageJsonPath, htmlFilePath);
+        let watchedDepDirs = new Set();
+        const watcher = chokidar.watch([packageJsonPath], {
+            persistent: true,
+            ignoreInitial: true
+        });
+        function syncWatchedDeps(depDirs) {
+            const newDirs = new Set(depDirs);
             for (const dir of watchedDepDirs) {
-                console.log(`  ${dir}`);
+                if (!newDirs.has(dir)) {
+                    watcher.unwatch(dir);
+                }
             }
+            for (const dir of newDirs) {
+                if (!watchedDepDirs.has(dir)) {
+                    watcher.add(dir);
+                }
+            }
+            watchedDepDirs = newDirs;
         }
-    });
-    watcher.on('error', (error) => {
-        console.error(`${ts()} [generate-importmap] Watcher error:`, error.message);
-    });
-}
-else {
-    generateImportMap(packageJsonPath, htmlFilePath);
+        syncWatchedDeps(result.depDirs);
+        let debounceTimer = null;
+        const onChange = () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(() => {
+                result = generateImportMap(packageJsonPath, htmlFilePath);
+                syncWatchedDeps(result.depDirs);
+            }, 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...`);
+            if (watchedDepDirs.size > 0) {
+                for (const dir of watchedDepDirs) {
+                    console.log(`  ${dir}`);
+                }
+            }
+        });
+        watcher.on('error', (error) => {
+            console.error(`${ts()} [generate-importmap] Watcher error:`, error.message);
+        });
+    }
+    else {
+        generateImportMap(packageJsonPath, htmlFilePath);
+    }
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@bobfrankston/importgen",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Generate ES Module import maps from package.json dependencies for native browser module loading",
   "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
   "bin": {
     "importgen": "index.js"
   },
   "type": "module",
   "scripts": {
+    "start": "node index.js --watch",
     "build": "tsc",
     "watch": "tsc -w",
     "preversion": "npm run build",

package/.claude/settings.local.json

@@ -1,17 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run build:*)",
-      "Bash(npmglobalize)",
-      "Bash(npx tsc)",
-      "Bash(node index.js:*)",
-      "Bash(dir:*)",
-      "Bash(ls:*)",
-      "Bash(where extractids:*)",
-      "Bash(cd \"y:/dev/utils/importgen\" && npx tsc --noEmit 2>&1222)",
-      "Bash(cd y:/dev/utils/importgen && npm run release 2>&1exit)",
-      "Bash(cd y:/dev/utils/importgen && npx tsc --noEmit 2>&1)",
-      "Bash(cd:*)"
-    ]
-  }
-}