@bobfrankston/npmglobalize 1.0.189 → 1.0.191

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}`));
@@ -428,9 +440,7 @@ function printBuildSummary() {
 export async function main() {
     installCleanupHandlers();
     // Show version at the very start
-    const ownPkgPath = path.join(__dirname, 'package.json');
-    const ownPkg = JSON.parse(fs.readFileSync(ownPkgPath, 'utf-8'));
-    console.log(styleText('cyan', `npmglobalize v${ownPkg.version}`));
+    console.log(styleText('cyan', `npmglobalize v${NPMGLOBALIZE_VERSION}`));
     const args = process.argv.slice(2);
     const cliOptions = parseArgs(args);
     if (cliOptions.help) {

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,15 +1965,20 @@ 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
@@ -2102,6 +2107,55 @@ function ensureTsconfigNodeTypes(cwd) {
     }
     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
  *  failures. Returns true if build succeeded (or was skipped because no
@@ -2136,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;
@@ -2497,6 +2561,15 @@ function diagnoseBuildFailure(errorText, cwd) {
         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
     if (!diagnosed && /error TS\d+/.test(errorText)) {
         console.error(colors.yellow('\n  Hint: TypeScript compilation errors. Fix the type errors above before publishing.'));

package/package.json

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