@dbx-tools/projen 0.6.44 → 0.6.46

package/package.json

@@ -50,7 +50,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.44",
+  "version": "0.6.46",
   "packageManager": "pnpm@10.33.0",
   "types": "index.ts",
   "type": "module",

package/src/bun-app.ts

@@ -131,6 +131,7 @@ export class BunBuildFile extends TextFile {
       readonly: true,
       lines: String.raw`
 import { existsSync } from "node:fs";
+import { basename } from "node:path";
 import tailwind from "bun-plugin-tailwind";
 
 // Unmanaged override (${BUN_BUILD_OVERRIDE}): its default export is merged over
@@ -155,6 +156,26 @@ if (!result.success) {
   for (const message of result.logs) console.error(message);
   process.exit(1);
 }
+
+// Fix a Bun bug: with \`splitting: true\` and an HTML entrypoint, the emitted
+// HTML's <script src> is wired to an arbitrary chunk instead of the JS
+// entry-point, so the app never boots (a blank page). Rewrite the HTML script
+// (and stylesheet) to the real entry-point outputs. No-op when they already
+// match (e.g. splitting off), so it is always safe to run.
+const htmlOut = result.outputs.find((o) => o.path.endsWith(".html"));
+const entryJs = result.outputs.find((o) => o.kind === "entry-point" && o.path.endsWith(".js"));
+const entryCss = result.outputs.find((o) => o.kind === "entry-point" && o.path.endsWith(".css"));
+if (htmlOut && entryJs) {
+  let html = await Bun.file(htmlOut.path).text();
+  const jsName = basename(entryJs.path);
+  html = html.replace(/(<script[^>]*\bsrc=")([^"]*\/)?[^"/]+\.js(")/i, "$1$2" + jsName + "$3");
+  if (entryCss) {
+    const cssName = basename(entryCss.path);
+    html = html.replace(/(<link[^>]*\bhref=")([^"]*\/)?[^"/]+\.css(")/i, "$1$2" + cssName + "$3");
+  }
+  await Bun.write(htmlOut.path, html);
+}
+
 console.log("built " + result.outputs.length + " files to " + options.outdir);
 `
         .trimStart()

package/src/project.ts

@@ -913,6 +913,9 @@ function initProject(
   // them to a project. ESLint still cannot parse them.
   eslint.addIgnorePattern("**/dev.ts");
   eslint.addIgnorePattern("**/build.ts");
+  // A deploy-staging helper that lives at a package root (outside any `src/**`
+  // tsconfig), same parse-resolution problem as the bun app scripts above.
+  eslint.addIgnorePattern("**/stage-deploy.ts");
   for (const override of BUN_APP_OVERRIDES) {
     eslint.addIgnorePattern(`**/${override}`);
   }

package/tasks/publish.ts

@@ -18,8 +18,17 @@
  *     while the on-disk manifest keeps the protocols.) Setting each member's
  *     version first is the only prerequisite, so a sibling resolves the release
  *     version rather than the disk default of `0.0.0`;
- *   - **`publishConfig` substitution** (compiled `lib/` entry points) and the
- *     `prepack` (compile) run are `bun publish`'s own pack behavior.
+ *   - **`publishConfig` substitution** (compiled `lib/` entry points) is done
+ *     HERE, by {@link applyPublishConfig}, NOT by bun: unlike pnpm/npm, `bun
+ *     publish`/`bun pm pack` do NOT fold `publishConfig`'s `main`/`types`/`bin`/
+ *     `exports` into the packed manifest (verified: the packed manifest keeps the
+ *     raw `.ts` source paths and an inert `publishConfig`). Left unsubstituted, a
+ *     published CLI's `bin` points at `./bin/x.ts`, and because the bin runs via
+ *     its `#!/usr/bin/env node` shebang, node chokes on the `.ts`
+ *     (ERR_UNKNOWN_FILE_EXTENSION). We merge `publishConfig` onto the top-level
+ *     manifest before packing so the tarball advertises the compiled `lib/` tree;
+ *   - the **`prepack` (compile) run** that emits that `lib/` tree is `bun
+ *     publish`'s own pack behavior.
  *
  * `--dry-run` forwards to `bun publish`: it packs + validates (running prepack)
  * but uploads nothing, so the `release` workflow is testable end-to-end via a
@@ -32,7 +41,7 @@
  * this unlocks each only long enough to set the version + publish. The next
  * `projen` synth restores them - the release version lives in the git tag.
  */
-import { chmodSync, existsSync, readFileSync, rmSync, statSync } from "node:fs";
+import { chmodSync, existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { exec } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
@@ -70,6 +79,31 @@ function unlockManifest(pkgPath: string): void {
   chmodSync(pkgPath, statSync(pkgPath).mode | 0o200);
 }
 
+/** Entry-point fields projen writes as `.ts` source in-repo and rewrites to `lib/` for publish. */
+const PUBLISH_CONFIG_ENTRY_FIELDS = ["main", "types", "bin", "exports"] as const;
+
+/**
+ * Fold a package's `publishConfig` entry-point fields onto the top-level manifest,
+ * the way pnpm/npm do at pack time but `bun publish` does NOT (see the module
+ * doc). Idempotent, writes only when something changes, and leaves `publishConfig`
+ * in place (npm ignores it once the top-level fields already point at `lib/`). The
+ * manifest must already be unlocked. The next `projen` synth restores the `.ts`
+ * entry points, so this only affects the packed tarball - like the version stamp.
+ */
+function applyPublishConfig(pkgPath: string): void {
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, unknown>;
+  const publishConfig = pkg.publishConfig as Record<string, unknown> | undefined;
+  if (!publishConfig) return;
+  let changed = false;
+  for (const field of PUBLISH_CONFIG_ENTRY_FIELDS) {
+    if (field in publishConfig) {
+      pkg[field] = publishConfig[field];
+      changed = true;
+    }
+  }
+  if (changed) writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+}
+
 /**
  * PATH with the workspace-root `node_modules/.bin` prepended. `bun publish` runs
  * each package's `prepack` (compile) through projen's dax shell, which resolves
@@ -149,6 +183,11 @@ for (const dir of members) {
     logger.info(`skip private ${pkg.name ?? dirname(dir)}`);
     continue;
   }
+  // bun won't fold publishConfig into the packed manifest, so do it ourselves -
+  // otherwise the tarball's `bin`/`main`/`exports` stay pointed at `.ts` source.
+  const manifestPath = join(dir, "package.json");
+  unlockManifest(manifestPath);
+  applyPublishConfig(manifestPath);
   logger.info(`${dryRun ? "dry-run publishing" : "publishing"} ${pkg.name} @ ${version}`);
   run(dir, "bun", ["publish", ...publishArgs], path);
   published += 1;