ts-node-pack 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-node-pack",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Pack a TypeScript package into a Node-compatible npm tarball without modifying the source tree",
   "keywords": [
     "cli",

package/src/index.js

@@ -83,21 +83,20 @@ export async function tsNodePack(
     log(`Copied ${packFiles.length} file(s) into staging`);
 
     // ── Phase 4: Decide whether to run tsc, generate config if so ────────
-    // Three conditions trigger declaration emit:
-    //   1. user passed --tsconfig (explicit opt-in)
-    //   2. tsconfig.build.json exists (agoric convention for opt-in)
-    //   3. any source contains .ts/.tsx/.mts (we'd be stripping them
-    //      anyway, and probably want their declarations)
-    // For pure JS+JSDoc packages with only `tsconfig.json` and no .ts
-    // sources, this skips tsc entirely — matching what `npm pack` would
-    // have done before ts-node-pack: ship .js files, no .d.ts.
+    // Trigger declaration emit only when there's something to derive:
+    //   1. user passed --tsconfig (explicit opt-in), OR
+    //   2. any source contains .ts/.tsx/.mts (we'd be stripping them
+    //      anyway, and probably want their declarations).
+    // The mere presence of tsconfig.build.json is NOT enough — monorepos
+    // commonly keep one per package for a root project-references build
+    // (`tsc --build`) without intending each package to be independently
+    // emit-able. Pure JS+JSDoc packages with no .ts sources skip tsc and
+    // ship whatever .js files are already in the packlist, matching plain
+    // `npm pack` semantics.
     const hasTsSources = packFiles.some(
       (f) => /\.(ts|tsx|mts)$/.test(f) && !/\.d\.(ts|mts)$/.test(f),
     );
-    const isExplicitOptIn =
-      tsconfigPath !== null &&
-      (tsconfig !== undefined || basename(tsconfigPath) === "tsconfig.build.json");
-    const shouldRunTsc = tsconfigPath !== null && (isExplicitOptIn || hasTsSources);
+    const shouldRunTsc = tsconfigPath !== null && (tsconfig !== undefined || hasTsSources);
 
     if (shouldRunTsc) {
       log("Phase 4: Generating derived tsconfig...");
@@ -107,8 +106,21 @@ export async function tsNodePack(
       // location. Pin typeRoots when that directory exists. (TS 6.0
       // surfaces the missing resolution as TS2688 instead of the silent
       // "Cannot find module 'node:util'" cascade of earlier versions.)
-      const atTypesDir = join(packageDir, "node_modules", "@types");
-      const hasAtTypes = existsSync(atTypesDir);
+      // Walk upward to find the nearest ancestor that actually has
+      // node_modules/@types. Yarn 4's pnpm linker keeps `@types` only at
+      // the workspace root, so the package's own node_modules is empty.
+      const findAtTypes = (start        )                => {
+        let dir = start;
+        while (true) {
+          const candidate = join(dir, "node_modules", "@types");
+          if (existsSync(candidate)) return candidate;
+          const parent = dirname(dir);
+          if (parent === dir) return null;
+          dir = parent;
+        }
+      };
+      const atTypesDir = findAtTypes(packageDir);
+      const hasAtTypes = atTypesDir !== null;
       const emitConfig = {
         extends: tsconfigPath,
         compilerOptions: {
@@ -236,14 +248,33 @@ function findLocalBin(startDir, name) {
   }
 }
 
-async function runTsc(emitConfigPath, cwd, log) {
+async function findLocalTsc(cwd) {
   // Prefer a local tsc so users control the compiler version (and to avoid
   // npx resolving to macOS's /usr/bin/tsc — the TeX/Smalltalk compiler —
   // when no local install exists). In a monorepo, the package's own
   // node_modules/.bin may be empty while the workspace root has the
   // binary, so walk upward the same way npm's `$PATH` composition does.
   const binName = process.platform === "win32" ? "tsc.cmd" : "tsc";
-  const localTsc = findLocalBin(cwd, binName);
+  const fromBin = findLocalBin(cwd, binName);
+  if (fromBin !== null) return fromBin;
+  // Yarn 4's pnpm/PnP linkers do not populate node_modules/.bin/. Fall back
+  // to `yarn bin tsc`, which resolves through the active linker and prints
+  // the absolute path of the tsc binary when the workspace depends on it.
+  try {
+    const { stdout } = await execFileAsync("yarn", ["bin", "tsc"], {
+      cwd,
+      maxBuffer: 1024 * 1024,
+    });
+    const candidate = stdout.trim().split("\n").pop();
+    if (candidate && existsSync(candidate)) return candidate;
+  } catch {
+    // `yarn` not on PATH or not a yarn project — fall through to npx.
+  }
+  return null;
+}
+
+async function runTsc(emitConfigPath, cwd, log) {
+  const localTsc = await findLocalTsc(cwd);
   const useLocal = localTsc !== null;
   const [cmd, argv] = useLocal
     ? [localTsc, ["-p", emitConfigPath]]
@@ -503,15 +534,21 @@ export function rewritePackageJson(pkg) {
   delete result.scripts;
 
   // Rewrite entry points
+  const originalMain = result.main;
   if (result.main) result.main = rewriteTsToJs(result.main);
   if (result.module) result.module = rewriteTsToJs(result.module);
+  const mainWasTs = result.main !== originalMain;
 
-  // Rewrite or derive types
+  // Only synthesize a `types` field from `main` when `main` was a .ts
+  // source (a .d.ts will be emitted alongside the .js). For pure JS+JSDoc
+  // packages, inventing `"./index.d.ts"` would point at a file that
+  // ts-node-pack never creates — see @endo/ses-ava in agoric/endo, where
+  // this produced a dangling types pointer in published tarballs.
   if (result.types) {
     result.types = rewriteTsToDts(result.types);
   } else if (result.typings) {
     result.typings = rewriteTsToDts(result.typings);
-  } else if (result.main) {
+  } else if (mainWasTs) {
     result.types = result.main.replace(/\.js$/, ".d.ts");
   }