@bobfrankston/npmglobalize 1.0.202 → 1.0.204

package/lib.js

@@ -42,6 +42,16 @@ const _buildIssues = [];
 export function recordBuildIssue(module, severity, message) {
     _buildIssues.push({ module, severity, message });
 }
+/** How many issues have been recorded so far — pair with `dropBuildIssuesFrom`
+ *  to un-record issues for an action that was subsequently undone. */
+function markBuildIssues() {
+    return _buildIssues.length;
+}
+/** Drop every issue recorded after `mark` (see `markBuildIssues`). */
+function dropBuildIssuesFrom(mark) {
+    if (mark >= 0 && mark < _buildIssues.length)
+        _buildIssues.length = mark;
+}
 /** Get all accumulated build issues */
 export function getBuildIssues() {
     return _buildIssues;
@@ -2323,8 +2333,12 @@ function ensureTsconfigNodeTypes(cwd) {
  *  most-leaf writable config so it wins. This is a *semantic* change: the rebuild
  *  may now surface genuine resolution errors — that is the point. Those are real
  *  bugs the `node10` resolver was hiding, not deprecations. Returns true if it
- *  changed any file. */
-function migrateTsconfigDeprecations(cwd) {
+ *  changed any file.
+ *
+ *  Pass `snapshot` to capture each touched file's original text (path → text)
+ *  before it is rewritten, so the caller can put the tsconfigs back if the
+ *  migrated build turns out to be worse than the un-migrated one. */
+function migrateTsconfigDeprecations(cwd, snapshot) {
     const tsconfigPath = path.join(cwd, 'tsconfig.json');
     if (!fs.existsSync(tsconfigPath))
         return false;
@@ -2358,6 +2372,8 @@ function migrateTsconfigDeprecations(cwd) {
             return false;
         try {
             fs.writeFileSync(filePath, patched);
+            if (snapshot && !snapshot.has(filePath))
+                snapshot.set(filePath, text);
             return true;
         }
         catch (error) {
@@ -2413,6 +2429,131 @@ function migrateTsconfigDeprecations(cwd) {
     }
     return changed;
 }
+/** Ordering of ES language levels as they appear in `target`/`lib`. Anything
+ *  unknown ranks 0 so it never looks newer than what the build asked for. */
+const ES_LEVEL_RANK = {
+    es3: 3, es5: 5, es6: 6, es2015: 6, es7: 7, es2016: 7, es2017: 8, es2018: 9,
+    es2019: 10, es2020: 11, es2021: 12, es2022: 13, es2023: 14, es2024: 15,
+    es2025: 16, esnext: 99,
+};
+const esLevelRank = (value) => ES_LEVEL_RANK[value.toLowerCase().replace(/\.full$/, '')] ?? 0;
+/** tsc says "Try changing the 'lib' compiler option to 'es2023' or later"
+ *  (TS2550/TS2583/TS2584) when the code uses a standard-library API newer than
+ *  the configured level. That isn't a deprecation — it's a tsconfig the language
+ *  moved past — so raise the level to whatever the build asked for and let it
+ *  try again, rather than leaving the user to decode `replaceAll` and `toSorted`
+ *  errors by hand.
+ *
+ *  We raise `target`: its implied `lib` keeps the DOM declarations a bare
+ *  `lib: ["es2023"]` would silently drop. An explicit `lib` overrides `target`
+ *  though, so when one is set we raise its `es*` entry in place and keep the
+ *  rest (dom, webworker, …). Reads the required level from `buildOutput`;
+ *  returns true if it changed any file. */
+function raiseTsconfigLibLevel(cwd, buildOutput, snapshot) {
+    let required = '';
+    for (const m of buildOutput.matchAll(/'lib' compiler option to '([A-Za-z0-9.]+)'/g)) {
+        if (esLevelRank(m[1]) > esLevelRank(required))
+            required = m[1].toLowerCase();
+    }
+    if (!required)
+        return false;
+    const tsconfigPath = path.join(cwd, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath))
+        return false;
+    const { chain } = resolveTsconfigChain(tsconfigPath);
+    if (!chain.length)
+        return false;
+    const mostLeafWritable = chain.find(c => c.writable);
+    if (!mostLeafWritable)
+        return false;
+    const name = (() => { try {
+        return readPackageJson(cwd).name;
+    }
+    catch {
+        return null;
+    } })() || path.basename(cwd);
+    const edit = (filePath, fn) => {
+        let text;
+        try {
+            text = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return false;
+        }
+        const patched = fn(text);
+        if (patched == null || patched === text)
+            return false;
+        try {
+            fs.writeFileSync(filePath, patched);
+            if (snapshot && !snapshot.has(filePath))
+                snapshot.set(filePath, text);
+            return true;
+        }
+        catch (error) {
+            console.error(colors.yellow(`  Could not write tsconfig patch (${filePath}): ${error.message}`));
+            return false;
+        }
+    };
+    /** The file to edit for an option: where it's defined if that's writable,
+     *  else the most-leaf writable config, where an override wins. */
+    const targetFor = (definedIn) => {
+        const def = definedIn ? chain.find(c => c.path === definedIn) : null;
+        return def?.writable ? def : mostLeafWritable;
+    };
+    // An explicit `lib` beats `target`, so it's the one that has to move.
+    const lib = effectiveCompilerOption(chain, 'lib');
+    if (lib && Array.isArray(lib.value)) {
+        const entries = lib.value.filter((e) => typeof e === 'string');
+        if (entries.some(e => esLevelRank(e) >= esLevelRank(required)))
+            return false;
+        const raised = [required, ...entries.filter(e => esLevelRank(e) === 0)];
+        const tgt = targetFor(lib.definedIn);
+        if (!edit(tgt.path, t => upsertCompilerOption(t, 'lib', JSON.stringify(raised).replace(/","/g, '", "'))))
+            return false;
+        console.log(colors.cyan(`  Raised lib [${entries.join(', ')}] → [${raised.join(', ')}] in ${path.relative(cwd, tgt.path) || 'tsconfig.json'} (build needs ${required})`));
+        recordBuildIssue(name, 'warning', `Raised "lib" to ${required} — the code uses standard-library APIs newer than the tsconfig allowed.`);
+        return true;
+    }
+    const tg = effectiveCompilerOption(chain, 'target');
+    const current = tg && typeof tg.value === 'string' ? tg.value : 'es5'; // tsc's own default
+    if (esLevelRank(current) >= esLevelRank(required))
+        return false;
+    const tgt = targetFor(tg?.definedIn);
+    if (!edit(tgt.path, t => upsertCompilerOption(t, 'target', `"${required}"`)))
+        return false;
+    console.log(colors.cyan(`  Raised target "${current}" → "${required}" in ${path.relative(cwd, tgt.path) || 'tsconfig.json'} (build needs it)`));
+    recordBuildIssue(name, 'warning', `Raised "target" ${current} → ${required} — the code uses standard-library APIs newer than the tsconfig allowed.`);
+    return true;
+}
+/** Write back the texts captured in a `migrateTsconfigDeprecations` snapshot
+ *  (path → text). Used to undo a migration whose build turned out worse, and to
+ *  re-apply it afterwards. Returns false if any write failed — the tree is then
+ *  in a mixed state, which the caller reports rather than hides. */
+function restoreTsconfigTexts(texts) {
+    let ok = true;
+    for (const [filePath, text] of texts) {
+        try {
+            fs.writeFileSync(filePath, text);
+        }
+        catch (error) {
+            ok = false;
+            console.error(colors.yellow(`  Could not restore tsconfig (${filePath}): ${error.message}`));
+        }
+    }
+    return ok;
+}
+/** Current text of every file in a snapshot, so a migration can be re-applied
+ *  after being tried in reverse. */
+function readTsconfigTexts(paths) {
+    const out = new Map();
+    for (const p of paths) {
+        try {
+            out.set(p, fs.readFileSync(p, 'utf-8'));
+        }
+        catch { /* gone — nothing to re-apply */ }
+    }
+    return out;
+}
 /** Newest mtime of any regular file under `dir` (recursive). Symlinks/junctions
  *  are not followed — the file: dep webs here link back into sibling checkouts. */
 function newestMtimeUnder(dir) {
@@ -2913,15 +3054,29 @@ export async function buildProject(cwd, opts = {}) {
     // 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;
         shouldBuild = tsconfig.compilerOptions?.noEmit !== true;
     }
     catch {
         // No tsconfig — skip
     }
+    // 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;
     try {
         earlyPkg = readPackageJson(cwd);
@@ -2974,7 +3129,9 @@ export async function buildProject(cwd, opts = {}) {
     // freshness — one the user declined to wire in isn't this build's business.
     const finalBuild = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build : '';
     const wiredSubs = detectSubProjects(cwd).filter(s => scriptBuildsSubProject(finalBuild, s.dir));
-    if (!opts.forceBuild && isBuildUpToDate(cwd) && areSubProjectsUpToDate(cwd, wiredSubs)
+    // A migration just changed how modules resolve — never report that as fresh;
+    // the rebuild is what validates it (and what the revert path above needs).
+    if (!opts.forceBuild && !migratedUpFront && isBuildUpToDate(cwd) && areSubProjectsUpToDate(cwd, wiredSubs)
         && (!runsImportgen || isImportMapUpToDate(cwd))) {
         console.log(colors.dim(`– Build up to date (${pkg.name || path.basename(cwd)})`));
         return true;
@@ -2987,10 +3144,51 @@ export async function buildProject(cwd, opts = {}) {
         // We don't silence with ignoreDeprecations — the retry may now surface real
         // resolution errors, which are genuine bugs to fix, not deprecations.
         const out = (buildResult.stderr || '') + (buildResult.output || '');
-        if (/error TS510[17]\b/.test(out) && migrateTsconfigDeprecations(cwd)) {
+        if (/error TS510[17]\b/.test(out) && migrateTsconfigDeprecations(cwd, tsconfigSnapshot)) {
             buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
         }
     }
+    // "Try changing the 'lib' compiler option to 'es2023' or later" — a tsconfig
+    // pinned below the standard-library APIs the code actually uses. Raise it and
+    // rebuild. Looped because one level can uncover the need for a higher one,
+    // and bounded because each pass must raise the level to run again.
+    for (let pass = 0; pass < 3 && !buildResult.success; pass++) {
+        const out = (buildResult.stderr || '') + (buildResult.output || '');
+        if (!raiseTsconfigLibLevel(cwd, out, tsconfigSnapshot))
+            break;
+        buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
+    }
+    if (!buildResult.success && migratedUpFront && tsconfigSnapshot.size) {
+        // The up-front migration is a semantic change: `nodenext` resolution can
+        // surface real errors (missing file extensions on relative imports) that
+        // `node10` was hiding. Those are genuine bugs — but they are not this
+        // publish's business, and silently breaking a build that worked a moment
+        // ago is worse than leaving the deprecation in place. So put the
+        // tsconfigs back, and if that restores a working build, hand the user
+        // the errors plus the command that migrates for real.
+        const migratedOutput = (buildResult.stderr || '') + (buildResult.output || '');
+        const migratedTexts = readTsconfigTexts(tsconfigSnapshot.keys());
+        if (restoreTsconfigTexts(tsconfigSnapshot)) {
+            const retry = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
+            if (retry.success) {
+                dropBuildIssuesFrom(issueMark); // the migration was undone; its warnings no longer apply
+                const firstErr = extractFirstTscError(migratedOutput);
+                const label = pkg.name || path.basename(cwd);
+                console.log(colors.yellow(`  Reverted the tsconfig TS7 migration in ${label} — it broke the build:`));
+                if (firstErr)
+                    console.log(colors.yellow(`    ${firstErr}`));
+                console.log(colors.yellow(`    Deprecated settings left in place. Fix with: npmglobalize ${cwd} -tsfix`));
+                recordBuildIssue(label, 'warning', `tsconfig still uses settings TypeScript 7 removes: migrating to "nodenext" broke the build (${firstErr || 'see build output'}). Run \`npmglobalize ${cwd} -tsfix\` and fix the surfaced imports.`);
+                buildResult = retry;
+            }
+            else {
+                // The build was already failing for its own reasons — the migration
+                // isn't what broke it, so keep the migrated (TS7-ready) tsconfigs
+                // and report the migrated build's failure.
+                restoreTsconfigTexts(migratedTexts);
+            }
+        }
+    }
     if (buildResult.success) {
         console.log(colors.green(`✓ Build succeeded (${pkg.name || path.basename(cwd)})`));
         return true;

package/package.json

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