@wular/pnext 0.1.5 → 0.1.7

package/bin/pnext

@@ -64,11 +64,18 @@ case "$1" in
   *) named=pnext ;;
 esac
 
+# The published package runs `start` from its publish-time prebundle, once its stamp marks it
+# complete; the prebundle hands a build of any other source back to src.
+entry=$dir/../src/cli/index.ts
+if [ "$1" = start ] && [ -f "$dir/../dist/server/generation.json" ]; then
+  entry=$dir/../dist/server/cli/index.js
+fi
+
 bun_bin=$(command -v bun)
 for candidate in "${XDG_CACHE_HOME:-$HOME/.cache}"/pnext/bin/bun-*/"$named"; do
   if [ -x "$candidate" ] && [ "$candidate" -ef "$bun_bin" ]; then
-    exec "$candidate" --conditions=react-server "$dir/../src/cli/index.ts" "$@"
+    exec "$candidate" --conditions=react-server "$entry" "$@"
   fi
 done
 
-exec bun --conditions=react-server "$dir/../src/cli/index.ts" "$@"
+exec bun --conditions=react-server "$entry" "$@"

package/dist/server/_chunks/aliases-j47a10ce.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  SHIMMED_NEXT_DIST_PATHS,
+  compatAliasPlugin,
+  compatAliases,
+  compatSuspenseType,
+  ensureCompatSuspense,
+  missingCompatImportError,
+  nextCompatAliasEntries,
+  nextCompatAliases,
+  nextCompatEnabled,
+  reactCompatAliases,
+  reactCompatEnabled,
+  reactCompilerOptions,
+  reactServerLayerAliases,
+  rewriteNextFontSource
+} from "./index-eeaanp2e.js";
+import"./index-3xbr4eyv.js";
+import"./index-6q7zvrap.js";
+import"./index-20ppawv7.js";
+import"./index-x93hv0sc.js";
+import"./index-tqn2qnnn.js";
+import"./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-pym1cezq.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+export {
+  SHIMMED_NEXT_DIST_PATHS,
+  compatAliasPlugin,
+  compatAliases,
+  compatSuspenseType,
+  ensureCompatSuspense,
+  missingCompatImportError,
+  nextCompatAliasEntries,
+  nextCompatAliases,
+  nextCompatEnabled,
+  reactCompatAliases,
+  reactCompatEnabled,
+  reactCompilerOptions,
+  reactServerLayerAliases,
+  rewriteNextFontSource
+};

package/dist/server/_chunks/analyze-arswqe6s.js

