elegance-js 2.1.37 → 3.0.1

package/dist/build/dev.js

@@ -0,0 +1,234 @@
+import { getPageRoutes } from "../page-tools.js";
+import { rm, mkdir, writeFile, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { c, logger } from "../logger.js";
+import { OUT_DIR, DIST_DIR, CACHE_DIR, PAGES_DIR, loadPaths } from "../constants.js";
+import {
+  transpileAllRoutes,
+  buildClientRuntime,
+  copyPublicDir,
+  copyPublicDirIncremental,
+  findAndCacheStatusCodePages,
+  discoverApiRoutes,
+  discoverMiddlewares,
+  computeFileHash,
+  loadIncrementalState,
+  saveIncrementalState,
+  loadRouteFromCache,
+  pageCacheKey,
+  layoutFileCacheKey
+} from "./common.js";
+import { existsSync } from "node:fs";
+import { isRichError, printError, richError } from "../error.js";
+const PUBLIC_DIR = join(process.cwd(), "public");
+const IS_INCREMENTAL = process.env.ELEGANCE_BUILD_MODE === "incremental";
+const SLUG_PATTERN = /\[([^\]]+)\]/;
+async function buildDevAll() {
+  logger.info(`Beginning build.. (${IS_INCREMENTAL ? "incremental" : "full"})`);
+  const start = performance.now();
+  if (existsSync(PAGES_DIR) === false) {
+    logger.warn("config.pagesDirectory did not exist, it will be created.");
+    await mkdir(PAGES_DIR, { recursive: true });
+  }
+  if (IS_INCREMENTAL) {
+    await rm(DIST_DIR, { recursive: true, force: true });
+    await mkdir(DIST_DIR, { recursive: true });
+    await mkdir(CACHE_DIR, { recursive: true });
+    await copyPublicDirIncremental(PUBLIC_DIR);
+    await buildClientRuntime(false);
+  } else {
+    await rm(OUT_DIR, { recursive: true, force: true });
+    await mkdir(OUT_DIR, { recursive: true });
+    await mkdir(DIST_DIR, { recursive: true });
+    await mkdir(CACHE_DIR, { recursive: true });
+    await copyPublicDir(PUBLIC_DIR);
+    await buildClientRuntime(false);
+  }
+  const allRoutes = await getPageRoutes(PAGES_DIR);
+  if (IS_INCREMENTAL) {
+    await pruneStaleOutputs(allRoutes.map((r) => r.pageFile));
+  }
+  for (const route of allRoutes) {
+    if (!route.isDynamic && SLUG_PATTERN.test(route.pathname)) {
+      printError(richError({
+        title: "Missing Enumerations",
+        cause: `Route ${route.pathname} is marked as a [slug] route, and is currently set to isDynamic = false.For a [slug] route to be static, it must export getEnumeratedRoutes(); so that all possible paths can be generated statically.`,
+        origin: route.pathname,
+        doShowStack: false
+      }));
+      process.exit(1);
+    }
+  }
+  const prevState = IS_INCREMENTAL ? await loadIncrementalState() : { fileHashes: {}, clientCodeHashes: {} };
+  const nextFileHashes = {};
+  const skipServerKeys = /* @__PURE__ */ new Set();
+  const unchangedPathnames = /* @__PURE__ */ new Set();
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const route of allRoutes) {
+    allFiles.add(route.pageFile);
+    for (const l of route.layouts) allFiles.add(l);
+  }
+  await Promise.all([...allFiles].map(async (f) => {
+    nextFileHashes[f] = await computeFileHash(f);
+  }));
+  if (IS_INCREMENTAL) {
+    for (const route of allRoutes) {
+      const key = pageCacheKey(route.pathname);
+      const pageChanged = nextFileHashes[route.pageFile] !== prevState.fileHashes[route.pageFile];
+      const layoutChanged = route.layouts.some((l) => nextFileHashes[l] !== prevState.fileHashes[l]);
+      if (!pageChanged && !layoutChanged && existsSync(join(CACHE_DIR, `${key}.server.mjs`))) {
+        skipServerKeys.add(key);
+        unchangedPathnames.add(route.pathname);
+        for (const l of route.layouts) {
+          const lk = layoutFileCacheKey(l);
+          if (existsSync(join(CACHE_DIR, `${lk}.server.mjs`)))
+            skipServerKeys.add(lk);
+        }
+      }
+    }
+  }
+  const transpiled = await transpileAllRoutes(allRoutes, false, skipServerKeys);
+  let prevManifest = null;
+  if (IS_INCREMENTAL) {
+    try {
+      prevManifest = JSON.parse(await readFile(join(OUT_DIR, "paths.json"), "utf-8"));
+    } catch {
+    }
+  }
+  const manifestRoutes = [];
+  for (const route of allRoutes) {
+    const t = transpiled.get(route.pathname);
+    if (!t) {
+      printError(richError({
+        title: "No transpilation result",
+        cause: "This is an internal error within Elegance, please report it.",
+        doShowStack: false
+      }));
+      process.exit(1);
+    }
+    const key = pageCacheKey(t.pathname);
+    const layoutKeys = t.layouts.map(layoutFileCacheKey);
+    const sharedChunks = t.sharedChunkPaths;
+    if (!route.isDynamic) {
+      manifestRoutes.push({
+        kind: "static",
+        pathname: route.pathname,
+        pageFile: route.pageFile,
+        layouts: route.layouts,
+        layoutCacheKeys: layoutKeys,
+        cacheKey: key,
+        sharedChunkPaths: sharedChunks
+      });
+      continue;
+    }
+    const mod = await loadRouteFromCache({
+      pageFile: route.pageFile,
+      layouts: route.layouts,
+      layoutCacheKeys: layoutKeys,
+      cacheKey: key,
+      pathname: route.pathname
+    });
+    if (!mod.getEnumeratedRoutes) {
+      if (unchangedPathnames.has(route.pathname) && prevManifest) {
+        const prevEntry = prevManifest.routes.find((r) => r.pathname === route.pathname);
+        if (prevEntry) {
+          manifestRoutes.push(prevEntry);
+          continue;
+        }
+      }
+      manifestRoutes.push({
+        kind: "dynamic",
+        pathname: route.pathname,
+        pageFile: route.pageFile,
+        layouts: route.layouts,
+        layoutCacheKeys: layoutKeys,
+        cacheKey: key,
+        sharedChunkPaths: sharedChunks
+      });
+      continue;
+    }
+    const slugs = await mod.getEnumeratedRoutes();
+    const freshPaths = new Set(slugs.map((slug) => route.pathname.replace(/\[([^\]]+)\]/g, slug)));
+    if (IS_INCREMENTAL && prevManifest) {
+      const prevEnumerated = prevManifest.routes.filter(
+        (r) => r.kind === "enumerated" && r.patternPathname === route.pathname
+      );
+      await Promise.all(
+        prevEnumerated.filter((r) => !freshPaths.has(r.pathname)).map((r) => {
+          const dir = r.pathname === "/" ? DIST_DIR : join(DIST_DIR, r.pathname);
+          return Promise.all([
+            unlink(join(dir, "index.html")).catch(() => {
+            }),
+            unlink(join(dir, "bundle.js")).catch(() => {
+            })
+          ]);
+        })
+      );
+    }
+    for (const slug of slugs) {
+      const concretePath = route.pathname.replace(/\[([^\]]+)\]/g, slug);
+      manifestRoutes.push({
+        kind: "enumerated",
+        pathname: concretePath,
+        patternPathname: route.pathname,
+        pageFile: route.pageFile,
+        layouts: route.layouts,
+        layoutCacheKeys: layoutKeys,
+        cacheKey: key,
+        sharedChunkPaths: sharedChunks
+      });
+    }
+  }
+  const [statusCodePages, apiRoutes, middlewares] = await Promise.all([
+    findAndCacheStatusCodePages(),
+    discoverApiRoutes(PAGES_DIR),
+    discoverMiddlewares(PAGES_DIR)
+  ]);
+  const manifest = {
+    buildTime: Date.now(),
+    routes: manifestRoutes,
+    statusCodePages,
+    apiRoutes,
+    middlewares
+  };
+  await writeFile(join(OUT_DIR, "paths.json"), JSON.stringify(manifest, null, 2));
+  await saveIncrementalState({ fileHashes: nextFileHashes, clientCodeHashes: {} });
+  await rm(join(process.cwd(), ".temp"), { recursive: true, force: true }).catch(() => {
+  });
+  logger.debug(`Built in ${c.dim}${(performance.now() - start).toFixed(1)}ms${c.reset}`);
+}
+async function pruneStaleOutputs(livePageFiles) {
+  let prev;
+  try {
+    prev = JSON.parse(await readFile(join(OUT_DIR, "paths.json"), "utf-8"));
+  } catch {
+    return;
+  }
+  const live = new Set(livePageFiles);
+  const removals = [];
+  for (const entry of prev.routes) {
+    if (live.has(entry.pageFile)) continue;
+    const dir = entry.pathname === "/" ? DIST_DIR : join(DIST_DIR, entry.pathname);
+    removals.push(unlink(join(dir, "index.html")).catch(() => {
+    }));
+    removals.push(unlink(join(dir, "bundle.js")).catch(() => {
+    }));
+  }
+  if (removals.length === 0) return;
+  await Promise.all(removals);
+}
+(async () => {
+  await loadPaths();
+  try {
+    await buildDevAll();
+    process.exit(0);
+  } catch (err) {
+    if (isRichError(err)) {
+      printError(err);
+    } else {
+      console.error(err);
+    }
+    process.exit(1);
+  }
+})();

