@absolutejs/absolute 0.20.0-beta.179 → 0.20.0-beta.180

package/dist/cli/index-w79snsxv.js

@@ -0,0 +1,461 @@
+// @bun
+import {
+  logWarn
+} from "./index-aqe25w4h.js";
+import {
+  REACT_SERVER_CLIENT_MANIFEST_KEY,
+  REACT_SERVER_PAGE_MANIFEST_SUFFIX,
+  REACT_SERVER_PAYLOAD_GLOBAL,
+  REACT_SERVER_RENDERER_MANIFEST_KEY,
+  REACT_SERVER_RUNTIME_FILE
+} from "./index-x1vvn549.js";
+import {
+  toPascal
+} from "./index-dw44xa4x.js";
+import {
+  normalizePath
+} from "./index-47e8fwha.js";
+
+// src/build/buildReactServerComponents.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, dirname, extname, join, relative as relative2, resolve as resolve2 } from "path";
+var {
+  build: bunBuild, 
+  Glob, 
+  Transpiler
+} = globalThis.Bun;
+
+// src/utils/validateSafePath.ts
+import { resolve, relative } from "path";
+var validateSafePath = (targetPath, baseDirectory) => {
+  const absoluteBase = resolve(baseDirectory);
+  const absoluteTarget = resolve(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative(absoluteBase, absoluteTarget));
+  if (relativePath.startsWith("../") || relativePath === "..") {
+    throw new Error(`Unsafe path: ${targetPath}`);
+  }
+  return absoluteTarget;
+};
+
+// src/build/buildReactServerComponents.ts
+var PAGE_PATTERN = "*.{tsx,jsx,ts,js}";
+var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
+var USE_CLIENT_PATTERN = /^(?:\s|\/\/[^\n]*\n|\/\*[\s\S]*?\*\/)*(['"])use client\1/;
+var MANIFEST_NAMESPACE = "absolute-react-server";
+var MANIFEST_SPECIFIER = "absolute-react-server:client-manifest";
+var MODULE_ID_LENGTH = 16;
+var loaderFor = (path) => {
+  const extension = extname(path);
+  if (extension === ".tsx")
+    return "tsx";
+  if (extension === ".ts" || extension === ".mts" || extension === ".cts")
+    return "ts";
+  if (extension === ".jsx")
+    return "jsx";
+  return "js";
+};
+var clientModuleId = (projectRoot, path) => createHash("sha256").update(relative2(projectRoot, path).replace(/\\/g, "/")).digest("hex").slice(0, MODULE_ID_LENGTH);
+var isClientModuleSource = (source) => USE_CLIENT_PATTERN.test(source);
+var scanExportNames = (path, source) => {
+  const transpiler = new Transpiler({ loader: loaderFor(path) });
+  return transpiler.scan(source).exports;
+};
+var clientReferenceSource = (module, flightServer) => {
+  const lines = [
+    `import { registerClientReference } from ${JSON.stringify(flightServer)};`,
+    `import { clientManifest } from ${JSON.stringify(MANIFEST_SPECIFIER)};`,
+    `const id = ${JSON.stringify(module.id)};`,
+    `clientManifest[id] = { chunks: [id, id], id, name: '' };`,
+    `const reference = (name) => registerClientReference(() => { throw new Error('Client component ' + name + ' cannot be called on the server.'); }, id, name);`
+  ];
+  for (const name of module.exports) {
+    lines.push(name === "default" ? `export default reference('default');` : `export const ${name} = reference(${JSON.stringify(name)});`);
+  }
+  return `${lines.join(`
+`)}
+`;
+};
+var REACT_COMPONENTS_SPECIFIER = /^@absolutejs\/absolute\/react\/components$/;
+var resolveReactComponentsServerEntry = (importer) => {
+  try {
+    const regularEntry = Bun.resolveSync("@absolutejs/absolute/react/components", dirname(importer));
+    const serverEntry = join(dirname(regularEntry), "server", "index.js");
+    return existsSync(serverEntry) ? serverEntry : undefined;
+  } catch {
+    return;
+  }
+};
+var createClientReferencePlugin = (projectRoot, clientModules) => {
+  const flightServer = Bun.resolveSync("react-server-dom-webpack/server.edge", projectRoot);
+  const plugin = {
+    name: "absolute-react-server-client-references",
+    setup(builder) {
+      builder.onResolve({ filter: /^absolute-react-server:/ }, (args) => ({
+        namespace: MANIFEST_NAMESPACE,
+        path: args.path
+      }));
+      builder.onLoad({ filter: /.*/, namespace: MANIFEST_NAMESPACE }, () => ({
+        contents: `export const clientManifest = {};
+`,
+        loader: "js"
+      }));
+      builder.onResolve({ filter: REACT_COMPONENTS_SPECIFIER }, (args) => {
+        const path = resolveReactComponentsServerEntry(args.importer);
+        return path ? { path } : undefined;
+      });
+      builder.onLoad({ filter: SOURCE_FILTER }, (args) => {
+        const source = readFileSync(args.path, "utf8");
+        const loader = loaderFor(args.path);
+        if (!isClientModuleSource(source)) {
+          return { contents: source, loader };
+        }
+        const module = {
+          exports: scanExportNames(args.path, source),
+          id: clientModuleId(projectRoot, args.path),
+          path: args.path
+        };
+        clientModules.set(module.id, module);
+        return {
+          contents: clientReferenceSource(module, flightServer),
+          loader: "js"
+        };
+      });
+    }
+  };
+  return plugin;
+};
+var ALS_SETUP_SOURCE = `import { AsyncLocalStorage } from 'node:async_hooks';
+// The Flight server's edge build looks for a global AsyncLocalStorage to
+// keep per-request state (cache(), hints) across awaits.
+if (typeof globalThis.AsyncLocalStorage !== 'function') {
+	globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+`;
+var resolvePageExport = (pagePath, pascalName) => {
+  const exports = scanExportNames(pagePath, readFileSync(pagePath, "utf8"));
+  if (exports.includes(pascalName))
+    return pascalName;
+  if (exports.includes("default"))
+    return "default";
+  throw new Error(`React Server Components page ${pagePath} must export a component named ${pascalName} (or a default export).`);
+};
+var pageEntrySource = (pagePath, exportName) => `import '../asyncLocalStorage';
+export { ${exportName} as Page } from ${JSON.stringify(pagePath)};
+export { renderToReadableStream } from 'react-server-dom-webpack/server.edge';
+export { createElement } from 'react';
+export { clientManifest } from ${JSON.stringify(MANIFEST_SPECIFIER)};
+// A development Flight server: the page handler moves its debug info to a
+// separate stream that stays on the server.
+export const developmentFlight = process.env.NODE_ENV !== 'production';
+`;
+var ssrEntrySource = (modules) => {
+  const imports = modules.map((module, index) => `import * as module${index} from ${JSON.stringify(module.path)};`);
+  const entries = modules.map((module, index) => `	${JSON.stringify(module.id)}: module${index}`);
+  return `${imports.join(`
+`)}
+import { createFromReadableStream } from 'react-server-dom-webpack/client.edge';
+import { renderToReadableStream } from 'react-dom/server';
+import { createElement, use } from 'react';
+
+const modules = {
+${entries.join(`,
+`)}
+};
+const registry = (globalThis.__absoluteReactServerModules ??= {});
+Object.assign(registry, modules);
+globalThis.__webpack_require__ = (id) => globalThis.__absoluteReactServerModules[id];
+globalThis.__webpack_chunk_load__ = () => Promise.resolve();
+
+const moduleMap = {};
+for (const id of Object.keys(modules)) {
+	moduleMap[id] = { '*': { chunks: [], id, name: '*' } };
+}
+
+// \`debug\`: a development Flight server's debug channel. It is read here,
+// on the server, so server-rendered errors keep their server component
+// owners; the browser's copy of the payload carries none of it.
+export const renderHtml = (flight, options, debug) => {
+	const root = createFromReadableStream(flight, {
+		...(debug ? { debugChannel: { readable: debug } } : {}),
+		serverConsumerManifest: {
+			moduleLoading: null,
+			moduleMap,
+			serverModuleMap: null
+		}
+	});
+	const Root = () => use(root);
+
+	return renderToReadableStream(createElement(Root), options);
+};
+
+// A fragment (a SuspenseSlot's resolved content) rendered to an HTML string.
+export const renderStaticHtml = async (flight) => {
+	const root = createFromReadableStream(flight, {
+		serverConsumerManifest: {
+			moduleLoading: null,
+			moduleMap,
+			serverModuleMap: null
+		}
+	});
+	const Root = () => use(root);
+	const stream = await renderToReadableStream(createElement(Root));
+	await stream.allReady;
+
+	return new Response(stream).text();
+};
+`;
+};
+var clientRuntimeSource = (modules) => {
+  const loaders = modules.map((module) => `	${JSON.stringify(module.id)}: () => import(${JSON.stringify(module.path)})`);
+  return `const loaders = {
+${loaders.join(`,
+`)}
+};
+const loaded = {};
+const webpackRequire = (id) => loaded[id];
+webpackRequire.u = (id) => id;
+globalThis.__webpack_require__ = webpackRequire;
+// Dev builds of the Flight client name each chunk's script for debug info.
+globalThis.__webpack_get_script_filename__ = (id) => id;
+globalThis.__webpack_chunk_load__ = (id) => {
+	const load = loaders[id];
+	if (!load) return Promise.reject(new Error('Unknown client module ' + id));
+
+	return load().then((module) => {
+		loaded[id] = module;
+	});
+};
+`;
+};
+var clientEntrySource = () => `import './ReactServerClientRuntime';
+import { createFromReadableStream } from 'react-server-dom-webpack/client.browser';
+import { hydrateRoot } from 'react-dom/client';
+import { createElement, use, useEffect } from 'react';
+
+const encoder = new TextEncoder();
+const stream = new ReadableStream({
+	start(controller) {
+		const queue = (self.${REACT_SERVER_PAYLOAD_GLOBAL} ??= []);
+		for (const chunk of queue) controller.enqueue(encoder.encode(chunk));
+		queue.length = 0;
+		queue.push = (chunk) => {
+			controller.enqueue(encoder.encode(chunk));
+
+			return 0;
+		};
+		const close = () => controller.close();
+		if (document.readyState === 'loading') {
+			document.addEventListener('DOMContentLoaded', close, { once: true });
+		} else {
+			close();
+		}
+	}
+});
+const root = createFromReadableStream(stream);
+// The page's inline bootstrap holds streamed slot content back
+// (__ABS_SLOT_HYDRATION_PENDING__) so hydration compares against the HTML the
+// server rendered: a slot whose fallback is a React node would otherwise
+// mismatch, and React's client re-render would drop every patched slot.
+const releaseStreamingSlots = () => {
+	self.__ABS_SLOT_HYDRATION_PENDING__ = false;
+	if (typeof self.__ABS_SLOT_FLUSH__ === 'function') self.__ABS_SLOT_FLUSH__();
+};
+const Root = () => {
+	useEffect(() => {
+		setTimeout(releaseStreamingSlots, 0);
+	}, []);
+
+	return use(root);
+};
+hydrateRoot(document, createElement(Root));
+`;
+var findOutput = (outputs, name) => outputs.find((artifact) => artifact.kind === "entry-point" && basename(artifact.path).startsWith(`${name}.`));
+var toWebPath = (buildPath, path) => `/${relative2(buildPath, path).replace(/\\/g, "/")}`;
+var assertFlightPackage = (projectRoot) => {
+  try {
+    Bun.resolveSync("react-server-dom-webpack/package.json", projectRoot);
+  } catch {
+    throw new Error("reactServerComponentsDirectory is set but react-server-dom-webpack is not installed. " + "Add it at the same version as react (for example `bun add react-server-dom-webpack@<your react version>`).");
+  }
+};
+var emptyResult = () => ({
+  logs: [],
+  manifest: {},
+  outputPaths: [],
+  success: true
+});
+var writeGeneratedFile = (path, contents) => {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, contents);
+  return path;
+};
+var pageEntryName = (pagePath) => toPascal(basename(pagePath, extname(pagePath)));
+var endsWithPageSuffix = (name) => name.length > REACT_SERVER_PAGE_MANIFEST_SUFFIX.length && name.endsWith(REACT_SERVER_PAGE_MANIFEST_SUFFIX);
+var pageManifestKeys = (name, names) => {
+  const doubled = `${name}${REACT_SERVER_PAGE_MANIFEST_SUFFIX}`;
+  if (!endsWithPageSuffix(name))
+    return { keys: [doubled] };
+  const base = name.slice(0, -REACT_SERVER_PAGE_MANIFEST_SUFFIX.length);
+  if (!names.has(base))
+    return { keys: [name, doubled] };
+  return {
+    collision: `React Server Components pages ${base} and ${name} both map to the manifest key "${name}"; ${base} keeps it and ${name} is only reachable as "${doubled}". Rename one of them.`,
+    keys: [doubled]
+  };
+};
+var buildReactServerComponents = async ({
+  buildPath,
+  directory,
+  isDev,
+  projectRoot
+}) => {
+  const pagesDir = join(directory, "pages");
+  if (!existsSync(pagesDir))
+    return emptyResult();
+  const pages = [
+    ...new Glob(PAGE_PATTERN).scanSync({ absolute: true, cwd: pagesDir })
+  ].sort();
+  if (pages.length === 0)
+    return emptyResult();
+  assertFlightPackage(projectRoot);
+  const generatedDir = join(projectRoot, ".absolutejs", "generated", "react-server");
+  writeGeneratedFile(join(generatedDir, "asyncLocalStorage.ts"), ALS_SETUP_SOURCE);
+  const pageEntries = pages.map((pagePath) => {
+    const name = pageEntryName(pagePath);
+    return {
+      entry: writeGeneratedFile(join(generatedDir, "pages", `${name}.ts`), pageEntrySource(pagePath, resolvePageExport(pagePath, name))),
+      name
+    };
+  });
+  const sharedDefine = {
+    "process.env.NODE_ENV": JSON.stringify(isDev ? "development" : "production")
+  };
+  const serverSourcemap = isDev ? "inline" : "linked";
+  const clientModules = new Map;
+  const serverResult = await bunBuild({
+    conditions: ["react-server"],
+    define: sharedDefine,
+    entrypoints: pageEntries.map((page) => page.entry),
+    format: "esm",
+    naming: "[name].[hash].[ext]",
+    outdir: join(buildPath, "react", "server", "rsc"),
+    plugins: [createClientReferencePlugin(projectRoot, clientModules)],
+    root: generatedDir,
+    sourcemap: serverSourcemap,
+    splitting: true,
+    target: "bun",
+    throw: false
+  });
+  if (!serverResult.success) {
+    return { ...emptyResult(), logs: serverResult.logs, success: false };
+  }
+  const modules = [...clientModules.values()].sort((left, right) => left.id.localeCompare(right.id));
+  const ssrEntry = writeGeneratedFile(join(generatedDir, "ReactServerRenderer.ts"), ssrEntrySource(modules));
+  writeGeneratedFile(join(generatedDir, "ReactServerClientRuntime.ts"), clientRuntimeSource(modules));
+  const clientEntry = writeGeneratedFile(join(generatedDir, "ReactServerClient.ts"), clientEntrySource());
+  const [ssrResult, clientResult] = await Promise.all([
+    bunBuild({
+      define: sharedDefine,
+      entrypoints: [ssrEntry],
+      format: "esm",
+      naming: "[name].[hash].[ext]",
+      outdir: join(buildPath, "react", "server", "ssr"),
+      root: generatedDir,
+      sourcemap: serverSourcemap,
+      target: "bun",
+      throw: false
+    }),
+    bunBuild({
+      define: sharedDefine,
+      entrypoints: [clientEntry],
+      format: "esm",
+      minify: !isDev,
+      naming: {
+        chunk: "chunk-[hash].[ext]",
+        entry: "[name].[hash].[ext]"
+      },
+      outdir: join(buildPath, "react", "rsc"),
+      root: generatedDir,
+      splitting: true,
+      target: "browser",
+      throw: false
+    })
+  ]);
+  const logs = [
+    ...serverResult.logs,
+    ...ssrResult.logs,
+    ...clientResult.logs
+  ];
+  if (!ssrResult.success || !clientResult.success) {
+    return { ...emptyResult(), logs, success: false };
+  }
+  const ssrOutput = findOutput(ssrResult.outputs, "ReactServerRenderer");
+  const clientOutput = findOutput(clientResult.outputs, "ReactServerClient");
+  if (!ssrOutput || !clientOutput) {
+    throw new Error("React Server Components build produced no entry.");
+  }
+  const clientUrl = toWebPath(buildPath, clientOutput.path);
+  const rscOutputDir = join(buildPath, "react", "server", "rsc");
+  const runtimeFile = writeGeneratedFile(join(rscOutputDir, REACT_SERVER_RUNTIME_FILE), JSON.stringify({
+    client: clientUrl,
+    ssr: relative2(rscOutputDir, ssrOutput.path).replace(/\\/g, "/")
+  }));
+  const manifest = {
+    [REACT_SERVER_CLIENT_MANIFEST_KEY]: clientUrl,
+    [REACT_SERVER_RENDERER_MANIFEST_KEY]: resolve2(ssrOutput.path)
+  };
+  const pageKeys = reactServerPageManifestKeys2(pageEntries.map((page) => page.name));
+  for (const collision of pageKeys.collisions)
+    logWarn(collision);
+  for (const page of pageEntries) {
+    const output = findOutput(serverResult.outputs, page.name);
+    if (!output)
+      continue;
+    for (const key of pageKeys.keys.get(page.name) ?? [])
+      manifest[key] = resolve2(output.path);
+  }
+  const result = {
+    logs,
+    manifest,
+    outputPaths: [
+      ...serverResult.outputs.map((artifact) => artifact.path),
+      ...ssrResult.outputs.map((artifact) => artifact.path),
+      ...clientResult.outputs.map((artifact) => artifact.path),
+      runtimeFile
+    ],
+    success: true
+  };
+  return result;
+};
+var buildReactServerComponentsPass2 = async ({
+  directory,
+  incrementalFiles,
+  ...options
+}) => {
+  if (!directory)
+    return;
+  const absoluteDirectory = validateSafePath(directory, options.projectRoot);
+  const directoryPrefix = `${normalizePath(absoluteDirectory)}/`;
+  const touchesDirectory = !incrementalFiles || incrementalFiles.length === 0 || incrementalFiles.some((file) => normalizePath(resolve2(file)).startsWith(directoryPrefix));
+  if (!touchesDirectory)
+    return;
+  return buildReactServerComponents({
+    ...options,
+    directory: absoluteDirectory
+  });
+};
+var reactServerPageManifestKeys2 = (pageNames) => {
+  const names = new Set(pageNames);
+  const keys = new Map;
+  const collisions = [];
+  for (const name of pageNames) {
+    const page = pageManifestKeys(name, names);
+    keys.set(name, page.keys);
+    if (page.collision)
+      collisions.push(page.collision);
+  }
+  return { collisions, keys };
+};
+
+export { buildReactServerComponentsPass2, reactServerPageManifestKeys2 };