@bobfrankston/npmglobalize 1.0.203 → 1.0.205

package/lib.js

@@ -2383,23 +2383,43 @@ function migrateTsconfigDeprecations(cwd, snapshot) {
     };
     const note = (msg) => console.log(colors.cyan(`  ${msg}`));
     let changed = false;
-    // moduleResolution: node/node10/classic → nodenext (+ align module).
+    // moduleResolution: node/node10/classic → NodeNext (+ align module).
     const mr = effectiveCompilerOption(chain, 'moduleResolution');
     if (mr && typeof mr.value === 'string' && DEPRECATED_MODULE_RESOLUTION.has(mr.value.toLowerCase())) {
         const tgt = targetFor(mr.definedIn);
-        if (tgt && edit(tgt.path, t => upsertCompilerOption(t, 'moduleResolution', '"nodenext"'))) {
+        if (tgt && edit(tgt.path, t => upsertCompilerOption(t, 'moduleResolution', `"${CANONICAL_NODENEXT}"`))) {
             changed = true;
-            note(`Migrated moduleResolution "${mr.value}" → "nodenext" in ${path.relative(cwd, tgt.path) || 'tsconfig.json'}`);
+            note(`Migrated moduleResolution "${mr.value}" → "${CANONICAL_NODENEXT}" in ${path.relative(cwd, tgt.path) || 'tsconfig.json'}`);
             // nodenext resolution requires a matching module setting.
             const mod = effectiveCompilerOption(chain, 'module');
             const modOk = mod && typeof mod.value === 'string' && /^(node16|nodenext|preserve)$/i.test(mod.value);
             if (!modOk) {
                 const modTgt = mod ? targetFor(mod.definedIn) : mostLeafWritable;
-                if (modTgt && edit(modTgt.path, t => upsertCompilerOption(t, 'module', '"nodenext"'))) {
-                    note(`Aligned module → "nodenext" (required by moduleResolution "nodenext")`);
+                if (modTgt && edit(modTgt.path, t => upsertCompilerOption(t, 'module', `"${CANONICAL_NODENEXT}"`))) {
+                    note(`Aligned module → "${CANONICAL_NODENEXT}" (required by moduleResolution "${CANONICAL_NODENEXT}")`);
                 }
             }
-            recordBuildIssue(name, 'warning', `Migrated moduleResolution "${mr.value}" → "nodenext". Verify relative imports resolve (NodeNext requires explicit file extensions on relative specifiers).`);
+            recordBuildIssue(name, 'warning', `Migrated moduleResolution "${mr.value}" → "${CANONICAL_NODENEXT}". Verify relative imports resolve (NodeNext requires explicit file extensions on relative specifiers).`);
+        }
+    }
+    // Canonical casing for values we write ourselves. TypeScript reads these
+    // case-insensitively, but the JSON schema behind editor linting (webhint,
+    // "Microsoft Edge Tools") only accepts the documented spelling, so an
+    // all-lowercase "nodenext" we wrote earlier shows up as an error in the
+    // editor even though the build is fine.
+    for (const key of ['module', 'moduleResolution']) {
+        const opt = effectiveCompilerOption(chain, key);
+        if (!opt || typeof opt.value !== 'string')
+            continue;
+        const canonical = CANONICAL_CASING[opt.value.toLowerCase()];
+        if (!canonical || canonical === opt.value)
+            continue;
+        const def = chain.find(c => c.path === opt.definedIn);
+        if (!def?.writable)
+            continue; // an override would be noise, not a fix
+        if (edit(def.path, t => upsertCompilerOption(t, key, `"${canonical}"`))) {
+            changed = true;
+            note(`Normalized ${key} "${opt.value}" → "${canonical}" in ${path.relative(cwd, def.path) || 'tsconfig.json'}`);
         }
     }
     // target: es3 → es2022 (es3 is removed in TS7).
@@ -2429,6 +2449,103 @@ function migrateTsconfigDeprecations(cwd, snapshot) {
     }
     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 and let the build try again, rather than
+ *  leaving the user to decode `replaceAll` and `toSorted` errors by hand. The
+ *  level asked for only decides *whether* to raise; what we write is
+ *  `RAISED_ES_LEVEL`, so the next new method used doesn't start this over.
+ *
+ *  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 = [RAISED_ES_LEVEL, ...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 ${RAISED_ES_LEVEL} — the code uses standard-library APIs newer than the tsconfig allowed (needs ${required}).`);
+        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', `"${RAISED_ES_LEVEL}"`)))
+        return false;
+    console.log(colors.cyan(`  Raised target "${current}" → "${RAISED_ES_LEVEL}" in ${path.relative(cwd, tgt.path) || 'tsconfig.json'} (build needs ${required})`));
+    recordBuildIssue(name, 'warning', `Raised "target" ${current} → ${RAISED_ES_LEVEL} — the code uses standard-library APIs newer than the tsconfig allowed (needs ${required}).`);
+    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
@@ -3052,6 +3169,16 @@ export async function buildProject(cwd, opts = {}) {
             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
@@ -3143,6 +3270,18 @@ export async function buildFileDepsTopologically(cwd, opts = {}, visited = new S
 }
 /** `moduleResolution` values TypeScript 6 deprecated and TypeScript 7 removes. */
 const DEPRECATED_MODULE_RESOLUTION = new Set(['node', 'node10', 'classic']);
+/** Spelling the tsconfig JSON schema — and so the editor linting built on it,
+ *  e.g. webhint via "Microsoft Edge Tools" — expects for the values we write.
+ *  TypeScript reads them case-insensitively; the schema does not. Deliberately
+ *  limited to the values npmglobalize writes itself: re-casing whatever the user
+ *  hand-typed would be churn, not a fix. */
+const CANONICAL_NODENEXT = 'NodeNext';
+const CANONICAL_CASING = { nodenext: CANONICAL_NODENEXT, node16: 'Node16' };
+/** Level we raise a too-old `target`/`lib` to. These are Node packages built and
+ *  run on the current Node, so tracking the newest language level costs nothing
+ *  and saves a re-raise every time the code picks up a newer standard-library
+ *  method. */
+const RAISED_ES_LEVEL = 'ESNext';
 /** Compiler flags TypeScript deprecated (TS5101) and will remove in TS7. Their
  *  mere presence — at any value — is a migration item. */
 const DEPRECATED_TS7_FLAGS = [

package/package.json

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