package/dist/build/prod.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prod.d.ts.map

package/dist/build/prod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prod.d.ts","sourceRoot":"","sources":["../../src/build/prod.ts"],"names":[],"mappings":""}

package/dist/build/prod.js

@@ -0,0 +1,212 @@
+import { getPageRoutes } from "../page-tools.js";
+import { generateSyntheticBundle } from "../processing/oxc.js";
+import { generatePageHTML, createRenderContext, runWithRenderContext } from "./render.js";
+import { rm, mkdir, writeFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { logger } from "../logger.js";
+import { OUT_DIR, DIST_DIR, CACHE_DIR, PAGES_DIR, loadPaths } from "../constants.js";
+import {
+  transpileAllRoutes,
+  loadRouteFromCache,
+  buildClientRuntime,
+  copyPublicDir,
+  findAndCacheStatusCodePages,
+  discoverApiRoutes,
+  discoverMiddlewares,
+  runBuildHooks,
+  minifyHtml,
+  minifyCode,
+  getSlugParamName,
+  fileHasExports,
+  layoutFileCacheKey,
+  pageCacheKey,
+  preClientMjsPath
+} from "./common.js";
+import { existsSync } from "node:fs";
+import { isRichError, printError, richError } from "../error.js";
+const PUBLIC_DIR = join(process.cwd(), "public");
+async function buildStaticTasks(tasks) {
+  logger.info(`Building ${tasks.length} static route${tasks.length === 1 ? "" : "s"}`);
+  let built = 0;
+  await Promise.all(tasks.map(async ({ route, transpiled, layoutCacheKeys, cacheKey, params, outPathname }) => {
+    if (await fileHasExports(route.pageFile) === false) {
+      throw richError({
+        title: "Empty Page",
+        cause: "Empty pages are not allowed in production builds.",
+        hint: "Try removing the file, or write a page there.",
+        doShowStack: false
+      });
+    }
+    logger.info(`  > ${outPathname}`);
+    const compiled = await loadRouteFromCache({
+      pageFile: route.pageFile,
+      layouts: route.layouts,
+      layoutCacheKeys,
+      cacheKey,
+      pathname: outPathname
+    });
+    const ctx = createRenderContext();
+    for (const { id, initial } of compiled.atomSeeds) {
+      if (!ctx.atomValues.has(id)) {
+        ctx.atomValues.set(id, initial);
+        ctx.atomRegistry.push({ id });
+      }
+    }
+    const routeOutDir = outPathname === "/" ? DIST_DIR : join(DIST_DIR, outPathname);
+    try {
+      await runWithRenderContext(ctx, async () => {
+        await runBuildHooks(compiled, "pre");
+        const rootNode = await compiled.default(params);
+        const metaNodes = await compiled.metadata(params);
+        const bundleUrl = `${outPathname === "/" ? "" : outPathname}/bundle.js`;
+        const { fullHtml } = await generatePageHTML(
+          rootNode,
+          metaNodes,
+          { ...route, pathname: outPathname },
+          bundleUrl,
+          ctx,
+          transpiled.sharedChunkPaths
+        );
+        const preClientCode = await readFile(preClientMjsPath(pageCacheKey(transpiled.pathname)), "utf-8");
+        const syntheticCode = generateSyntheticBundle(preClientCode, outPathname, ctx.regions, layoutCacheKeys);
+        const finalClientCode = await minifyCode(syntheticCode);
+        await mkdir(routeOutDir, { recursive: true });
+        await writeFile(join(routeOutDir, "bundle.js"), finalClientCode);
+        await writeFile(join(routeOutDir, "index.html"), minifyHtml(fullHtml));
+        await runBuildHooks(compiled, "post");
+      });
+      built++;
+    } catch (err) {
+      if (isRichError(err)) {
+        throw err;
+      }
+      throw richError({
+        title: "Failed to Render Route",
+        cause: err,
+        origin: route.pageFile,
+        doShowStack: true
+      });
+    }
+  }));
+}
+async function buildProdAll() {
+  logger.info("Beginning production build...");
+  if (existsSync(PAGES_DIR) === false) {
+    printError(richError({
+      title: "Missing pagesDirectory",
+      cause: `config.pagesDirectory ${PAGES_DIR} does not exist. This is most likely due to a malformed configuration. Please create the directory and try again.`,
+      doShowStack: false
+    }));
+    process.exit(1);
+  }
+  await rm(OUT_DIR, { recursive: true, force: true });
+  await mkdir(OUT_DIR, { recursive: true });
+  await mkdir(DIST_DIR, { recursive: true });
+  await mkdir(CACHE_DIR, { recursive: true });
+  await copyPublicDir(PUBLIC_DIR);
+  await buildClientRuntime(true);
+  const allRoutes = await getPageRoutes(PAGES_DIR);
+  const splitMap = await transpileAllRoutes(allRoutes, true);
+  const staticTasks = [];
+  const manifestRoutes = [];
+  for (const route of allRoutes) {
+    const transpiled = splitMap.get(route.pathname);
+    if (!transpiled) {
+      printError(richError({
+        title: "No transpilation result",
+        cause: "This is an internal error within Elegance, please report it.",
+        doShowStack: false
+      }));
+      process.exit(1);
+    }
+    const cacheKey = pageCacheKey(transpiled.pathname);
+    const layoutKeys = transpiled.layouts.map(layoutFileCacheKey);
+    if (!route.isDynamic) {
+      staticTasks.push({ route, transpiled, layoutCacheKeys: layoutKeys, cacheKey, params: {}, outPathname: route.pathname });
+      manifestRoutes.push({
+        pathname: route.pathname,
+        kind: "static",
+        pageFile: route.pageFile,
+        layoutCacheKeys: layoutKeys,
+        layouts: route.layouts,
+        sharedChunkPaths: transpiled.sharedChunkPaths,
+        cacheKey
+      });
+      continue;
+    }
+    const compiled = await loadRouteFromCache({
+      pageFile: route.pageFile,
+      layouts: route.layouts,
+      layoutCacheKeys: layoutKeys,
+      cacheKey,
+      pathname: route.pathname
+    });
+    if (!compiled.getEnumeratedRoutes) {
+      manifestRoutes.push({
+        pathname: route.pathname,
+        kind: "dynamic",
+        pageFile: route.pageFile,
+        layouts: route.layouts,
+        layoutCacheKeys: layoutKeys,
+        cacheKey,
+        sharedChunkPaths: transpiled.sharedChunkPaths
+      });
+      continue;
+    }
+    const rawSlugs = await compiled.getEnumeratedRoutes();
+    for (const slug of rawSlugs) {
+      const concretePath = route.pathname.replace(/\[([^\]]+)\]/g, slug);
+      staticTasks.push({
+        route,
+        transpiled,
+        layoutCacheKeys: layoutKeys,
+        cacheKey,
+        //params:      { [getSlugParamName(route.pathname)]: slug },
+        params: { [getSlugParamName(route.pathname)]: slug.split("/") },
+        outPathname: concretePath
+      });
+      manifestRoutes.push({
+        pathname: concretePath,
+        kind: "enumerated",
+        pageFile: route.pageFile,
+        layouts: route.layouts,
+        layoutCacheKeys: layoutKeys,
+        cacheKey,
+        sharedChunkPaths: transpiled.sharedChunkPaths,
+        patternPathname: route.pathname
+      });
+    }
+  }
+  if (staticTasks.length > 0) {
+    await buildStaticTasks(staticTasks);
+  }
+  const [statusCodePages, apiRoutes, middlewares] = await Promise.all([
+    findAndCacheStatusCodePages(),
+    discoverApiRoutes(PAGES_DIR),
+    discoverMiddlewares(PAGES_DIR)
+  ]);
+  const manifest = {
+    buildTime: Date.now(),
+    routes: manifestRoutes,
+    statusCodePages,
+    apiRoutes,
+    middlewares
+  };
+  await writeFile(join(OUT_DIR, "paths.json"), JSON.stringify(manifest, null, 2));
+  await rm(join(process.cwd(), ".temp"), { recursive: true, force: true }).catch(() => {
+  });
+}
+(async () => {
+  await loadPaths();
+  try {
+    await buildProdAll();
+    process.exit(0);
+  } catch (err) {
+    if (isRichError(err)) {
+      printError(err);
+    } else {
+      console.error(err);
+    }
+    process.exit(1);
+  }
+})();

