@bobfrankston/npmglobalize 1.0.218 → 1.0.219

package/README.md

@@ -756,7 +756,7 @@ As with import maps, these have historically been built only by a second `.vscod
 Before building, `npmglobalize` looks for sub-projects, in this order:
 
 1. `.vscode/tasks.json` has a task that runs `tsc` or `importgen` with `"options": { "cwd": "${workspaceFolder}/client" }`, or runs `tsc` with `-p`/`--project` naming a sub-directory (authoritative — it's how the project is actually built today; the task's `label` is quoted back in the prompt).
-2. An immediate sub-directory containing its own `package.json` build script or `tsconfig.json`. Build output and vendored trees (`node_modules`, `prev`, `dist`, `built`, `out`, `wwwroot`, `coverage`, `temp`, `preflight`, dot-directories) are never scanned.
+2. An immediate sub-directory containing its own `package.json` or `tsconfig.json`. A sub-package without a build script gets one set up the same way the root does (importgen, `tsc`, its own sub-projects) before the root delegates to it. Build output and vendored trees (`node_modules`, `prev`, `dist`, `built`, `out`, `wwwroot`, `coverage`, `temp`, `preflight`, dot-directories) are never scanned.
 
 Nothing is detected when the root `tsconfig.json` uses project `references` — that build graph belongs to `tsc -b` and isn't second-guessed.
 

package/lib.d.ts

@@ -430,7 +430,7 @@ export declare function ensureImportgenInBuild(cwd: string): Promise<void>;
 /** A sub-directory the root build must build, and how. */
 interface SubProject {
     dir: string; /** Relative directory with its on-disk casing */
-    kind: 'package' | 'tsconfig'; /** package: delegate to its build script; tsconfig: `tsc -p` */
+    kind: 'package' | 'tsconfig'; /** package: has its own package.json, delegate to its build script; tsconfig: `tsc -p` */
     reason: string; /** The signal that found it, quoted in prompts */
 }
 /** Sub-directories the root build must build itself. A package can hold more
@@ -452,11 +452,20 @@ export declare function detectSubProjects(cwd: string): SubProject[];
  *  own idea of what to compile. Declining records `subProjects: false` in
  *  .globalize.json5. */
 export declare function ensureSubProjectsInBuild(cwd: string): Promise<void>;
-/** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
- *  TypeScript project lacks a build script, run `npm run build`, record
- *  failures. Returns true if build succeeded (or was skipped because no
- *  tsconfig / noEmit / no build script after declining the prompt / output
- *  already up to date). Pass `forceBuild` to skip the freshness check. */
+/** Make sure `cwd`'s package.json has the build script it needs: importgen
+ *  for an importgen project, `tsc` for a TypeScript project (prompted), and a
+ *  step per sub-project. Returns the package plus whether the script runs
+ *  importgen, or null when there is nothing to build here (no package.json, no
+ *  tsconfig or `noEmit` and no importgen, or the user declined the prompt). */
+export declare function ensureBuildScript(cwd: string): Promise<{
+    pkg: any;
+    runsImportgen: boolean;
+} | null>;
+/** Build a single project: set up its build script (see `ensureBuildScript`),
+ *  run `npm run build`, record failures. Returns true if build succeeded (or
+ *  was skipped because there was nothing to build / the user declined the
+ *  build-script prompt / output already up to date). Pass `forceBuild` to
+ *  skip the freshness check. */
 export declare function buildProject(cwd: string, opts?: {
     verbose?: boolean;
     force?: boolean;

package/lib.js

@@ -3198,17 +3198,12 @@ function resolveOnDiskCase(base, rel) {
     }
     return out.length ? out.join('/') : null;
 }
-/** Classify `rel` under `cwd`: a package with its own build script, a plain
- *  tsconfig sub-project, or null when it's neither. */
+/** Classify `rel` under `cwd`: a package (its own package.json — its build
+ *  script is set up by `ensureBuildScript` if it lacks one), a plain tsconfig
+ *  sub-project, or null when it's neither. */
 function subProjectKind(cwd, rel) {
-    try {
-        const pkg = readPackageJson(path.join(cwd, rel));
-        if (typeof pkg?.scripts?.build === 'string' && pkg.scripts.build.trim())
-            return 'package';
-    }
-    catch {
-        // No package.json there — fall through to the tsconfig test
-    }
+    if (fs.existsSync(path.join(cwd, rel, 'package.json')))
+        return 'package';
     return fs.existsSync(path.join(cwd, rel, 'tsconfig.json')) ? 'tsconfig' : null;
 }
 /** The command the root build script runs for a sub-project. */
@@ -3303,7 +3298,7 @@ export function detectSubProjects(cwd) {
                 continue;
             const kind = subProjectKind(cwd, e.name);
             if (kind)
-                add(e.name, kind === 'package' ? `${e.name}/package.json has a build script` : `${e.name}/tsconfig.json`);
+                add(e.name, kind === 'package' ? `${e.name}/package.json` : `${e.name}/tsconfig.json`);
         }
     }
     catch {
@@ -3328,6 +3323,20 @@ function configuredSubProjects(cwd, config) {
     }
     return detectSubProjects(cwd);
 }
+/** The sub-projects the root build should run, each ready to be run: a
+ *  sub-package gets its own build script set up first (importgen, tsc, its own
+ *  sub-projects — the same setup the root gets), and one that still has
+ *  nothing to build afterwards is left out, since delegating to it would only
+ *  fail with "missing script: build". */
+async function readySubProjects(cwd, config) {
+    const ready = [];
+    for (const s of configuredSubProjects(cwd, config)) {
+        if (s.kind === 'package' && !(await ensureBuildScript(path.join(cwd, s.dir))))
+            continue;
+        ready.push(s);
+    }
+    return ready;
+}
 /** Quote a path for a package.json script only when it needs it. */
 function quoteScriptPath(p) {
     return /[\s&|<>]/.test(p) ? `"${p}"` : p;
@@ -3351,14 +3360,8 @@ export async function ensureSubProjectsInBuild(cwd) {
     const buildScript = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build.trim() : '';
     if (!buildScript || !scriptRunsTsc(buildScript))
         return;
-    const subs = configuredSubProjects(cwd, config);
-    // A sub-package owns its own import map: give its build script the same
-    // importgen check the root gets, so delegating to it is enough.
-    for (const s of subs) {
-        if (s.kind === 'package')
-            await ensureImportgenInBuild(path.join(cwd, s.dir));
-    }
-    const missing = subs.filter(s => !scriptBuildsSubProject(buildScript, s.dir));
+    const missing = (await readySubProjects(cwd, config))
+        .filter(s => !scriptBuildsSubProject(buildScript, s.dir));
     if (missing.length === 0)
         return;
     const name = pkg.name || path.basename(cwd);
@@ -3367,7 +3370,7 @@ export async function ensureSubProjectsInBuild(cwd) {
     // — a bare nested tsconfig (tests, examples) is a weaker signal, and this
     // prompt rewrites a build script that currently works.
     const strong = missing.every(s => s.reason.startsWith('.vscode/tasks.json') || s.reason.startsWith('listed in'));
-    console.log(colors.yellow(`${name}'s build script doesn't compile ${missing.length === 1 ? 'a sub-project' : 'its sub-projects'}:`));
+    console.log(colors.yellow(`${name}'s build script doesn't build ${missing.length === 1 ? 'a sub-project' : 'its sub-projects'}:`));
     for (const s of missing)
         console.log(colors.yellow(`  ${s.dir}/ — ${s.reason}`));
     const addIt = await confirm(`Set "build": "${newScript}" in ${name}'s package.json?`, strong);
