@bobfrankston/npmglobalize 1.0.188 → 1.0.189

package/lib.js

@@ -1975,71 +1975,132 @@ function insertTypesIntoTsconfig(text, typesArr) {
     // Inline single-line object: `{ "target": ... }`
     return text.slice(0, braceEnd) + ` "types": ${arrLiteral},` + text.slice(braceEnd);
 }
+/** `@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')
-        return;
-    // Respect any explicit choice; never override a user-set `types`.
-    if (co.types !== undefined)
+    if (!fs.existsSync(tsconfigPath))
         return;
-    // `extends` may already supply `types`; a local array would override it, so leave it.
-    if (parsed.extends !== undefined)
+    const { chain, truncated } = resolveTsconfigChain(tsconfigPath);
+    if (!chain.length)
         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')))
+    // Respect an explicit `types` anywhere in the resolved chain.
+    if (chain.some(c => c.parsed?.compilerOptions?.types !== undefined))
         return;
-    let installed;
-    try {
-        installed = fs.readdirSync(typesDir, { withFileTypes: true })
-            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-            .map(e => e.name);
-    }
-    catch {
+    // Couldn't fully resolve the chain → a hidden base may set `types`; don't risk it.
+    if (truncated)
         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"`);
 }
 /** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
  *  TypeScript project lacks a build script, run `npm run build`, record
@@ -2433,6 +2494,7 @@ 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: TypeScript compilation error

package/package.json

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