@@ -0,0 +1,445 @@
+// @bun
+import"./index-8k7pfejn.js";
+import"./index-91x12ykq.js";
+import {
+  matchRoute
+} from "./index-jepjvcrf.js";
+import"./index-2dv4y4wd.js";
+import"./index-73z4esab.js";
+import {
+  emittedAssetName,
+  publishEmittedAssets,
+  routeCssAssetNames
+} from "./index-y2jr2n72.js";
+import"./index-web361b8.js";
+import"./index-fp8r0sqs.js";
+import"./index-cjgqs13g.js";
+import"./index-p77b4kcx.js";
+import {
+  listFiles
+} from "./index-20ppawv7.js";
+import {
+  loadConfig
+} from "./index-x93hv0sc.js";
+import"./index-tqn2qnnn.js";
+import {
+  bold,
+  cyan,
+  dim
+} from "./index-6kp9r0d9.js";
+import"./index-ras0sdab.js";
+import"./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-z4z9zv3b.js";
+import"./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+
+// src/cli/analyze.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+import zlib from "zlib";
+async function analyzeProject(root, options = {}) {
+  const config = await loadConfig(root);
+  if (!existsSync(config.outPath)) {
+    throw new Error(`No PNext output found at ${config.outPath}. Run pnext build first.`);
+  }
+  const target = analyzeTarget(config.outPath);
+  if (!target) {
+    throw new Error(`No production build found at ${config.outPath}. Run pnext build first.`);
+  }
+  const compression = options.compression ?? "gzip";
+  const files = await listFiles(target.root);
+  const rows = await Promise.all(files.map(async (file) => {
+    const bytes = await readFile(file);
+    return {
+      path: path.relative(target.root, file),
+      type: fileType(file),
+      rawBytes: bytes.length,
+      compressedBytes: compressedSize(bytes, compression)
+    };
+  }));
+  const routeBundles = await analyzeRouteBundles(config.outPath, target.root, rows, options.route);
+  return {
+    root: path.relative(config.root, target.root),
+    compression,
+    files: rows,
+    routeBundles,
+    totals: rows.reduce((total, row) => ({
+      rawBytes: total.rawBytes + row.rawBytes,
+      compressedBytes: total.compressedBytes + row.compressedBytes
+    }), { rawBytes: 0, compressedBytes: 0 })
+  };
+}
+async function analyzeRouteBundles(outPath, publicPath, files, routeFilter) {
+  const manifestPath = path.join(outPath, "manifest.json");
+  if (!existsSync(manifestPath))
+    return [];
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  publishEmittedAssets(outPath, manifest.assetNames);
+  const pages = manifest.routes.filter((route) => route.kind === "page");
+  const selected = routeFilter ? filterAnalyzeRoutes(pages, routeFilter) : pages.map((route) => ({ route }));
+  if (routeFilter && selected.length === 0) {
+    throw new Error(`No route matches ${routeFilter}. Routes:
+  ${pages.map((route) => publicRoutePath(route.route)).join(`
+  `)}`);
+  }
+  const sizes = new Map(files.map((file) => [toPosix(file.path), file]));
+  const contents = new Map;
+  async function js(pathname) {
+    const normalized = toPosix(pathname);
+    if (contents.has(normalized))
+      return contents.get(normalized) ?? "";
+    const text = await readFile(path.join(publicPath, normalized), "utf8");
+    contents.set(normalized, text);
+    return text;
+  }
+  const bundles = [];
+  for (const { route, pathname } of selected) {
+    bundles.push(await analyzeRouteBundle(outPath, route, sizes, js, pathname));
+  }
+  return bundles;
+}
+function filterAnalyzeRoutes(pages, filter) {
+  const normalized = filter === "/" ? filter : filter.replace(/\/+$/, "");
+  const direct = pages.filter((route) => route.route === normalized || publicRoutePath(route.route) === normalized);
+  if (direct.length > 0)
+    return direct.map((route) => ({ route }));
+  const matched = matchRoute(pages, normalized);
+  return matched ? [{ route: matched.route, pathname: normalized }] : [];
+}
+function publicRoutePath(route) {
+  return route.replace(/:([a-zA-Z0-9_]+)\*/g, "[...$1]").replace(/:([a-zA-Z0-9_]+)/g, "[$1]");
+}
+async function analyzeRouteBundle(outPath, route, sizes, js, pathname) {
+  const initial = new Set;
+  addIfExists(initial, sizes, routeHtmlPath(route, pathname));
+  const assetFile = (name) => `assets/${emittedAssetName({ outPath }, name)}`;
+  addIfExists(initial, sizes, assetFile("global.css"));
+  for (const asset of routeCssAssetNames(route))
+    addIfExists(initial, sizes, assetFile(asset));
+  addIfExists(initial, sizes, "_next/static/pnext/_buildManifest.js");
+  if (route.clientEntry) {
+    addIfExists(initial, sizes, route.clientEntry);
+    for (const asset of route.clientEntryImports ?? [])
+      addIfExists(initial, sizes, asset);
+    for (const dependency of await staticDependencies(route.clientEntry, sizes, js))
+      initial.add(dependency);
+  }
+  const visibleDynamic = [];
+  const dynamic = [];
+  const dynamicTargets = new Set;
+  const lazyShared = new Set;
+  if (route.clientEntry && sizes.has(toPosix(route.clientEntry))) {
+    const entrySource = await js(route.clientEntry);
+    for (const island of islandImports(entrySource, route.clientEntry)) {
+      const row = sizes.get(island.path);
+      if (!row)
+        continue;
+      const reference = route.clientReferences.find((item2) => item2.id === island.id);
+      const load = reference?.dynamic?.load === "visible" ? "visible" : "render";
+      dynamicTargets.add(island.path);
+      const exportName = reference?.exportName ?? "default";
+      const item = {
+        path: island.path,
+        id: island.id,
+        component: islandComponent(exportName, reference?.file, island.path),
+        exportName,
+        load,
+        rawBytes: row.rawBytes,
+        compressedBytes: row.compressedBytes
+      };
+      if (load === "visible")
+        visibleDynamic.push(item);
+      else
+        dynamic.push(item);
+      if (reference?.cssImports?.length)
+        addIfExists(lazyShared, sizes, `assets/${island.id}.css`);
+      for (const dependency of await staticDependencies(island.path, sizes, js)) {
+        if (!initial.has(dependency) && !dynamicTargets.has(dependency))
+          lazyShared.add(dependency);
+      }
+    }
+    for (const asset of [
+      ...route.clientDynamicImports ?? [],
+      ...dynamicImportPaths(entrySource, route.clientEntry)
+    ]) {
+      const importedPath = toPosix(asset);
+      if (initial.has(importedPath) || dynamicTargets.has(importedPath))
+        continue;
+      if (sizes.has(importedPath))
+        lazyShared.add(importedPath);
+      for (const dependency of await staticDependencies(importedPath, sizes, js)) {
+        if (!initial.has(dependency) && !dynamicTargets.has(dependency))
+          lazyShared.add(dependency);
+      }
+    }
+  }
+  return {
+    route: route.route,
+    page: route.client ? "client" : "server",
+    initial: bundleFiles([...initial], sizes),
+    visibleDynamic: visibleDynamic.sort((a, b) => b.compressedBytes - a.compressedBytes),
+    dynamic: dynamic.sort((a, b) => b.compressedBytes - a.compressedBytes),
+    lazyShared: bundleFiles([...lazyShared], sizes)
+  };
+}
+function islandComponent(exportName, file, chunkPath) {
+  if (exportName !== "default")
+    return exportName;
+  const source = file ?? chunkPath.replace(/-[A-Z0-9]{8}\.js$/, ".js");
+  return path.posix.basename(toPosix(source)).replace(/\.[^.]+$/, "");
+}
+async function staticDependencies(entry, sizes, js, seen = new Set) {
+  const dependencies = new Set;
+  const normalized = toPosix(entry);
+  if (seen.has(normalized) || !sizes.has(normalized))
+    return dependencies;
+  seen.add(normalized);
+  for (const specifier of staticImports(await js(normalized))) {
+    const dependency = resolveBuiltImport(normalized, specifier);
+    if (!dependency || !sizes.has(dependency))
+      continue;
+    dependencies.add(dependency);
+    for (const transitive of await staticDependencies(dependency, sizes, js, seen))
+      dependencies.add(transitive);
+  }
+  return dependencies;
+}
+function islandImports(source, from) {
+  const imports = [];
+  const pattern = /\bid\s*:\s*"([^"]+)"\s*,\s*options\s*:\s*\{[^{}]*\}\s*,\s*load\s*:\s*\(\)\s*=>\s*(?:Promise\.all\(\[\s*)?import\(\s*"([^"]+)"\s*\)/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    const id = match[1];
+    const specifier = match[2];
+    if (!id || !specifier)
+      continue;
+    const resolved = resolveBuiltImport(from, specifier);
+    if (resolved)
+      imports.push({ path: resolved, id });
+  }
+  return imports;
+}
+function dynamicImportPaths(source, from) {
+  const imports = [];
+  const pattern = /import\("([^"]+)"\)/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    const specifier = match[1];
+    if (!specifier)
+      continue;
+    const resolved = resolveBuiltImport(from, specifier);
+    if (resolved)
+      imports.push(resolved);
+  }
+  return imports;
+}
+function staticImports(source) {
+  const imports = [];
+  const pattern = /import\s*(?:[^'"]*?from\s*)?["']([^'"]+)["']/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    if (match[1])
+      imports.push(match[1]);
+  }
+  return imports;
+}
+function resolveBuiltImport(from, specifier) {
+  if (!specifier.startsWith("."))
+    return null;
+  return toPosix(path.posix.normalize(path.posix.join(path.posix.dirname(toPosix(from)), specifier)));
+}
+function addIfExists(items, sizes, pathname) {
+  const normalized = toPosix(pathname);
+  if (sizes.has(normalized))
+    items.add(normalized);
+}
+function bundleFiles(paths, sizes) {
+  return paths.map((pathname) => {
+    const row = sizes.get(pathname);
+    return row ? { path: pathname, rawBytes: row.rawBytes, compressedBytes: row.compressedBytes } : null;
+  }).filter((file) => Boolean(file)).sort((a, b) => b.compressedBytes - a.compressedBytes);
+}
+function routeHtmlPath(route, pathname) {
+  const target = pathname ?? prerenderedPathname(route) ?? route.route;
+  return target === "/" ? "index.html" : `${target.replace(/^\/+/, "")}/index.html`;
+}
+function prerenderedPathname(route) {
+  const params = route.prerenderedParams?.[0];
+  if (!params)
+    return;
+  return route.route.replace(/:([a-zA-Z0-9_]+)\*?/g, (_match, name) => {
+    const value = params[name];
+    return Array.isArray(value) ? value.join("/") : value ?? "";
+  });
+}
+function analyzeTarget(outPath) {
+  const publicPath = path.join(outPath, "public");
+  return existsSync(publicPath) ? { root: publicPath } : null;
+}
+function compressedSize(bytes, compression) {
+  if (compression === "brotli") {
+    return zlib.brotliCompressSync(bytes, {
+      params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 11 }
+    }).length;
+  }
+  return zlib.gzipSync(bytes, { level: 9 }).length;
+}
+function fileType(file) {
+  if (file.endsWith(".html"))
+    return "html";
+  if (file.endsWith(".css"))
+    return "css";
+  if (file.endsWith(".js"))
+    return "js";
+  return "asset";
+}
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+function printAnalyzeResult(result, options) {
+  console.log(`PNext analyze: production build at ${dim(result.root)} (${result.compression})`);
+  printRouteBundles(result);
+  if (!options.route)
+    printAnalyzeFiles(result, { details: options.files });
+}
+function printRouteBundles(result) {
+  if (result.routeBundles.length === 0)
+    return;
+  console.log(`
+${bold("Routes")}`);
+  for (const bundle of result.routeBundles) {
+    console.log(`
+${cyan(bundle.route)} ${dim(`(${bundle.page} page)`)}`);
+    printBundleGroup("initial", bundle.initial, result.compression);
+    printDynamicBundleGroup("visible dynamic", bundle.visibleDynamic, result.compression);
+    printDynamicBundleGroup("dynamic", bundle.dynamic, result.compression);
+    printBundleGroup("shared after dynamic", bundle.lazyShared, result.compression);
+  }
+  console.log("");
+}
+function printBundleGroup(label, files, compression) {
+  if (files.length === 0)
+    return;
+  console.log(`
+  ${bold(label.padEnd(22))} ${formatTotalSize(files, compression)}`);
+  printBundleFiles(files, compression, "    ", rowColumns(files));
+}
+function printDynamicBundleGroup(label, files, compression) {
+  if (files.length === 0)
+    return;
+  console.log(`
+  ${bold(label)}`);
+  const columns = rowColumns(files);
+  const componentWidth = Math.max(...files.map((file) => file.component.length));
+  const pathWidth = Math.max(...files.map((file) => file.path.length));
+  for (const file of files) {
+    console.log(`    ${file.component.padEnd(componentWidth)}  ${dim(file.path.padEnd(pathWidth))}  ${formatFileSize(file, compression, columns)}`);
+  }
+}
+function formatTotalSize(files, compression) {
+  const rawBytes = files.reduce((total, file) => total + file.rawBytes, 0);
+  const compressedBytes = files.reduce((total, file) => total + file.compressedBytes, 0);
+  return `${formatBytes(compressedBytes)} ${compression}  ${dim(`${formatBytes(rawBytes)} raw`)}`;
+}
+function printAnalyzeFiles(result, options) {
+  const routeFiles = new Set(result.routeBundles.flatMap((bundle) => [
+    ...bundle.initial.map((file) => file.path),
+    ...bundle.visibleDynamic.map((file) => file.path),
+    ...bundle.dynamic.map((file) => file.path),
+    ...bundle.lazyShared.map((file) => file.path)
+  ]));
+  const sorted = sortedAnalyzeFiles(result.files).filter((file) => !routeFiles.has(file.path));
+  if (sorted.length === 0)
+    return;
+  if (!options.details) {
+    console.log(`Other files: ${formatFileCount(sorted)}  ${formatTotalSize(sorted, result.compression)}`);
+    console.log("List them: pnext analyze --files");
+    return;
+  }
+  console.log(`${bold("Other files")}
+`);
+  for (const type of ["html", "css", "js", "asset"]) {
+    const files = sorted.filter((file) => file.type === type);
+    if (files.length === 0)
+      continue;
+    console.log(bold(type));
+    printBundleFiles(files, result.compression, "  ", rowColumns(files));
+    console.log("");
+  }
+}
+function printBundleFiles(files, compression, indent, columns) {
+  const pathWidth = Math.max(...files.map((file) => file.path.length));
+  for (const file of files) {
+    console.log(`${indent}${dim(file.path.padEnd(pathWidth))}  ${formatFileSize(file, compression, columns)}`);
+  }
+}
+function rowColumns(files) {
+  return {
+    compressedWidth: Math.max(...files.map((file) => formatBytes(file.compressedBytes).length)),
+    rawWidth: Math.max(...files.map((file) => formatBytes(file.rawBytes).length))
+  };
+}
+function formatFileSize(file, compression, columns) {
+  const compressed = formatBytes(file.compressedBytes).padStart(columns.compressedWidth);
+  const raw = `${formatBytes(file.rawBytes).padStart(columns.rawWidth)} raw`;
+  return `${compressed} ${compression}  ${dim(raw)}`;
+}
+function formatFileCount(files) {
+  const counts = new Map;
+  for (const file of files)
+    counts.set(file.type, (counts.get(file.type) ?? 0) + 1);
+  return [...counts].map(([type, count]) => `${count} ${pluralFileType(type, count)}`).join(", ");
+}
+function pluralFileType(type, count) {
+  if (count === 1)
+    return type;
+  if (type === "js" || type === "css" || type === "html")
+    return type;
+  return `${type}s`;
+}
+function sortedAnalyzeFiles(files) {
+  return [...files].sort((a, b) => {
+    const typeDelta = analyzeTypeRank(a.type) - analyzeTypeRank(b.type);
+    if (typeDelta)
+      return typeDelta;
+    const sizeDelta = b.compressedBytes - a.compressedBytes;
+    if (sizeDelta)
+      return sizeDelta;
+    return a.path.localeCompare(b.path);
+  });
+}
+function analyzeTypeRank(type) {
+  switch (type) {
+    case "html":
+      return 0;
+    case "css":
+      return 1;
+    case "js":
+      return 2;
+    case "asset":
+      return 3;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${units[unitIndex]}`;
+}
+export {
+  analyzeProject,
+  printAnalyzeResult
+};

package/dist/server/_chunks/boot-af0mv3dy.js

@@ -0,0 +1,36 @@
+// @bun
+import {
+  registerCompatBootExtensions
+} from "./index-k1g3epw0.js";
+import"./index-2wfv4kvx.js";
+import"./index-danncfhy.js";
+import"./index-jepjvcrf.js";
+import"./index-eeaanp2e.js";
+import"./index-kq8kpzye.js";
+import"./index-3xbr4eyv.js";
+import"./index-6q7zvrap.js";
+import"./index-z88qv16t.js";
+import"./index-2vz0wzdn.js";
+import"./index-6e4fqv30.js";
+import"./index-cjgqs13g.js";
+import"./index-jks0x0a1.js";
+import"./index-6b009mt0.js";
+import"./index-4zzebszd.js";
+import"./index-sq3kvz3g.js";
+import"./index-ckkdpht5.js";
+import"./index-20ppawv7.js";
+import"./index-x93hv0sc.js";
+import"./index-jcsjq3d1.js";
+import"./index-tqn2qnnn.js";
+import"./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+export {
+  registerCompatBootExtensions
+};

package/dist/server/_chunks/build-spy3dxp4.js

@@ -0,0 +1,84 @@
+// @bun
+import {
+  buildClientReferenceCss,
+  buildGlobalCss,
+  buildNotFoundCss,
+  buildRouteCss,
+  buildRouteStylesheets,
+  clearGlobalCssSourceCache,
+  cssModuleClientPlugin,
+  globalCssSource,
+  globalCssSources,
+  globalCssSourcesForPaths,
+  hoistCssImports,
+  isCssFile,
+  prepareRouteCssChunks,
+  rewriteTailwindConfigDirectives,
+  runPostcssOffThread,
+  setGlobalCssSourceStore,
+  stopCssWorker,
+  warmCssPipeline,
+  warmCssWorker
+} from "./index-2dv4y4wd.js";
+import"./index-73z4esab.js";
+import {
+  assetHref,
+  assetPathname,
+  clearEmittedAssets,
+  cssModuleMapping,
+  emitFontCssStylesheet,
+  emittedAssetName,
+  emittedAssetNames,
+  publishEmittedAssets,
+  recordEmittedAsset,
+  registerCssRuntime,
+  routeCssAssetNames,
+  routeCssHref,
+  withAssetPrefix
+} from "./index-y2jr2n72.js";
+import"./index-web361b8.js";
+import"./index-fp8r0sqs.js";
+import"./index-cjgqs13g.js";
+import"./index-20ppawv7.js";
+import"./index-tqn2qnnn.js";
+import"./index-6kp9r0d9.js";
+import"./index-yz54pxrh.js";
+import"./index-7wc9n8be.js";
+import"./index-pym1cezq.js";
+import"./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-rt9qq1va.js";
+export {
+  assetHref,
+  assetPathname,
+  buildClientReferenceCss,
+  buildGlobalCss,
+  buildNotFoundCss,
+  buildRouteCss,
+  buildRouteStylesheets,
+  clearEmittedAssets,
+  clearGlobalCssSourceCache,
+  cssModuleClientPlugin,
+  cssModuleMapping,
+  emitFontCssStylesheet,
+  emittedAssetName,
+  emittedAssetNames,
+  globalCssSource,
+  globalCssSources,
+  globalCssSourcesForPaths,
+  hoistCssImports,
+  isCssFile,
+  prepareRouteCssChunks,
+  publishEmittedAssets,
+  recordEmittedAsset,
+  registerCssRuntime,
+  rewriteTailwindConfigDirectives,
+  routeCssAssetNames,
+  routeCssHref,
+  runPostcssOffThread,
+  setGlobalCssSourceStore,
+  stopCssWorker,
+  warmCssPipeline,
+  warmCssWorker,
+  withAssetPrefix
+};