plgg-bundle 0.0.2 → 0.0.5

package/src/domain/usecase/collectModules.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
-import { relative } from "node:path";
+import { readFileSync } from "plgg-bundle/vendors/nodeFs";
+import { relative } from "plgg-bundle/vendors/nodePath";
 import { type External } from "plgg-bundle/domain/model/BundleConfig";
 import { resolveSpecifier } from "plgg-bundle/domain/usecase/resolveSpecifier";
 import { isExternal } from "plgg-bundle/domain/usecase/isExternal";
@@ -135,7 +135,7 @@ const linkModule = (
   cjs: string,
   acc: Map<string, Module>,
 ): ReadonlyArray<string> => {
-  const specifiers = requireSpecifiers(cjs);
+  const specifiers = inlineRequireSpecifiers(file, cjs);
   const externals: string[] = [];
   const deps: string[] = [];
   let rewritten = cjs;
@@ -165,6 +165,59 @@ const linkModule = (
   return deps;
 };
 
+/**
+ * Literal requires that belong to the OUTER graph walk.
+ * Registry-installed plgg-family packages ship
+ * pre-bundled dist entries whose internal module table
+ * still contains strings like `require("src/index.ts")`.
+ * Those are parameters of the INNER registry runtime and
+ * must not be resolved or rewritten by this app bundle.
+ * Real top-level externals in that dist file remain, e.g.
+ * `require("plgg")`, and are still inlined by the app
+ * graph.
+ */
+const inlineRequireSpecifiers = (
+  file: string,
+  cjs: string,
+): ReadonlyArray<string> => {
+  const specifiers = requireSpecifiers(cjs);
+  if (!isInstalledDist(file)) {
+    return specifiers;
+  }
+  const internal = bundledModuleIds(cjs);
+  return specifiers.filter((spec) => !internal.has(spec));
+};
+
+/**
+ * Whether a file is a registry-installed built JS entry.
+ * Source packages under the monorepo are never matched.
+ */
+const isInstalledDist = (file: string): boolean => {
+  const normalized = file.split("\\").join("/");
+  return (
+    normalized.includes("/node_modules/") &&
+    normalized.includes("/dist/") &&
+    normalized.endsWith(".js")
+  );
+};
+
+/**
+ * Module ids declared inside a plgg-bundle emitted
+ * registry object: `"src/x.ts": function (...) { ... }`.
+ */
+const bundledModuleIds = (
+  cjs: string,
+): ReadonlySet<string> =>
+  new Set(
+    [
+      ...cjs.matchAll(
+        /["']([^"']+)["']\s*:\s*function\s*\(/g,
+      ),
+    ].flatMap((m) =>
+      m[1] === undefined ? [] : [m[1]],
+    ),
+  );
+
 /**
  * Read a source file, re-throwing with context.
  */

package/src/domain/usecase/deriveExternal.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync } from "plgg-bundle/vendors/nodeFs";
+import { join } from "plgg-bundle/vendors/nodePath";
 import { type External } from "plgg-bundle/domain/model/BundleConfig";
 
 /**

package/src/domain/usecase/discoverWorkspace.spec.ts

@@ -4,6 +4,13 @@ import {
   all,
   toBe,
 } from "plgg-test";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { discoverWorkspace } from "plgg-bundle/domain/usecase/discoverWorkspace";
 
@@ -61,3 +68,107 @@ test("discoverWorkspace sorts longest-name first (so plgg-view beats plgg)", ()
   );
   return check(iView < iCore, toBe(true));
 });
+
+test("discoverWorkspace finds dist-only packages installed under node_modules", () => {
+  const root = fixtureRoot();
+  try {
+    const app = join(root, "packages", "app");
+    writePackage(app, "app", true);
+    writePackage(
+      join(app, "node_modules", "plgg"),
+      "plgg",
+      false,
+    );
+    const found = discoverWorkspace(app).find(
+      (p) => p.name === "plgg",
+    );
+    return all([
+      check(found?.kind, toBe("dist")),
+      check(
+        found?.exports.get("."),
+        toBe("./dist/index.es.js"),
+      ),
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("discoverWorkspace keeps a sibling source package before an installed duplicate", () => {
+  const root = fixtureRoot();
+  try {
+    const app = join(root, "packages", "app");
+    writePackage(app, "app", true);
+    writePackage(
+      join(root, "packages", "plgg"),
+      "plgg",
+      true,
+    );
+    writePackage(
+      join(app, "node_modules", "plgg"),
+      "plgg",
+      false,
+    );
+    const found = discoverWorkspace(app).find(
+      (p) => p.name === "plgg",
+    );
+    return check(found?.kind, toBe("source"));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("discoverWorkspace finds installed deps of a sibling source package", () => {
+  const root = fixtureRoot();
+  try {
+    const app = join(root, "packages", "app");
+    writePackage(app, "app", true);
+    const local = join(root, "packages", "local");
+    writePackage(local, "local", true);
+    writePackage(
+      join(local, "node_modules", "plgg-ui"),
+      "plgg-ui",
+      false,
+    );
+    const found = discoverWorkspace(app).find(
+      (p) => p.name === "plgg-ui",
+    );
+    return check(found?.kind, toBe("dist"));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+const fixtureRoot = (): string =>
+  mkdtempSync(
+    join(tmpdir(), "plgg-bundle-discover-"),
+  );
+
+const writePackage = (
+  dir: string,
+  name: string,
+  source: boolean,
+): void => {
+  mkdirSync(source ? join(dir, "src") : join(dir, "dist"), {
+    recursive: true,
+  });
+  writeFileSync(
+    join(dir, "package.json"),
+    JSON.stringify(
+      {
+        name,
+        type: "module",
+        exports: {
+          import: {
+            default: "./dist/index.es.js",
+          },
+          require: {
+            default: "./dist/index.cjs.js",
+          },
+        },
+      },
+      null,
+      2,
+    ),
+  );
+};

package/src/domain/usecase/discoverWorkspace.ts

@@ -3,42 +3,69 @@ import {
   readFileSync,
   existsSync,
   statSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
-
-/**
- * A workspace sibling the app bundler can INLINE from
- * source: its package `name`, its `dir`, and the map from
- * each public export subpath (`"."`, `"./client"`, …) to
- * the `import.default` dist path declared in its
- * `package.json` `exports`. The app resolver reverses
- * that dist path to the entry's source file (so the
- * `./style` → `dist/styleEntry.es.js` → `src/styleEntry`
- * rename is honoured), and falls back to a self-alias
- * `name/<path>` → `src/<path>` for non-export internal
- * imports.
- */
-export type WorkspacePackage = Readonly<{
+} from "plgg-bundle/vendors/nodeFs";
+import { join, dirname } from "plgg-bundle/vendors/nodePath";
+
+/**
+ * A package the app bundler can INLINE. Monorepo
+ * siblings are inlined from `src`; registry-installed
+ * packages usually ship only `dist`, so the resolver
+ * inlines their built ESM entry instead.
+ */
+export type WorkspacePackage =
+  | SourceWorkspacePackage
+  | DistWorkspacePackage;
+
+/**
+ * A source package, usually a sibling under `packages/`.
+ * Its public export subpaths are reversed from
+ * `exports` dist paths back to `src` entries.
+ */
+export type SourceWorkspacePackage = Readonly<{
+  kind: "source";
   name: string;
   dir: string;
+  srcDir: string;
   /** export subpath (`"."` | `"./x"`) → dist default. */
   exports: ReadonlyMap<string, string>;
 }>;
 
 /**
- * Discover every sibling package under the directory that
- * holds `packageRoot` (the monorepo `packages/` dir) —
- * each entry that has a `package.json` with a `name`.
+ * A dist package, usually installed under the app's
+ * `node_modules`. It has no source in the consumer tree,
+ * so public export subpaths resolve to built ESM files.
+ */
+export type DistWorkspacePackage = Readonly<{
+  kind: "dist";
+  name: string;
+  dir: string;
+  distDir: string;
+  /** export subpath (`"."` | `"./x"`) → dist default. */
+  exports: ReadonlyMap<string, string>;
+}>;
+
+/**
+ * Discover inlineable packages visible from `packageRoot`:
+ * sibling packages under the directory that holds
+ * `packageRoot`, plus packages installed in this package's
+ * own `node_modules` and in sibling source packages'
+ * `node_modules`. Siblings are listed first and win on
+ * duplicate names so monorepo builds keep reading source.
  * Sorted longest-name-first so a later prefix match picks
- * `plgg-view` over `plgg`. Throws on a read/parse failure.
+ * `plgg-view` over `plgg`.
  */
 export const discoverWorkspace = (
   packageRoot: string,
 ): ReadonlyArray<WorkspacePackage> => {
   const siblingsDir = dirname(packageRoot);
-  return readdirSync(siblingsDir)
-    .map((name) => join(siblingsDir, name))
-    .filter(isPackageDir)
+  const siblings = packageDirsIn(siblingsDir);
+  return uniqueByName([
+    ...siblings,
+    ...packageDirsIn(join(packageRoot, "node_modules")),
+    ...siblings.flatMap((dir) =>
+      packageDirsIn(join(dir, "node_modules")),
+    ),
+  ])
     .map(readPackage)
     .flatMap((p) => (p === undefined ? [] : [p]))
     .sort(
@@ -47,8 +74,61 @@ export const discoverWorkspace = (
 };
 
 /**
- * Whether a path is a directory holding a
- * `package.json`.
+ * Direct package dirs under `dir`, including scoped
+ * `@scope/name` packages. Missing directories simply
+ * contribute no packages.
+ */
+const packageDirsIn = (
+  dir: string,
+): ReadonlyArray<string> =>
+  existsSync(dir)
+    ? readdirSync(dir).flatMap((name) =>
+        childPackageDirs(join(dir, name)),
+      )
+    : [];
+
+/**
+ * The package dirs represented by one child of a package
+ * collection directory. A scope directory fans out one
+ * level; ordinary package directories are returned as-is.
+ */
+const childPackageDirs = (
+  dir: string,
+): ReadonlyArray<string> => {
+  if (!statSync(dir).isDirectory()) {
+    return [];
+  }
+  if (isPackageDir(dir)) {
+    return [dir];
+  }
+  return readdirSync(dir)
+    .map((name) => join(dir, name))
+    .filter(isPackageDir);
+};
+
+/**
+ * Keep the first directory for each package name. The
+ * caller supplies siblings before node_modules, so a local
+ * source package beats an installed copy.
+ */
+const uniqueByName = (
+  dirs: ReadonlyArray<string>,
+): ReadonlyArray<string> => {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const dir of dirs) {
+    const name = packageName(dir);
+    if (name === undefined || seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    out.push(dir);
+  }
+  return out;
+};
+
+/**
+ * Whether a path is a directory holding a package.json.
  */
 const isPackageDir = (dir: string): boolean =>
   statSync(dir).isDirectory() &&
@@ -66,9 +146,44 @@ const readPackage = (
     join(dir, "package.json"),
   );
   const name = pkg["name"];
-  return typeof name === "string"
-    ? { name, dir, exports: exportMap(pkg) }
-    : undefined;
+  if (typeof name !== "string") {
+    return undefined;
+  }
+  const srcDir = join(dir, "src");
+  if (existsSync(srcDir)) {
+    return {
+      kind: "source",
+      name,
+      dir,
+      srcDir,
+      exports: exportMap(pkg),
+    };
+  }
+  const distDir = join(dir, "dist");
+  if (existsSync(distDir)) {
+    return {
+      kind: "dist",
+      name,
+      dir,
+      distDir,
+      exports: exportMap(pkg),
+    };
+  }
+  return undefined;
+};
+
+/**
+ * Read only the package name for de-duplication.
+ */
+const packageName = (
+  dir: string,
+): string | undefined => {
+  if (!isPackageDir(dir)) {
+    return undefined;
+  }
+  const pkg = parseJson(join(dir, "package.json"));
+  const name = pkg["name"];
+  return typeof name === "string" ? name : undefined;
 };
 
 /**

package/src/domain/usecase/emitDts.ts

@@ -1,16 +1,16 @@
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "plgg-bundle/vendors/nodeProc";
 import {
   join,
   dirname,
   basename,
   relative,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 import {
   existsSync,
   writeFileSync,
   rmSync,
-} from "node:fs";
-import { createRequire } from "node:module";
+} from "plgg-bundle/vendors/nodeFs";
+import { createRequire } from "plgg-bundle/vendors/nodeProc";
 import { rewriteDtsAliases } from "plgg-bundle/domain/usecase/rewriteDtsAliases";
 
 /**

package/src/domain/usecase/resolveSpecifier.ts

@@ -1,9 +1,9 @@
-import { existsSync, statSync } from "node:fs";
+import { existsSync, statSync } from "plgg-bundle/vendors/nodeFs";
 import {
   dirname,
   resolve,
   join,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 
 /**
  * Resolve a bare import specifier to an absolute source

package/src/domain/usecase/resolveWorkspaceSpecifier.spec.ts

@@ -4,6 +4,13 @@ import {
   all,
   toBe,
 } from "plgg-test";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { discoverWorkspace } from "plgg-bundle/domain/usecase/discoverWorkspace";
 import { resolveWorkspaceSpecifier } from "plgg-bundle/domain/usecase/resolveWorkspaceSpecifier";
@@ -77,3 +84,93 @@ test("returns undefined for a non-workspace specifier", () =>
     check(resolve("react"), toBe(undefined)),
     check(resolve("node:fs"), toBe(undefined)),
   ]));
+
+test("resolves an installed dist-only package export to its built ESM file", () => {
+  const root = fixtureRoot();
+  try {
+    const app = join(root, "packages", "app");
+    writePackage(app, "app", true);
+    writePackage(
+      join(app, "node_modules", "plgg"),
+      "plgg",
+      false,
+    );
+    const installed = discoverWorkspace(app);
+    return check(
+      resolveWorkspaceSpecifier({
+        specifier: "plgg",
+        fromFile: join(app, "src", "main.ts"),
+        packages: installed,
+      }),
+      toBe(
+        join(
+          app,
+          "node_modules",
+          "plgg",
+          "dist",
+          "index.es.js",
+        ),
+      ),
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("does not resolve internal paths from a dist-only installed package", () => {
+  const root = fixtureRoot();
+  try {
+    const app = join(root, "packages", "app");
+    writePackage(app, "app", true);
+    writePackage(
+      join(app, "node_modules", "plgg"),
+      "plgg",
+      false,
+    );
+    const installed = discoverWorkspace(app);
+    return check(
+      resolveWorkspaceSpecifier({
+        specifier: "plgg/Atomics/Num",
+        fromFile: join(app, "src", "main.ts"),
+        packages: installed,
+      }),
+      toBe(undefined),
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+const fixtureRoot = (): string =>
+  mkdtempSync(join(tmpdir(), "plgg-bundle-resolve-"));
+
+const writePackage = (
+  dir: string,
+  name: string,
+  source: boolean,
+): void => {
+  const codeDir = source
+    ? join(dir, "src")
+    : join(dir, "dist");
+  mkdirSync(codeDir, { recursive: true });
+  writeFileSync(join(codeDir, "index.es.js"), "");
+  writeFileSync(
+    join(dir, "package.json"),
+    JSON.stringify(
+      {
+        name,
+        type: "module",
+        exports: {
+          import: {
+            default: "./dist/index.es.js",
+          },
+          require: {
+            default: "./dist/index.cjs.js",
+          },
+        },
+      },
+      null,
+      2,
+    ),
+  );
+};

package/src/domain/usecase/resolveWorkspaceSpecifier.ts

@@ -1,4 +1,4 @@
-import { basename, join } from "node:path";
+import { basename, join } from "plgg-bundle/vendors/nodePath";
 import {
   resolveSpecifier,
   isRelative,
@@ -8,11 +8,12 @@ import { type WorkspacePackage } from "plgg-bundle/domain/usecase/discoverWorksp
 
 /**
  * App-mode resolver: resolve an import specifier to an
- * absolute SOURCE file, inlining workspace siblings
- * (`plgg`, `plgg-view/client`, …) by walking their `src`
- * instead of leaving them external. This is the mirror of
- * the library externalization — the leaf app is where
- * bundling deps is correct.
+ * absolute inlineable file. Source packages
+ * (`packages/plgg`, local `file:` siblings) resolve to
+ * `src`; published packages installed in `node_modules`
+ * resolve to their built ESM `dist` export. This is the
+ * mirror of the library externalization — the leaf app is
+ * where bundling deps is correct.
  *
  * Order:
  * 1. relative (`./x`) → resolve against the importer,
@@ -75,8 +76,8 @@ const matchPackage = (
 
 /**
  * Resolve a specifier already known to belong to `pkg`:
- * a declared export subpath via the exports reversal,
- * else the internal self-alias path.
+ * a declared export subpath through the package kind,
+ * else a source package's internal self-alias path.
  */
 const resolveInPackage = (
   pkg: WorkspacePackage,
@@ -89,17 +90,42 @@ const resolveInPackage = (
           pkg.name.length + 1,
         )}`;
   const dist = pkg.exports.get(subpath);
-  return dist === undefined
+  return pkg.kind === "source"
+    ? resolveInSourcePackage(pkg, specifier, dist)
+    : resolveInDistPackage(pkg, dist);
+};
+
+/**
+ * Source packages keep the previous monorepo behavior:
+ * public exports reverse their emitted dist stem back to
+ * source; non-export self-alias paths resolve under `src`.
+ */
+const resolveInSourcePackage = (
+  pkg: WorkspacePackage & { kind: "source" },
+  specifier: string,
+  dist: string | undefined,
+): string | undefined =>
+  dist === undefined
     ? resolveSpecifier({
         specifier,
         fromFile: pkg.dir,
         aliasPrefix: pkg.name,
-        aliasSrcRoot: join(pkg.dir, "src"),
+        aliasSrcRoot: pkg.srcDir,
       })
-    : pickExisting(
-        join(pkg.dir, "src", srcStem(dist)),
-      );
-};
+    : pickExisting(join(pkg.srcDir, srcStem(dist)));
+
+/**
+ * Dist-only packages can safely resolve only declared
+ * public exports. Internal self-alias paths are not
+ * available in a consumer install.
+ */
+const resolveInDistPackage = (
+  pkg: WorkspacePackage & { kind: "dist" },
+  dist: string | undefined,
+): string | undefined =>
+  dist === undefined
+    ? undefined
+    : pickExisting(join(pkg.dir, dist));
 
 /**
  * The source stem implied by an export's dist default —

package/src/domain/usecase/rewriteDtsAliases.ts

@@ -3,12 +3,12 @@ import {
   statSync,
   readFileSync,
   writeFileSync,
-} from "node:fs";
+} from "plgg-bundle/vendors/nodeFs";
 import {
   join,
   dirname,
   relative,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 
 /**
  * Rewrite the package self-alias (`<prefix>/<sub>`) in

package/src/vendors/nodeFs.ts

@@ -0,0 +1,22 @@
+/**
+ * The filesystem anti-corruption layer for plgg-bundle — the
+ * ONLY place the bundler's build usecases reach `node:fs`, kept
+ * under `vendors/` so the domain speaks these named operations,
+ * not the driver. Re-exported (not re-wrapped) to preserve the
+ * exact node types; plgg-bundle's throw-at-the-boundary error
+ * model (see BundleConfig) means a failed fs call surfaces as a
+ * thrown Error the entrypoint catches — the seam is the import
+ * chokepoint, so the vendor-boundary gate holds unexempted.
+ */
+export {
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+  renameSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  watch,
+  type FSWatcher,
+} from "node:fs";

package/src/vendors/nodeHttp.ts

@@ -0,0 +1,14 @@
+/**
+ * The HTTP anti-corruption layer for plgg-bundle's DEV server —
+ * the ONLY place the node:http ⇄ Web-standard bridge reaches
+ * `node:http`. Confined here so the dev orchestration stays
+ * `node:`-free (the vendor-boundary gate); a plgg-free
+ * reimplementation of `serve` (the toolchain must not import a
+ * library it builds).
+ */
+export {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+  type Server,
+} from "node:http";