@bobfrankston/npmglobalize 1.0.188 → 1.0.190

package/cli.js

@@ -8,6 +8,18 @@ import path from 'path';
 import { styleText } from 'util';
 // npmglobalize install directory (for --version)
 const __dirname = import.meta.dirname;
+/** Own version, read once. Stamped into the startup banner AND the Issues Summary
+ *  so a failure log always reveals which installed npmglobalize produced it — a
+ *  build that fails on something the source already fixes usually just means the
+ *  installed copy predates the fix. */
+const NPMGLOBALIZE_VERSION = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8')).version;
+    }
+    catch {
+        return 'unknown';
+    }
+})();
 function printHelp() {
     console.log(`
 npmglobalize - Transform file: dependencies to npm versions for publishing
@@ -417,7 +429,7 @@ function printBuildSummary() {
     if (issues.length === 0)
         return;
     console.log('');
-    console.log(styleText('yellow', '━━━ Issues Summary ━━━━━━━━━━━━━━━━━━━━'));
+    console.log(styleText('yellow', `━━━ Issues Summary (npmglobalize v${NPMGLOBALIZE_VERSION}) ━━━`));
     for (const issue of issues) {
         const icon = issue.severity === 'error' ? '✗' : '⚠';
         console.log(styleText('yellow', `  ${icon} ${issue.module}: ${issue.message}`));

package/lib.js

@@ -1947,12 +1947,12 @@ function getTscMajor() {
     catch { /* leave at 0 — can't probe, assume pre-6 (no patch) */ }
     return _tscMajor;
 }
-/** Insert a `"types": [...]` line as the first property of `compilerOptions`,
+/** Insert `"<key>": <valueLiteral>` as the first property of `compilerOptions`,
  *  preserving the file's existing formatting/comments. Returns the patched text,
  *  or null if the object couldn't be located safely (caller leaves file alone).
- *  Only ever called when `compilerOptions.types` is absent. */
-function insertTypesIntoTsconfig(text, typesArr) {
-    const arrLiteral = '[' + typesArr.map(t => JSON.stringify(t)).join(', ') + ']';
+ *  Only ever called when the key is known to be absent. */
+function insertCompilerOption(text, key, valueLiteral) {
+    const prop = `"${key}": ${valueLiteral}`;
     const m = text.match(/"compilerOptions"\s*:\s*\{/);
     if (!m)
         return null;
@@ -1965,81 +1965,196 @@ function insertTypesIntoTsconfig(text, typesArr) {
         const lineStart = text.lastIndexOf('\n', m.index) + 1;
         const baseIndent = text.slice(lineStart, m.index).match(/^\s*/)[0];
         const propIndent = baseIndent + '  ';
-        return text.slice(0, braceEnd) + '\n' + propIndent + `"types": ${arrLiteral}\n` + baseIndent + text.slice(braceEnd + ws.length);
+        return text.slice(0, braceEnd) + '\n' + propIndent + prop + '\n' + baseIndent + text.slice(braceEnd + ws.length);
     }
     // Multiline object: derive property indent from the existing first property.
     if (ws.includes('\n')) {
         const propIndent = ws.slice(ws.lastIndexOf('\n') + 1);
-        return text.slice(0, braceEnd) + '\n' + propIndent + `"types": ${arrLiteral},` + text.slice(braceEnd);
+        return text.slice(0, braceEnd) + '\n' + propIndent + prop + ',' + text.slice(braceEnd);
     }
     // Inline single-line object: `{ "target": ... }`
-    return text.slice(0, braceEnd) + ` "types": ${arrLiteral},` + text.slice(braceEnd);
+    return text.slice(0, braceEnd) + ` ${prop},` + text.slice(braceEnd);
+}
+/** Insert a `"types": [...]` line as the first property of `compilerOptions`.
+ *  Only ever called when `compilerOptions.types` is absent. */
+function insertTypesIntoTsconfig(text, typesArr) {
+    return insertCompilerOption(text, 'types', '[' + typesArr.map(t => JSON.stringify(t)).join(', ') + ']');
+}
+/** `@types/*` packages that inject *global* declarations (usable with no
+ *  `import`). TS6 stopped auto-including these, so under TS6+ they must be named
+ *  in `compilerOptions.types`. Module-only types (`express`, `ws`, `nodemailer`,
+ *  ...) resolve through ordinary import resolution and never need listing — so we
+ *  deliberately do NOT enumerate every installed `@types/*`. `node` is always
+ *  added; the rest below are added only when actually installed. */
+const GLOBAL_AUGMENTING_TYPES = ['jest', 'mocha', 'jasmine', 'bun'];
+/** True if `@types/<name>` is resolvable from `start` or any ancestor's
+ *  `node_modules` — handles npm-workspace hoisting where `@types` live at the
+ *  monorepo root rather than the leaf package. */
+function atTypesInstalled(start, name) {
+    let dir = path.resolve(start);
+    for (;;) {
+        if (fs.existsSync(path.join(dir, 'node_modules', '@types', name)))
+            return true;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+}
+/** Resolve a tsconfig's `extends` chain into an ordered list (the file itself
+ *  first, then each base it extends). Local (non-`node_modules`) entries are
+ *  marked `writable`. `truncated` is true when an `extends` could not be read or
+ *  resolved (e.g. a package specifier or an array) — the caller then can't be
+ *  sure an inherited `types` doesn't exist, so it stays its hand. Cycle- and
+ *  depth-guarded. */
+function resolveTsconfigChain(tsconfigPath) {
+    const chain = [];
+    const seen = new Set();
+    let current = path.resolve(tsconfigPath);
+    let truncated = false;
+    for (let depth = 0; current && !seen.has(current) && depth < 16; depth++) {
+        seen.add(current);
+        let parsed;
+        try {
+            parsed = JSON5.parse(fs.readFileSync(current, 'utf-8'));
+        }
+        catch {
+            truncated = true;
+            break;
+        }
+        chain.push({ path: current, parsed, writable: !/[\\/]node_modules[\\/]/.test(current) });
+        const ext = parsed?.extends;
+        if (ext === undefined)
+            break; // natural end of chain
+        if (typeof ext !== 'string') {
+            truncated = true;
+            break;
+        } // array/object — not followed
+        // Resolve relative to the current file's directory. A bare/extensionless
+        // value may name a directory (→ tsconfig.json) or an extensionless file.
+        const baseDir = path.dirname(current);
+        let next;
+        if (ext.endsWith('.json'))
+            next = path.resolve(baseDir, ext);
+        else {
+            const asDir = path.resolve(baseDir, ext, 'tsconfig.json');
+            next = fs.existsSync(asDir) ? asDir : path.resolve(baseDir, ext + '.json');
+        }
+        if (!fs.existsSync(next)) {
+            truncated = true;
+            break;
+        } // e.g. a node_modules package specifier
+        current = next;
+    }
+    return { chain, truncated };
 }
 /** TypeScript 6 dropped the legacy behavior of auto-including every installed
- *  `@types/*` package. A tsconfig with no explicit `compilerOptions.types` then
- *  loses the Node globals (`process`, `Buffer`, ...), breaking the build with
- *  `TS2591`. When building under TS6+, add an explicit `types` list enumerating
- *  the installed `@types/*` (restoring the old behavior). Idempotent and
- *  conservative — only patches when `types` is absent, `@types/node` is actually
- *  installed, and there is no `extends` (whose merged `types` we can't see). */
+ *  `@types/*` package globally. A tsconfig with no explicit `compilerOptions.types`
+ *  then loses the Node globals (`process`, `Buffer`, ...), breaking the build with
+ *  `TS2591`. When building under TS6+, add an explicit, *minimal* `types` list
+ *  (Node plus any installed global-augmenting test types) to restore them.
+ *
+ *  Generalized for monorepos: it resolves the full `extends` chain, respects a
+ *  `types` set anywhere in that chain, finds `@types/node` even when hoisted to a
+ *  workspace-root `node_modules`, and writes the patch to the *base-most writable*
+ *  config so one edit fixes every package that shares the base (falling back to
+ *  the leaf config when the base lives in `node_modules`). Idempotent and
+ *  conservative — bails when the chain can't be fully resolved (an inherited
+ *  `types` might be hiding) or when `@types/node` isn't installed. */
 function ensureTsconfigNodeTypes(cwd) {
     if (getTscMajor() < 6)
         return;
     const tsconfigPath = path.join(cwd, 'tsconfig.json');
-    let text;
-    try {
-        text = fs.readFileSync(tsconfigPath, 'utf-8');
-    }
-    catch {
-        return;
-    }
-    let parsed;
-    try {
-        parsed = JSON5.parse(text);
-    }
-    catch {
-        return;
-    }
-    const co = parsed?.compilerOptions;
-    if (!co || typeof co !== 'object')
+    if (!fs.existsSync(tsconfigPath))
         return;
-    // Respect any explicit choice; never override a user-set `types`.
-    if (co.types !== undefined)
+    const { chain, truncated } = resolveTsconfigChain(tsconfigPath);
+    if (!chain.length)
         return;
-    // `extends` may already supply `types`; a local array would override it, so leave it.
-    if (parsed.extends !== undefined)
+    // Respect an explicit `types` anywhere in the resolved chain.
+    if (chain.some(c => c.parsed?.compilerOptions?.types !== undefined))
         return;
-    // Gate on @types/node actually being installed so the list resolves and we
-    // only touch genuine Node projects.
-    const typesDir = path.join(cwd, 'node_modules', '@types');
-    if (!fs.existsSync(path.join(typesDir, 'node')))
+    // Couldn't fully resolve the chain → a hidden base may set `types`; don't risk it.
+    if (truncated)
         return;
-    let installed;
-    try {
-        installed = fs.readdirSync(typesDir, { withFileTypes: true })
-            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-            .map(e => e.name);
-    }
-    catch {
-        return;
-    }
-    if (!installed.length)
+    // Only genuine Node projects, incl. workspace-hoisted @types at the repo root.
+    if (!atTypesInstalled(cwd, 'node'))
         return;
-    // node first, rest sorted, for a stable readable list.
-    installed.sort();
-    const typesArr = ['node', ...installed.filter(n => n !== 'node')];
-    const patched = insertTypesIntoTsconfig(text, typesArr);
-    if (!patched) {
-        recordBuildIssue(parsed.name || path.basename(cwd), 'warning', `TS6+ build may fail: couldn't locate compilerOptions in ${tsconfigPath} to add explicit "types"`);
+    // Minimal correct list: Node globals + any installed global-augmenting types.
+    const typesArr = ['node', ...GLOBAL_AUGMENTING_TYPES.filter(n => atTypesInstalled(cwd, n))];
+    // Prefer the base-most writable config (DRY: one edit fixes the whole workspace),
+    // then walk toward the leaf, patching the first whose compilerOptions we can edit.
+    const candidates = chain.filter(c => c.writable).reverse();
+    for (const cand of candidates) {
+        let text;
+        try {
+            text = fs.readFileSync(cand.path, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const patched = insertTypesIntoTsconfig(text, typesArr);
+        if (!patched)
+            continue;
+        try {
+            fs.writeFileSync(cand.path, patched);
+            const where = path.relative(cwd, cand.path) || 'tsconfig.json';
+            console.log(colors.cyan(`  Patched ${where}: added "types": [${typesArr.join(', ')}] (TypeScript ${_tscMajor}+ no longer auto-includes @types/*)`));
+        }
+        catch (error) {
+            console.error(colors.yellow(`  Could not write tsconfig patch (${cand.path}): ${error.message}`));
+        }
         return;
     }
-    try {
-        fs.writeFileSync(tsconfigPath, patched);
-        console.log(colors.cyan(`  Patched tsconfig.json: added "types": [${typesArr.join(', ')}] (TypeScript ${_tscMajor}+ no longer auto-includes @types/*)`));
-    }
-    catch (error) {
-        console.error(colors.yellow(`  Could not write tsconfig.json patch: ${error.message}`));
+    recordBuildIssue(chain[0].parsed?.name || path.basename(cwd), 'warning', `TS6+ build may fail: no writable compilerOptions block in the tsconfig chain of ${cwd} to add "types"`);
+}
+/** TS6 turned several long-deprecated compiler options (e.g.
+ *  `moduleResolution: "node10"`/`"node"`/`"classic"`, old `target`s) into hard
+ *  errors (`TS5107`/`TS5101`) that will be *removed* in TS7. TypeScript's own
+ *  sanctioned bridge for the 6→7 window is `"ignoreDeprecations": "<version>"`
+ *  (the error text names the version, e.g. `"6.0"`). We apply exactly that so the
+ *  build proceeds, and record a warning so the real migration (to `node16` /
+ *  `nodenext` / `bundler`) still happens before TS7. We do NOT auto-rewrite
+ *  `moduleResolution` itself — that changes resolution semantics and must be a
+ *  human, per-package decision. Returns true if it patched a file. Mirrors
+ *  `ensureTsconfigNodeTypes`: resolves the `extends` chain, respects an existing
+ *  `ignoreDeprecations`, and patches the base-most writable config. */
+function ensureTsconfigIgnoreDeprecations(cwd, version) {
+    const tsconfigPath = path.join(cwd, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath))
+        return false;
+    const { chain, truncated } = resolveTsconfigChain(tsconfigPath);
+    if (!chain.length)
+        return false;
+    // Already set somewhere in the chain (possibly with a different version) — leave it.
+    if (chain.some(c => c.parsed?.compilerOptions?.ignoreDeprecations !== undefined))
+        return false;
+    if (truncated)
+        return false;
+    const valueLiteral = JSON.stringify(version);
+    const candidates = chain.filter(c => c.writable).reverse();
+    for (const cand of candidates) {
+        let text;
+        try {
+            text = fs.readFileSync(cand.path, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const patched = insertCompilerOption(text, 'ignoreDeprecations', valueLiteral);
+        if (!patched)
+            continue;
+        try {
+            fs.writeFileSync(cand.path, patched);
+            const where = path.relative(cwd, cand.path) || 'tsconfig.json';
+            console.log(colors.cyan(`  Patched ${where}: added "ignoreDeprecations": ${valueLiteral} (silences TS6 removed-in-TS7 deprecation errors)`));
+            recordBuildIssue(chain[0].parsed?.name || path.basename(cwd), 'warning', `Deprecated compilerOptions silenced via ignoreDeprecations=${version}. Migrate moduleResolution to "node16"/"nodenext"/"bundler" before TypeScript 7.`);
+            return true;
+        }
+        catch (error) {
+            console.error(colors.yellow(`  Could not write tsconfig patch (${cand.path}): ${error.message}`));
+        }
     }
+    return false;
 }
 /** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
  *  TypeScript project lacks a build script, run `npm run build`, record
@@ -2075,7 +2190,17 @@ export async function buildProject(cwd, opts = {}) {
     }
     ensureTsconfigNodeTypes(cwd);
     console.log(`Building ${pkg.name || cwd}...`);
-    const buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
+    let buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
+    if (!buildResult.success) {
+        // TS6 deprecation error (removed-in-TS7): apply the version TS itself names
+        // in `"ignoreDeprecations": "<v>"` and retry once.
+        const out = (buildResult.stderr || '') + (buildResult.output || '');
+        const dep = out.match(/error TS510[17]\b/) &&
+            out.match(/['"]ignoreDeprecations['"]\s*:\s*['"]([\d.]+)['"]/);
+        if (dep && ensureTsconfigIgnoreDeprecations(cwd, dep[1])) {
+            buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
+        }
+    }
     if (buildResult.success) {
         console.log(colors.green(`✓ Build succeeded (${pkg.name || path.basename(cwd)})`));
         return true;
@@ -2433,6 +2558,16 @@ function diagnoseBuildFailure(errorText, cwd) {
     if (!diagnosed && /error TS2591|Do you need to install type definitions for node/.test(errorText)) {
         console.error(colors.yellow('\n  Hint: TypeScript 6 no longer auto-includes @types/*, so Node globals (process, Buffer) are unresolved.'));
         console.error(colors.yellow(`  Fix: add  "types": ["node"]  to compilerOptions in ${path.join(cwd, 'tsconfig.json')}`));
+        console.error(colors.yellow('  In a workspace this belongs in the shared base tsconfig the package extends (only global @types like node/jest need listing; imported types resolve on their own).'));
+        diagnosed = true;
+    }
+    // Pattern: TS6 made deprecated options (moduleResolution=node10, ...) hard errors,
+    // removed in TS7. (Safety net for when the auto ignoreDeprecations patch+retry didn't fire.)
+    if (!diagnosed && /error TS510[17]\b/.test(errorText)) {
+        const v = errorText.match(/['"]ignoreDeprecations['"]\s*:\s*['"]([\d.]+)['"]/);
+        console.error(colors.yellow('\n  Hint: TypeScript 6 flags long-deprecated options that TS7 will remove.'));
+        console.error(colors.yellow(`  Bridge: add  "ignoreDeprecations": "${v ? v[1] : '6.0'}"  to compilerOptions (shared base in a workspace).`));
+        console.error(colors.yellow('  Real fix before TS7: migrate moduleResolution to "node16"/"nodenext"/"bundler".'));
         diagnosed = true;
     }
     // Pattern: TypeScript compilation error

package/package.json

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