package/dist/build/render.d.ts

@@ -0,0 +1,29 @@
+import type { RouteInfo } from "../page-tools";
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface RenderContext {
+    atomValues: Map<string, any>;
+    atomRegistry: Array<{
+        id: string;
+    }>;
+    regions: Array<any[]>;
+    regionCounter: number;
+    insideComponentDepth: number;
+}
+export declare const renderContextStorage: AsyncLocalStorage<RenderContext>;
+export declare function createRenderContext(): RenderContext;
+export declare function runWithRenderContext<T>(ctx: RenderContext, fn: () => Promise<T>): Promise<T>;
+export declare function getAtomSnapshot(ctx: RenderContext): Record<string, any>;
+export interface HtmlSink {
+    append(s: string): void;
+}
+export declare class HtmlBuilder implements HtmlSink {
+    private parts;
+    append(s: string): void;
+    join(): string;
+}
+export interface GeneratePageHtmlResult {
+    fullHtml: string;
+}
+export declare function generatePageHTML(pageRoot: VirtualNode, metaNodes: VirtualNode[], route: RouteInfo, bundleSrc: string, ctx: RenderContext, extraScripts?: string[]): Promise<GeneratePageHtmlResult>;
+export declare function generateDynamicPageHTML(pageRoot: VirtualNode, metaNodes: VirtualNode[], route: RouteInfo, getClientCode: () => string, ctx: RenderContext): Promise<string>;
+//# sourceMappingURL=render.d.ts.map