@@ -3417,76 +3420,61 @@ function areSubProjectsUpToDate(cwd, subs) {
     }
     return true;
 }
-/** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
- *  TypeScript project lacks a build script, run `npm run build`, record
- *  failures. Returns true if build succeeded (or was skipped because no
- *  tsconfig / noEmit / no build script after declining the prompt / output
- *  already up to date). Pass `forceBuild` to skip the freshness check. */
-export async function buildProject(cwd, opts = {}) {
+// 2026-09-06 — Claude Code (Fable 5.1), at Bob's direction ("when you add
+// importgen for a client dir you should set up the proper package.json").
+// Factored out of buildProject so a sub-package (itemw/client) gets the SAME
+// build-script setup as the root — importgen wired in, `tsc` added when it has
+// a tsconfig, its own sub-projects appended — instead of a second recipe.
+/** Make sure `cwd`'s package.json has the build script it needs: importgen
+ *  for an importgen project, `tsc` for a TypeScript project (prompted), and a
+ *  step per sub-project. Returns the package plus whether the script runs
+ *  importgen, or null when there is nothing to build here (no package.json, no
+ *  tsconfig or `noEmit` and no importgen, or the user declined the prompt). */
+export async function ensureBuildScript(cwd) {
     // Do this before the tsconfig check: an importgen project may be plain JS
     // with no tsconfig at all, and still need its import map regenerated.
     await ensureImportgenInBuild(cwd);
     let shouldBuild = false;
-    let hasTsconfig = false;
     try {
-        const tsconfigPath = path.join(cwd, 'tsconfig.json');
-        const content = fs.readFileSync(tsconfigPath, 'utf-8');
-        const tsconfig = JSON5.parse(content);
-        hasTsconfig = true;
+        const tsconfig = JSON5.parse(fs.readFileSync(path.join(cwd, 'tsconfig.json'), 'utf-8'));
         shouldBuild = tsconfig.compilerOptions?.noEmit !== true;
     }
     catch {
-        // No tsconfig — skip
+        // No tsconfig — nothing for tsc to do
     }
-    // Fix removed-in-TS7 tsconfig settings up front rather than waiting for a
-    // build to fail on them. A deprecated `moduleResolution` is only a *hard*
-    // error under the tsc that flags it (TS6+, and the editor's bundled
-    // compiler), so a package pinned to an older tsc — or one that never gets
-    // to the build at all (noEmit, no build script, output already fresh) —
-    // would otherwise keep the deprecation until TS7 removes it outright.
-    // Deliberately ahead of every early return below: the tsconfig is worth
-    // fixing whether or not this package builds. Migrating also touches
-    // tsconfig.json, which makes the freshness check correctly read as stale.
-    const tsconfigSnapshot = new Map();
-    const issueMark = markBuildIssues();
-    const migratedUpFront = hasTsconfig && migrateTsconfigDeprecations(cwd, tsconfigSnapshot);
-    let earlyPkg;
+    let pkg;
     try {
-        earlyPkg = readPackageJson(cwd);
+        pkg = readPackageJson(cwd);
     }
     catch {
-        return true;
+        return null;
     }
-    const runsImportgen = scriptRunsImportgen(typeof earlyPkg.scripts?.build === 'string' ? earlyPkg.scripts.build : '');
+    const runsImportgen = scriptRunsImportgen(typeof pkg.scripts?.build === 'string' ? pkg.scripts.build : '');
     // A build script that regenerates the import map is worth running even when
     // there's nothing for tsc to emit.
     if (!shouldBuild && !runsImportgen)
-        return true;
-    const pkg = earlyPkg;
+        return null;
     const existingBuild = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build.trim() : '';
     // A build script ensureImportgenInBuild just created for a package that had
     // none still needs its tsc pass — treat importgen-only as "no build yet".
     const importgenOnly = !!existingBuild && existingBuild.split(/\s*&&\s*/).every(scriptRunsImportgen);
     if (shouldBuild && (!existingBuild || importgenOnly)) {
-        // Compile the sub-projects (service worker, …) in the same breath: the
-        // root tsc excludes them, so a bare "tsc" would leave them unbuilt.
-        const subs = configuredSubProjects(cwd, readConfig(cwd));
+        // Build the sub-projects (service worker, client package, …) in the same
+        // breath: the root tsc excludes them, so a bare "tsc" would leave them unbuilt.
+        const subs = await readySubProjects(cwd, readConfig(cwd));
         const tscParts = ['tsc', ...subs.map(subProjectBuildCommand)];
         const newScript = [...(existingBuild ? [existingBuild] : []), ...tscParts].join(' && ');
         console.log(colors.yellow(`TypeScript project has no "build" script in ${pkg.name || cwd}`));
         for (const s of subs)
             console.log(colors.yellow(`  sub-project ${s.dir}/ — ${s.reason}`));
         const addIt = await confirm(`Add "build": "${newScript}" to ${pkg.name || path.basename(cwd)}'s package.json?`, true);
-        if (addIt) {
-            if (!pkg.scripts)
-                pkg.scripts = {};
-            pkg.scripts.build = newScript;
-            writePackageJson(cwd, pkg);
-            console.log(colors.green(`✓ Added "build": "${newScript}" to ${pkg.name || path.basename(cwd)}`));
-        }
-        else {
-            return true;
-        }
+        if (!addIt)
+            return null;
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        pkg.scripts.build = newScript;
+        writePackageJson(cwd, pkg);
+        console.log(colors.green(`✓ Added "build": "${newScript}" to ${pkg.name || path.basename(cwd)}`));
     }
     else if (existingBuild) {
         await ensureSubProjectsInBuild(cwd);
@@ -3498,6 +3486,30 @@ export async function buildProject(cwd, opts = {}) {
         catch { /* keep the script we already have */ }
     }
     ensureTsconfigNodeTypes(cwd);
+    return { pkg, runsImportgen };
+}
+/** Build a single project: set up its build script (see `ensureBuildScript`),
+ *  run `npm run build`, record failures. Returns true if build succeeded (or
+ *  was skipped because there was nothing to build / the user declined the
+ *  build-script prompt / output already up to date). Pass `forceBuild` to
+ *  skip the freshness check. */
+export async function buildProject(cwd, opts = {}) {
+    // Fix removed-in-TS7 tsconfig settings up front rather than waiting for a
+    // build to fail on them. A deprecated `moduleResolution` is only a *hard*
+    // error under the tsc that flags it (TS6+, and the editor's bundled
+    // compiler), so a package pinned to an older tsc — or one that never gets
+    // to the build at all (noEmit, no build script, output already fresh) —
+    // would otherwise keep the deprecation until TS7 removes it outright.
+    // Deliberately ahead of every early return below: the tsconfig is worth
+    // fixing whether or not this package builds. Migrating also touches
+    // tsconfig.json, which makes the freshness check correctly read as stale.
+    const tsconfigSnapshot = new Map();
+    const issueMark = markBuildIssues();
+    const migratedUpFront = fs.existsSync(path.join(cwd, 'tsconfig.json')) && migrateTsconfigDeprecations(cwd, tsconfigSnapshot);
+    const setup = await ensureBuildScript(cwd);
+    if (!setup)
+        return true;
+    const { pkg, runsImportgen } = setup;
     // Only the sub-projects the final build script really compiles count toward
     // freshness — one the user declined to wire in isn't this build's business.
     const finalBuild = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.218",
+  "version": "1.0.219",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",