ts-node-pack 0.2.0 → 0.2.1

package/package.json

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

package/src/index.js

@@ -15,7 +15,8 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import packlist from "npm-packlist";
 import tsBlankSpace from "ts-blank-space";
-import { TS_SPECIFIER_PATTERNS, rewriteTsSpecifiers } from "./rewrite-specifiers.js";
+import { rewriteTsSpecifiers } from "./rewrite-specifiers.js";
+import { validate } from "./validation.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -595,7 +596,7 @@ export function rewritePackageJson(pkg) {
   } else if (result.typings) {
     result.typings = rewriteTsToDts(result.typings);
   } else if (mainWasTs) {
-    result.types = result.main.replace(/\.js$/, ".d.ts");
+    result.types = rewriteTsToDts(originalMain);
   }
 
   // Rewrite bin
@@ -617,7 +618,7 @@ export function rewritePackageJson(pkg) {
   // Rewrite files array
   if (Array.isArray(result.files)) {
     result.files = result.files.flatMap((f) => {
-      if (typeof f === "string" && /\.tsx?$/.test(f)) {
+      if (typeof f === "string" && TS_SOURCE_EXT_RE.test(f)) {
         return [rewriteTsToJs(f), rewriteTsToDts(f)];
       }
       return [f];
@@ -627,14 +628,22 @@ export function rewritePackageJson(pkg) {
   return result;
 }
 
+// `.ts`/`.tsx` → `.js`; `.mts` → `.mjs`. Matches what `ts-blank-space`
+// writes in Phase 6 and the specifier-rewrite pass in rewrite-specifiers.ts.
 function rewriteTsToJs(p) {
-  return typeof p === "string" ? p.replace(/\.tsx?$/, ".js") : p;
+  if (typeof p !== "string") return p;
+  return p.replace(/\.mts$/, ".mjs").replace(/\.tsx?$/, ".js");
 }
 
+// `.ts`/`.tsx` → `.d.ts`; `.mts` → `.d.mts`. Matches the declaration files
+// tsc emits from an .mts source.
 function rewriteTsToDts(p) {
-  return typeof p === "string" ? p.replace(/\.tsx?$/, ".d.ts") : p;
+  if (typeof p !== "string") return p;
+  return p.replace(/\.mts$/, ".d.mts").replace(/\.tsx?$/, ".d.ts");
 }
 
+const TS_SOURCE_EXT_RE = /\.(tsx?|mts)$/;
+
 function rewriteExportsValue(value, isTypesKey) {
   if (typeof value === "string") {
     return isTypesKey ? rewriteTsToDts(value) : rewriteTsToJs(value);
@@ -652,98 +661,6 @@ function rewriteExportsValue(value, isTypesKey) {
   return value;
 }
 
-async function validate(stagingDir, pkg, log) {
-  const errors = [];
-
-  // Check .js and .d.ts files for remaining .ts specifiers
-  const allFiles = await findFiles(
-    stagingDir,
-    (name) => name.endsWith(".js") || name.endsWith(".d.ts"),
-  );
-
-  for (const filePath of allFiles) {
-    const raw = await readFile(filePath, "utf8");
-    // Strip block and line comments before scanning so JSDoc examples that
-    // literally contain strings like `import './foo.js'` don't register as
-    // false positives. Comment stripping here is intentionally coarse
-    // (doesn't understand strings-containing-comment-markers) — good enough
-    // for tsc-emitted output, where comments are well-behaved.
-    const content = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-    const relPath = relative(stagingDir, filePath);
-
-    for (const pattern of TS_SPECIFIER_PATTERNS) {
-      for (const m of content.matchAll(pattern)) {
-        errors.push(`${relPath}: remaining .ts specifier: ${m[0]}`);
-      }
-    }
-  }
-
-  // Check package.json for .ts references in entry points
-  const entryFields = ["main", "module", "types", "typings"];
-  for (const field of entryFields) {
-    if (typeof pkg[field] === "string" && /(?<!\.d)\.tsx?$/.test(pkg[field])) {
-      errors.push(`package.json "${field}" still references .ts: ${pkg[field]}`);
-    }
-  }
-
-  // Non-fatal: yarn/npm tolerate `bin`/`main` pointing at missing
-  // files. Real transformation bugs are caught by the specifier
-  // checks above.
-  const referencedFiles = collectReferencedFiles(pkg);
-  for (const ref of referencedFiles) {
-    if (!existsSync(join(stagingDir, ref))) {
-      log(`  Warning: referenced file missing from tarball: ${ref}`);
-    }
-  }
-
-  if (errors.length > 0) {
-    const msg = "Validation failed:\n  " + errors.join("\n  ");
-    throw new Error(msg);
-  }
-
-  log(`Validated ${allFiles.length} file(s), no issues found`);
-}
-
-function collectReferencedFiles(pkg) {
-  const refs = new Set        ();
-
-  for (const field of ["main", "module", "types", "typings"]) {
-    if (typeof pkg[field] === "string") {
-      refs.add(pkg[field].replace(/^\.\//, ""));
-    }
-  }
-
-  if (typeof pkg.bin === "string") {
-    refs.add(pkg.bin.replace(/^\.\//, ""));
-  } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
-    for (const v of Object.values(pkg.bin)) {
-      if (typeof v === "string") refs.add(v.replace(/^\.\//, ""));
-    }
-  }
-
-  if (pkg.exports) {
-    collectExportsRefs(pkg.exports, refs);
-  }
-
-  return refs;
-}
-
-function collectExportsRefs(value, refs) {
-  if (typeof value === "string") {
-    refs.add(value.replace(/^\.\//, ""));
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const v of value) collectExportsRefs(v, refs);
-    return;
-  }
-  if (typeof value === "object" && value !== null) {
-    for (const v of Object.values(value)) {
-      collectExportsRefs(v, refs);
-    }
-  }
-}
-
 async function pack(stagingDir) {
   const { stdout } = await execFileAsync("npm", ["pack"], {
     cwd: stagingDir,

package/src/validation.d.ts

@@ -0,0 +1,21 @@
+export declare function validate(stagingDir: any, pkg: any, log?: (...args: unknown[]) => void): Promise<void>;
+/**
+ * Collect the relative file paths referenced by path-bearing fields of a
+ * package.json manifest, partitioned by how strictly a missing target
+ * should be treated.
+ *
+ * - `strict`: `main`, `module`, `types`, `typings`, and every leaf of
+ *   `exports`. A missing target here is a bug in the tarball we produced —
+ *   Node's module resolution will fail and `npm publish` warns on
+ *   dangling `types`.
+ * - `lenient`: `bin` entries. yarn and npm both tolerate a `bin` pointing
+ *   at a missing file (see the `bin-missing` fixture, which mirrors
+ *   agoric/portfolio-api's intentional shape).
+ *
+ * Exported for direct unit-testing of the policy; the only runtime caller
+ * is `validate()` above.
+ */
+export declare function collectReferencedFiles(pkg: any): {
+    strict: Set<string>;
+    lenient: Set<string>;
+};

package/src/validation.js

@@ -0,0 +1,146 @@
+/**
+ * Post-rewrite validation of a staged package. `validate()` is the one
+ * caller of `collectReferencedFiles`; both live here because the
+ * strict-vs-lenient partition is a policy decision owned by validation.
+ */
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { TS_SPECIFIER_PATTERNS } from "./rewrite-specifiers.js";
+
+export async function validate(
+  stagingDir,
+  pkg,
+  log                               = () => {},
+) {
+  const errors = [];
+
+  // Check .js/.mjs and .d.ts/.d.mts files for remaining .ts specifiers
+  const allFiles = await findFiles(
+    stagingDir,
+    (name) =>
+      name.endsWith(".js") ||
+      name.endsWith(".mjs") ||
+      name.endsWith(".d.ts") ||
+      name.endsWith(".d.mts"),
+  );
+
+  for (const filePath of allFiles) {
+    const raw = await readFile(filePath, "utf8");
+    // Strip block and line comments before scanning so JSDoc examples that
+    // literally contain strings like `import './foo.js'` don't register as
+    // false positives. Comment stripping here is intentionally coarse
+    // (doesn't understand strings-containing-comment-markers) — good enough
+    // for tsc-emitted output, where comments are well-behaved.
+    const content = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+    const relPath = relative(stagingDir, filePath);
+
+    for (const pattern of TS_SPECIFIER_PATTERNS) {
+      for (const m of content.matchAll(pattern)) {
+        errors.push(`${relPath}: remaining .ts specifier: ${m[0]}`);
+      }
+    }
+  }
+
+  // Check package.json for .ts references in entry points
+  const entryFields = ["main", "module", "types", "typings"];
+  for (const field of entryFields) {
+    if (typeof pkg[field] === "string" && /(?<!\.d)\.(tsx?|mts)$/.test(pkg[field])) {
+      errors.push(`package.json "${field}" still references .ts: ${pkg[field]}`);
+    }
+  }
+
+  // main/module/types/typings/exports must resolve to a file that is
+  // actually in the staging dir. This catches rewrite bugs that specifier
+  // scanning can't — e.g. the @endo/ses-ava regression where a synthesized
+  // `types: ./index.d.ts` pointed at a .d.ts ts-node-pack never emitted.
+  // `bin` is deliberately excluded: yarn/npm both tolerate a missing bin
+  // target (see the bin-missing fixture — agoric/portfolio-api ships that
+  // way intentionally), so we only warn.
+  const { strict: strictRefs, lenient: lenientRefs } = collectReferencedFiles(pkg);
+  for (const ref of strictRefs) {
+    if (!existsSync(join(stagingDir, ref))) {
+      errors.push(`referenced file missing from tarball: ${ref}`);
+    }
+  }
+  for (const ref of lenientRefs) {
+    if (!existsSync(join(stagingDir, ref))) {
+      log(`  Warning: referenced file missing from tarball: ${ref}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    const msg = "Validation failed:\n  " + errors.join("\n  ");
+    throw new Error(msg);
+  }
+
+  log(`Validated ${allFiles.length} file(s), no issues found`);
+}
+
+/**
+ * Collect the relative file paths referenced by path-bearing fields of a
+ * package.json manifest, partitioned by how strictly a missing target
+ * should be treated.
+ *
+ * - `strict`: `main`, `module`, `types`, `typings`, and every leaf of
+ *   `exports`. A missing target here is a bug in the tarball we produced —
+ *   Node's module resolution will fail and `npm publish` warns on
+ *   dangling `types`.
+ * - `lenient`: `bin` entries. yarn and npm both tolerate a `bin` pointing
+ *   at a missing file (see the `bin-missing` fixture, which mirrors
+ *   agoric/portfolio-api's intentional shape).
+ *
+ * Exported for direct unit-testing of the policy; the only runtime caller
+ * is `validate()` above.
+ */
+export function collectReferencedFiles(pkg) {
+  const strict = new Set        ();
+  const lenient = new Set        ();
+  const addStrict = (p) => strict.add(stripDotSlash(p));
+  const addLenient = (p) => lenient.add(stripDotSlash(p));
+
+  for (const field of ["main", "module", "types", "typings"]) {
+    if (typeof pkg[field] === "string") addStrict(pkg[field]);
+  }
+
+  if (typeof pkg.bin === "string") {
+    addLenient(pkg.bin);
+  } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+    for (const v of Object.values(pkg.bin)) {
+      if (typeof v === "string") addLenient(v);
+    }
+  }
+
+  if (pkg.exports) collectExportsRefs(pkg.exports, strict);
+
+  return { strict, lenient };
+}
+
+function collectExportsRefs(value, refs) {
+  if (typeof value === "string") {
+    refs.add(stripDotSlash(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const v of value) collectExportsRefs(v, refs);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const v of Object.values(value)) collectExportsRefs(v, refs);
+  }
+}
+
+function stripDotSlash(p) {
+  return p.replace(/^\.\//, "");
+}
+
+async function findFiles(dir, test) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (entry.isFile() && test(entry.name)) {
+      results.push(join(entry.parentPath, entry.name));
+    }
+  }
+  return results;
+}