package/dist/build/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/build/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAIrD,MAAM,WAAW,aAAa;IAC1B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,YAAY,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpC,OAAO,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,oBAAoB,kCAAyC,CAAC;AAE3E,wBAAgB,mBAAmB,IAAI,aAAa,CAQnD;AAED,wBAAsB,oBAAoB,CAAC,CAAC,EACxC,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAMvE;AAeD,MAAM,WAAW,QAAQ;IACrB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,qBAAa,WAAY,YAAW,QAAQ;IACxC,OAAO,CAAC,KAAK,CAAgB;IAC7B,MAAM,CAAC,CAAC,EAAE,MAAM;IAChB,IAAI,IAAI,MAAM;CACjB;AAED,MAAM,WAAW,sBAAsB;IACnC,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,gBAAgB,CAClC,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,WAAW,EAAE,EACxB,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,aAAa,EAClB,YAAY,CAAC,EAAE,MAAM,EAAE,GACxB,OAAO,CAAC,sBAAsB,CAAC,CAgCjC;AAED,wBAAsB,uBAAuB,CACzC,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,WAAW,EAAE,EACxB,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,MAAM,MAAM,EAC3B,GAAG,EAAE,aAAa,GACnB,OAAO,CAAC,MAAM,CAAC,CA6BjB"}