@aklinker1/aframe 1.0.4 → 1.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aklinker1/aframe",
-  "version": "1.0.4",
-  "packageManager": "bun@1.3.2",
+  "version": "1.1.1",
+  "packageManager": "bun@1.3.5",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -21,13 +21,13 @@
     "check": "check",
     "aframe": "bun --silent bin/aframe.ts",
     "dev": "bun aframe demo",
-    "build": "bun aframe build demo && bun run demo/post-build.js",
+    "build": "bun aframe build demo",
     "preview": "bun --cwd demo/.output --env-file ../.env server-entry.js",
     "release": "bun run scripts/release.ts"
   },
   "devDependencies": {
     "@aklinker1/check": "^1.4.5",
-    "@types/bun": "latest",
+    "@types/bun": "^1.3.5",
     "oxlint": "^0.15.11",
     "prettier": "^3.5.2",
     "publint": "^0.3.6",

package/src/client/server.ts

@@ -1,19 +1,10 @@
 import type { BunFile } from "bun";
-import { readFileSync } from "node:fs";
-import { join, extname, basename } from "node:path";
+import { basename, extname, join } from "node:path";
 
 export interface AframeServer {
   listen(port: number): void | never;
 }
 
-const staticPathsFile = join(aframe.rootDir, "static.json");
-const publicDir = aframe.publicDir;
-
-let staticPaths: Record<string, { cacheable: boolean; path: string }> = {};
-try {
-  staticPaths = JSON.parse(readFileSync(staticPathsFile, "utf-8"));
-} catch {}
-
 /**
  * Fetches a file from the `public` directory.
  */
@@ -28,11 +19,8 @@ export function fetchStatic(options?: {
     const path = new URL(request.url).pathname.replace(/\/+$/, "") || "/";
 
     // Fetch file on disk
-    if (staticPaths[path]) {
-      const filePath = join(aframe.rootDir, staticPaths[path].path);
-      const file = Bun.file(filePath);
-      const gzFile = Bun.file(filePath + ".gz");
-
+    if (aframe.static?.[path]) {
+      const { file, gzFile } = aframe.static[path];
       const customResponse = await options?.onFetch?.(path, file);
       if (customResponse) return customResponse;
 
@@ -72,13 +60,22 @@ export function fetchStatic(options?: {
     }
 
     // Fallback to public/index.html file
-    const file = Bun.file(join(publicDir, "index.html"));
-    const gzFile = Bun.file(join(publicDir, "index.html.gz"));
-    return new Response(gzFile.stream(), {
-      headers: {
-        "Content-Type": file.type,
-        "Content-Encoding": "gzip",
-      },
-    });
+    if (aframe.static?.["fallback"]) {
+      const { file, gzFile } = aframe.static["fallback"];
+      return createGzipResponse(file, gzFile);
+    }
+
+    const file = Bun.file(join(aframe.publicDir, "index.html"));
+    const gzFile = Bun.file(join(aframe.publicDir, "index.html.gz"));
+    return createGzipResponse(file, gzFile);
   };
 }
+
+function createGzipResponse(file: BunFile, gzFile: BunFile): Response {
+  return new Response(gzFile.stream(), {
+    headers: {
+      "Content-Type": file.type,
+      "Content-Encoding": "gzip",
+    },
+  });
+}

package/src/config.ts

@@ -1,6 +1,6 @@
-import * as vite from "vite";
-import { resolve, join, relative } from "node:path/posix";
+import { join, relative, resolve } from "node:path/posix";
 import type { LaunchOptions } from "puppeteer";
+import * as vite from "vite";
 
 export type AframeHooks = {
   afterServerBuild?: (config: ResolvedConfig) => Promise<void> | void;
@@ -18,6 +18,11 @@ export type UserConfig = {
   appPort?: number;
   serverPort?: number;
   hooks?: AframeHooks;
+  /**
+   * Compile the app into a single binary using Bun.
+   * @default true
+   */
+  compile?: boolean;
 };
 
 export type PrerenderConfig = {
@@ -54,6 +59,9 @@ export type ResolvedConfig = {
   prerenderedRoutes: string[];
   prerender: PrerenderConfig | false;
   hooks: AframeHooks | undefined;
+  serverEntryPath: string;
+  compileOutputPath: string;
+  compile: boolean;
 };
 
 export function defineConfig(config: UserConfig): UserConfig {
@@ -75,6 +83,8 @@ export async function resolveConfig(
   const appOutDir = join(outDir, "public");
   const serverOutDir = join(outDir, "server");
   const prerenderedDir = join(outDir, "prerendered");
+  const serverEntryPath = join(outDir, "server-entry.ts");
+  const compileOutputPath = join(outDir, "server-entry");
 
   const configFile = join(rootDir, "aframe.config"); // No file extension to resolve any JS/TS file
   const relativeConfigFile = "./" + relative(import.meta.dir, configFile);
@@ -147,10 +157,13 @@ export async function resolveConfig(
     appPort,
     serverPort,
     proxyPaths,
+    serverEntryPath,
+    compileOutputPath,
 
     prerenderedRoutes: userConfig.prerenderedRoutes ?? ["/"],
     vite: viteConfig,
     prerender: userConfig.prerender ?? {},
     hooks: userConfig.hooks,
+    compile: userConfig.compile ?? true,
   };
 }

package/src/env.d.ts

@@ -1,10 +1,14 @@
+import type { BunFile } from "bun";
 import "vite/client";
 
 declare global {
   declare var aframe: {
     command: "build" | "serve";
-    rootDir: string;
     publicDir: string;
+    static?: Record<
+      string,
+      { file: BunFile; gzFile: BunFile; cacheable: boolean }
+    >;
   };
 }
 

package/src/index.ts

@@ -6,13 +6,13 @@ import {
 } from "node:fs";
 import { cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import { join, relative } from "node:path/posix";
+import { pipeline } from "node:stream/promises";
+import { createGzip } from "node:zlib";
 import * as vite from "vite";
 import { BLUE, BOLD, CYAN, DIM, GREEN, MAGENTA, RESET, YELLOW } from "./color";
 import type { ResolvedConfig } from "./config";
-import { createTimer } from "./timer";
 import { prerenderPages, type PrerenderedRoute } from "./prerender";
-import { createGzip } from "node:zlib";
-import { pipeline } from "node:stream/promises";
+import { createTimer } from "./timer";
 
 export * from "./config";
 export * from "./dev-server";
@@ -46,31 +46,33 @@ export async function build(config: ResolvedConfig) {
     (file) => !bundledAppFileSet.has(file),
   );
 
-  await gzipFiles(config, allAbsoluteAppFiles);
+  await gzipFiles(allAbsoluteAppFiles);
 
-  const staticRoutesFile = join(config.outDir, "static.json");
-  let staticRoutes = [
+  const staticRoutes: StaticRouteArray = [
     ...Array.from(bundledAppFiles)
       .filter((path) => path !== "index.html")
-      .map((path) => [`/${path}`, { cacheable: true, path: `public/${path}` }]),
+      .map((path) => ({
+        route: `/${path}`,
+        cacheable: true,
+        filePath: `public/${path}`,
+        gzPath: `public/${path}.gz`,
+      })),
     ...publicAppFiles
       .filter((path) => path !== "index.html")
-      .map((path) => [
-        `/${path}`,
-        { cacheable: false, path: `public/${path}` },
-      ]),
+      .flatMap((path) => ({
+        route: `/${path}`,
+        cacheable: false,
+        filePath: `public/${path}`,
+        gzPath: `public/${path}.gz`,
+      })),
   ];
-  await writeFile(
-    staticRoutesFile,
-    JSON.stringify(Object.fromEntries(staticRoutes)),
-  );
 
   console.log();
 
   const serverTimer = createTimer();
-  console.log(`${BOLD}${CYAN}ℹ${RESET} Building ${CYAN}./server${RESET}`);
-  await buildServer(config);
-  console.log(`${GREEN}✔${RESET} Built in ${serverTimer()}`);
+  console.log(`${BOLD}${CYAN}ℹ${RESET} Preparing ${CYAN}./server${RESET}`);
+  await buildServer(config, staticRoutes);
+  console.log(`${GREEN}✔${RESET} Done in ${serverTimer()}`);
 
   console.log();
 
@@ -89,25 +91,27 @@ export async function build(config: ResolvedConfig) {
     console.log(`${DIM}${BOLD}→${RESET} Pre-render disabled`);
   }
 
-  await gzipFiles(
-    config,
-    prerendered.map((entry) => entry.absolutePath),
-  );
-
-  staticRoutes = staticRoutes.concat(
-    prerendered.map((entry) => [
-      entry.route,
-      { cacheable: false, path: `prerendered/${entry.relativePath}` },
-    ]),
-  );
-  await writeFile(
-    staticRoutesFile,
-    JSON.stringify(Object.fromEntries(staticRoutes)),
-  );
+  await gzipFiles(prerendered.map((entry) => entry.absolutePath));
+
+  staticRoutes.push({
+    route: "fallback",
+    cacheable: false,
+    filePath: "public/index.html",
+    gzPath: "public/index.html.gz",
+  });
+  for (const entry of prerendered) {
+    staticRoutes.push({
+      route: entry.route,
+      cacheable: false,
+      filePath: `prerendered/${entry.relativePath}`,
+      gzPath: `prerendered/${entry.relativePath}.gz`,
+    });
+  }
+  await writeServerEntry(config, staticRoutes);
 
   console.log();
 
-  console.log(`${GREEN}✔${RESET} Application built in ${buildTimer()}`);
+  console.log(`${GREEN}✔${RESET} Bundled in ${buildTimer()}`);
   const relativeOutDir = `${relative(config.rootDir, config.outDir)}/`;
   const files = (
     await listDirFiles(config.outDir, (path) => !path.includes("node_modules"))
@@ -126,22 +130,50 @@ export async function build(config: ResolvedConfig) {
     files
       .map(([file, size], i, array) => {
         const boxChar = i === array.length - 1 ? "└" : "├";
-        return `   ${DIM}${boxChar}─ ${relativeOutDir}${RESET}${getColor(file)}${file.padEnd(fileColumnCount)}${RESET}  ${DIM}${prettyBytes(size)}${RESET}`;
+        return `  ${DIM}${boxChar}─ ${relativeOutDir}${RESET}${getColor(file)}${file.padEnd(fileColumnCount)}${RESET}  ${DIM}${prettyBytes(size)}${RESET}`;
       })
       .join("\n"),
   );
   console.log(`${CYAN}Σ Total size:${RESET} ${prettyBytes(totalSize)}`);
   console.log();
 
-  console.log(
-    `To preview production build, run:
+  if (config.compile) {
+    const compileTimer = createTimer();
+    console.log(`${BOLD}${CYAN}ℹ${RESET} Compiling single binary`);
 
-    ${GREEN}bun run ${relative(process.cwd(), config.outDir)}/server-entry.ts${RESET}
+    await writeServerEntry(config, staticRoutes);
+    await Bun.build({
+      compile: {
+        outfile: config.compileOutputPath,
+      },
+      entrypoints: [config.serverEntryPath],
+    });
+    console.log(`${GREEN}✔${RESET} Compiled in ${compileTimer()}`);
+    console.log(
+      `  ${DIM}└─${RESET} ${BLUE}${relative(process.cwd(), config.compileOutputPath)}${RESET}  ${DIM}${prettyBytes(lstatSync(config.compileOutputPath).size)}${RESET}`,
+    );
+    console.log();
+
+    console.log(
+      `To preview production build, run:
+
+   ${GREEN}./${relative(process.cwd(), config.compileOutputPath)}${RESET}
 `,
-  );
+    );
+  } else {
+    console.log(
+      `To preview production build, run:
+
+   ${GREEN}bun run ${relative(process.cwd(), config.serverEntryPath)}${RESET}
+`,
+    );
+  }
 }
 
-async function buildServer(config: ResolvedConfig): Promise<void> {
+async function buildServer(
+  config: ResolvedConfig,
+  staticRoutes: StaticRouteArray,
+): Promise<void> {
   const cpDirOptions: CopyOptions = {
     recursive: true,
     filter: (src) =>
@@ -172,7 +204,7 @@ async function buildServer(config: ResolvedConfig): Promise<void> {
   const packageJson = await Bun.file(config.packageJsonPath)
     .json()
     .catch(() => ({}));
-  await Bun.write(
+  await writeFile(
     join(config.outDir, "package.json"),
     JSON.stringify(
       {
@@ -185,23 +217,7 @@ async function buildServer(config: ResolvedConfig): Promise<void> {
     ),
   );
 
-  await Bun.write(
-    join(config.outDir, "server-entry.ts"),
-    `import { resolve } from 'node:path';
-
-globalThis.aframe = {
-  command: "build",
-  rootDir: import.meta.dir,
-  publicDir: resolve(import.meta.dir, "public"),
-};
-
-const { default: server } = await import("./server/main");
-
-const port = Number(process.env.PORT) || 3000;
-console.log(\`Server running @ http://localhost:\${port}\`);
-server.listen(port);
-`,
-  );
+  await writeServerEntry(config, staticRoutes);
 
   const installProc = Bun.spawn(
     ["bun", "i", "--production", "--frozen-lockfile"],
@@ -217,6 +233,45 @@ server.listen(port);
   await config.hooks?.afterServerBuild?.(config);
 }
 
+async function writeServerEntry(
+  config: ResolvedConfig,
+  staticRoutes: StaticRouteArray,
+): Promise<void> {
+  const staticDef: string[] = [];
+  if (staticRoutes.length > 0) {
+    staticDef.push("  static: {");
+    staticRoutes.forEach((entry, i) => {
+      staticDef.push(
+        `  "${entry.route}": { file: Bun.file(file${i}), cacheable: ${entry.cacheable}, gzFile: Bun.file(gzFile${i}) },`,
+      );
+    });
+    staticDef.push("  },");
+  }
+
+  await writeFile(
+    join(config.outDir, "server-entry.ts"),
+    `import { resolve } from 'node:path';
+${staticRoutes
+  .flatMap(({ filePath }, i) => [
+    `import file${i} from "./${filePath}" with { type: "file" };`,
+    `import gzFile${i} from "./${filePath}.gz" with { type: "file" };`,
+  ])
+  .join("\n")}
+import server from "./server/main";
+
+globalThis.aframe = {
+  command: "build",
+  publicDir: resolve(import.meta.dir, "public"),
+${staticDef.join("\n")}
+};
+
+const port = Number(process.env.PORT) || 3000;
+console.log(\`Server running @ http://localhost:\${port}\`);
+server.listen(port);
+`,
+  );
+}
+
 function getColor(file: string) {
   if (file.endsWith(".js")) return CYAN;
   if (file.endsWith(".ts")) return CYAN;
@@ -238,14 +293,11 @@ function prettyBytes(bytes: number) {
   return `${unit === "B" ? value : value.toFixed(2)} ${unit}`;
 }
 
-async function gzipFiles(
-  config: ResolvedConfig,
-  files: string[],
-): Promise<void> {
-  for (const file of files) await gzipFile(config, file);
+async function gzipFiles(files: string[]): Promise<void> {
+  for (const file of files) await gzipFile(file);
 }
 
-async function gzipFile(config: ResolvedConfig, file: string): Promise<void> {
+async function gzipFile(file: string): Promise<void> {
   await writeFile(`${file}.gz`, "");
   await pipeline(
     createReadStream(file),
@@ -276,3 +328,11 @@ async function listDirFiles(
 
   return files;
 }
+
+type StaticRouteEntry = {
+  route: string;
+  filePath: string;
+  gzPath: string;
+  cacheable: boolean;
+};
+type StaticRouteArray = StaticRouteEntry[];

package/src/prerender.ts

@@ -1,5 +1,5 @@
-import { dirname, join } from "node:path";
 import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import type { Browser } from "puppeteer";
 import type { ResolvedConfig } from "./config";