elegance-js 2.1.37 → 3.0.0

package/dist/build/common.js

@@ -0,0 +1,599 @@
+import esbuild from "esbuild";
+import {
+  sanitize,
+  eleganceTsxPlugin,
+  collectLayouts,
+  composeRenderFn,
+  gatherMetaFromModules
+} from "../page-tools.js";
+import { transformBundle, transformChunk, generateLayoutBundle } from "../processing/oxc.js";
+import { hookGlobals } from "../globals.js";
+hookGlobals();
+import {
+  readFile,
+  mkdir,
+  writeFile,
+  copyFile,
+  cp,
+  stat as fsStat,
+  unlink,
+  readdir,
+  rm
+} from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, dirname, resolve, relative, basename } from "node:path";
+import { DIST_DIR, CACHE_DIR, PAGES_DIR } from "../constants.js";
+import { isRichError, printError, richError } from "../error.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+const SINGLE_PARAM_RE = /\[([^\]]+)\]/;
+const PARAM_STRIP_RE = /^\.{3}/;
+const EXPORT_RE = /\bexport\b/;
+const IS_DEV = process.env.ELEGANCE_DEV_MODE === "dev";
+const importContext = new AsyncLocalStorage();
+async function importModule(path) {
+  const store = {
+    preBuildHooks: [],
+    postBuildHooks: [],
+    buildCallbacks: [],
+    publishFiles: [],
+    atomSeeds: []
+  };
+  const module = await importContext.run(store, async () => await import(path));
+  return { module, ...store };
+}
+const importedModules = /* @__PURE__ */ new Map();
+async function importCompiledModule(sourceFile, filePath) {
+  const contents = await readFile(filePath);
+  if (importedModules.has(sourceFile)) {
+    return importedModules.get(sourceFile);
+  }
+  const tmpDir = join(process.cwd(), ".temp");
+  await mkdir(tmpDir, { recursive: true });
+  const tmpPath = join(tmpDir, `${Date.now() + Math.random() * 1e3}.mjs`);
+  await writeFile(tmpPath, contents);
+  try {
+    return await importModule(`copycat://${resolve(sourceFile)}?real=${resolve(tmpPath)}`);
+  } catch (err) {
+    if (isRichError(err)) throw err;
+    throw richError({
+      title: "Failed to Import Module",
+      cause: err,
+      doShowStack: true
+    });
+  } finally {
+    await unlink(tmpPath);
+  }
+}
+function pageCacheKey(pathname) {
+  return `route_${sanitize(pathname.replace(/^\//, "")) || "index"}`;
+}
+function layoutFileCacheKey(layoutPath) {
+  let s = sanitize(relative(PAGES_DIR, layoutPath).replace(/\.tsx?$/, ""));
+  if (s.endsWith("_layout")) s = s.slice(0, -7);
+  return `layout_${s}`;
+}
+function statusCodeCacheKey(filePath) {
+  return `statusCode_${sanitize(relative(PAGES_DIR, filePath).replace(/\.tsx?$/, ""))}`;
+}
+function serverMjsPath(key) {
+  return join(CACHE_DIR, `${key}.server.mjs`);
+}
+function preClientMjsPath(key) {
+  return join(CACHE_DIR, `${key}.pre_client.mjs`);
+}
+function clientMjsPath(key) {
+  return join(CACHE_DIR, `${key}.client.mjs`);
+}
+function chunkClientPath(key) {
+  return join(DIST_DIR, "chunks", `${key}.client.mjs`);
+}
+async function runBuildHooks(compiled, stage) {
+  if (stage === "pre") {
+    const buildCallbacks = compiled.buildCallbacks.splice(0);
+    try {
+      await Promise.all(buildCallbacks.map((cb) => cb()));
+    } catch (err) {
+      if (isRichError(err)) throw err;
+      throw richError({ title: "Build Hook Failed to Run", cause: err, origin: compiled.pathname, doShowStack: true });
+    }
+    try {
+      await Promise.all(compiled.preBuildHooks.map((cb) => cb()));
+    } catch (err) {
+      if (isRichError(err)) throw err;
+      throw richError({ title: "Build Hook Failed to Run", cause: err, origin: compiled.pathname, doShowStack: true });
+    }
+    return;
+  }
+  try {
+    await Promise.all(compiled.postBuildHooks.map((cb) => cb()));
+  } catch (err) {
+    if (isRichError(err)) throw err;
+    throw richError({ title: "Build Hook Failed to Run", cause: err, origin: compiled.pathname, doShowStack: true });
+  }
+  await Promise.all(
+    compiled.publishFiles.map(async ({ input, target }) => {
+      const dest = join(DIST_DIR, target);
+      await mkdir(dirname(dest), { recursive: true });
+      try {
+        await copyFile(input, dest);
+      } catch (err) {
+        const error = richError({
+          title: "Failed to Publish File",
+          cause: `A post-build hook attempted to call publishFile() on a file that did not exist during the build.
+File: ${input}`,
+          origin: compiled.pathname,
+          doShowStack: false
+        });
+        printError(error);
+        throw err;
+      }
+    })
+  );
+}
+function minifyHtml(html) {
+  return html.replace(/\s+/g, " ").replace(/> </g, "><").trim();
+}
+async function minifyCode(code) {
+  const result = await esbuild.transform(code, { minify: true, loader: "js" });
+  return result.code;
+}
+function getSlugParamName(pattern) {
+  const match = SINGLE_PARAM_RE.exec(pattern);
+  if (!match) return "slug";
+  return match[1].replace(PARAM_STRIP_RE, "");
+}
+async function fileHasExports(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return EXPORT_RE.test(content);
+  } catch (err) {
+    const error = richError({
+      title: "Internal Error",
+      cause: "Elegance attempted to check if a file had exports, but ran into an unexpected error.",
+      hint: "If the error persists, please report it.",
+      origin: filePath,
+      doShowStack: true
+    });
+    console.error(error);
+    printError(error);
+    throw err;
+  }
+}
+async function computeFileHash(filePath) {
+  const content = await readFile(filePath);
+  return createHash("sha1").update(content).digest("hex");
+}
+async function loadIncrementalState() {
+  const path = join(CACHE_DIR, "incremental.json");
+  try {
+    return JSON.parse(await readFile(path, "utf-8"));
+  } catch {
+    return { fileHashes: {}, clientCodeHashes: {} };
+  }
+}
+async function saveIncrementalState(state) {
+  const path = join(CACHE_DIR, "incremental.json");
+  await mkdir(CACHE_DIR, { recursive: true });
+  await writeFile(path, JSON.stringify(state));
+}
+async function copyPublicDir(publicDir) {
+  if (!existsSync(publicDir)) return;
+  await cp(publicDir, DIST_DIR, { recursive: true });
+}
+async function copyPublicDirIncremental(publicDir) {
+  if (!existsSync(publicDir)) return;
+  const dirEnsured = /* @__PURE__ */ new Map();
+  const ensureDir = (dir) => {
+    let p = dirEnsured.get(dir);
+    if (!p) dirEnsured.set(dir, p = mkdir(dir, { recursive: true }));
+    return p;
+  };
+  async function walk(srcDir, destDir) {
+    let entries;
+    try {
+      entries = await readdir(srcDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    await Promise.all(entries.map(async (e) => {
+      const src = join(srcDir, e.name);
+      const dest = join(destDir, e.name);
+      if (e.isDirectory()) {
+        await walk(src, dest);
+        return;
+      }
+      try {
+        const [ss, ds] = await Promise.all([fsStat(src), fsStat(dest)]);
+        if (ds.mtimeMs >= ss.mtimeMs && ds.size === ss.size) return;
+      } catch {
+      }
+      await ensureDir(destDir);
+      await copyFile(src, dest);
+    }));
+  }
+  await walk(publicDir, DIST_DIR);
+}
+async function buildClientRuntime(minify) {
+  await esbuild.build({
+    entryPoints: [join(import.meta.dirname, "..", "client.js")],
+    bundle: true,
+    outfile: join(DIST_DIR, "client.js"),
+    minify,
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    treeShaking: true,
+    loader: { ".ts": "ts", ".tsx": "ts" },
+    plugins: [eleganceTsxPlugin]
+  });
+}
+const ROUTE_ESBUILD_BASE = {
+  bundle: true,
+  write: false,
+  format: "esm",
+  target: `node${process.versions.node}`,
+  legalComments: "inline",
+  packages: "external",
+  external: ["../../../v11/user-utils"],
+  loader: { ".ts": "ts", ".tsx": "ts" },
+  plugins: [eleganceTsxPlugin],
+  minify: false,
+  treeShaking: false
+};
+async function walkPagesDir(dir, onDir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_")).map((e) => join(dir, e.name));
+  await Promise.all(subdirs.map((sub) => walkPagesDir(sub, onDir)));
+  await onDir(dir);
+}
+async function discoverApiRoutes(pagesDir) {
+  const entries = [];
+  await walkPagesDir(pagesDir, async (dir) => {
+    const candidate = join(dir, "route.ts");
+    if (existsSync(candidate)) {
+      const pathname = dir === pagesDir ? "/" : dir.slice(pagesDir.length);
+      entries.push({ pathname, file: candidate });
+    }
+  });
+  return entries;
+}
+async function discoverMiddlewares(pagesDir) {
+  const entries = [];
+  await walkPagesDir(pagesDir, async (dir) => {
+    const candidate = join(dir, "middleware.ts");
+    if (existsSync(candidate)) entries.push({ file: candidate });
+  });
+  return entries;
+}
+async function compileServerFiles(files, stamp, label) {
+  if (files.size === 0) return /* @__PURE__ */ new Map();
+  const tmpDir = join(process.cwd(), ".temp", `${label}_${stamp}`);
+  await mkdir(tmpDir, { recursive: true });
+  try {
+    await esbuild.build({
+      ...ROUTE_ESBUILD_BASE,
+      entryPoints: Object.fromEntries(files),
+      write: true,
+      outdir: tmpDir,
+      splitting: false,
+      minify: false
+    });
+    const result = /* @__PURE__ */ new Map();
+    await Promise.all([...files.keys()].map(async (key) => {
+      const raw = await readFile(join(tmpDir, `${key}.js`), "utf-8");
+      const { serverCode, preClientCode } = transformBundle(raw, files.get(key));
+      result.set(key, { serverCode, preClientCode });
+    }));
+    return result;
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function findAndCacheStatusCodePages() {
+  const candidates = [];
+  async function walk(dir) {
+    let dirents;
+    try {
+      dirents = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    await Promise.all(
+      dirents.filter((ent) => ent.isDirectory()).map((ent) => walk(join(dir, ent.name)))
+    );
+    for (const ent of dirents) {
+      if (!ent.isDirectory() && /^\d{3}\.tsx?$/.test(ent.name))
+        candidates.push({ full: join(dir, ent.name), dir });
+    }
+  }
+  await walk(PAGES_DIR);
+  if (candidates.length === 0) return [];
+  await mkdir(CACHE_DIR, { recursive: true });
+  const settled = await Promise.allSettled(
+    candidates.map(async ({ full, dir }) => {
+      const layouts = await collectLayouts(dir, PAGES_DIR);
+      const layoutKeys = layouts.map(layoutFileCacheKey);
+      const cacheKey = statusCodeCacheKey(full);
+      const stamp = Date.now();
+      const allFiles = /* @__PURE__ */ new Map();
+      allFiles.set(cacheKey, full);
+      for (let i = 0; i < layouts.length; i++) {
+        allFiles.set(layoutKeys[i], layouts[i]);
+      }
+      const compiled = await compileServerFiles(allFiles, stamp, `sc_${cacheKey}`);
+      await Promise.all(
+        [...compiled.entries()].map(
+          ([k, { serverCode }]) => writeFile(serverMjsPath(k), serverCode)
+        )
+      );
+      await Promise.all(
+        layoutKeys.map(async (lk, i) => {
+          if (existsSync(clientMjsPath(lk))) return;
+          const { preClientCode } = compiled.get(lk) ?? {};
+          if (!preClientCode) return;
+          let bundle = generateLayoutBundle(preClientCode, layouts[i]);
+          if (!IS_DEV) bundle = await minifyCode(bundle);
+          await Promise.all([
+            writeFile(clientMjsPath(lk), bundle),
+            writeFile(chunkClientPath(lk), bundle)
+          ]);
+        })
+      );
+      const { preClientCode: pagePreClient } = compiled.get(cacheKey);
+      await writeFile(
+        preClientMjsPath(cacheKey),
+        IS_DEV ? pagePreClient : await minifyCode(pagePreClient)
+      );
+      return {
+        pageFile: full,
+        layouts,
+        layoutCacheKeys: layoutKeys,
+        cacheKey
+      };
+    })
+  );
+  const entries = [];
+  for (let i = 0; i < settled.length; i++) {
+    const result = settled[i];
+    if (result.status === "fulfilled") {
+      entries.push(result.value);
+    } else {
+      const { full } = candidates[i];
+      const error = richError({
+        title: "Compilation Error",
+        cause: "A status code page threw an error whilst it was being compiled. (full error below).",
+        origin: full,
+        doShowStack: false
+      });
+      console.error(error);
+      printError(error);
+    }
+  }
+  return entries;
+}
+async function transpileAllRoutes(routes, minify, skipServerKeys = /* @__PURE__ */ new Set()) {
+  if (routes.length === 0) return /* @__PURE__ */ new Map();
+  const stamp = Date.now();
+  const clientTmpOut = join(process.cwd(), ".temp", `client_out_${stamp}`);
+  const serverTmpOut = join(process.cwd(), ".temp", `server_out_${stamp}`);
+  const chunksDir = join(DIST_DIR, "chunks");
+  const keyToRoute = /* @__PURE__ */ new Map();
+  const keyToLayoutPath = /* @__PURE__ */ new Map();
+  const clientEntryPoints = {};
+  const allServerFiles = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = pageCacheKey(route.pathname);
+    clientEntryPoints[key] = route.pageFile;
+    keyToRoute.set(key, route);
+    if (!skipServerKeys.has(key))
+      allServerFiles.set(key, route.pageFile);
+    for (const layoutPath of route.layouts) {
+      const lk = layoutFileCacheKey(layoutPath);
+      if (!keyToLayoutPath.has(lk)) {
+        clientEntryPoints[lk] = layoutPath;
+        keyToLayoutPath.set(lk, layoutPath);
+      }
+      if (!skipServerKeys.has(lk))
+        allServerFiles.set(lk, layoutPath);
+    }
+  }
+  const hasServerWork = allServerFiles.size > 0;
+  await Promise.all([
+    mkdir(clientTmpOut, { recursive: true }),
+    mkdir(chunksDir, { recursive: true }),
+    mkdir(CACHE_DIR, { recursive: true }),
+    hasServerWork ? mkdir(serverTmpOut, { recursive: true }) : Promise.resolve()
+  ]);
+  const serverBuildProm = hasServerWork ? esbuild.build({
+    ...ROUTE_ESBUILD_BASE,
+    entryPoints: Object.fromEntries(allServerFiles),
+    write: true,
+    outdir: serverTmpOut,
+    splitting: false,
+    minify: false
+  }).then(() => void 0) : Promise.resolve();
+  await esbuild.build({
+    ...ROUTE_ESBUILD_BASE,
+    entryPoints: clientEntryPoints,
+    write: true,
+    outdir: clientTmpOut,
+    splitting: true,
+    minify: false
+  });
+  const clientOutputs = await readdir(clientTmpOut);
+  const entryStems = /* @__PURE__ */ new Set([...keyToRoute.keys(), ...keyToLayoutPath.keys()]);
+  const chunkFiles = clientOutputs.filter(
+    (f) => f.endsWith(".js") && !entryStems.has(basename(f, ".js"))
+  );
+  const chunkUrlMap = /* @__PURE__ */ new Map();
+  await Promise.all(chunkFiles.map(async (chunkFile) => {
+    const raw = await readFile(join(clientTmpOut, chunkFile), "utf-8");
+    const processed = transformChunk(raw, chunkFile);
+    chunkUrlMap.set(`./${chunkFile}`, `/chunks/${chunkFile}`);
+    await writeFile(join(chunksDir, chunkFile), processed);
+  }));
+  let replaceChunkUrls;
+  if (chunkUrlMap.size > 0) {
+    const escapedKeys = [...chunkUrlMap.keys()].map(
+      (k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    );
+    const chunkRe = new RegExp(escapedKeys.join("|"), "g");
+    replaceChunkUrls = (code) => code.replace(chunkRe, (m) => chunkUrlMap.get(m));
+  } else {
+    replaceChunkUrls = (code) => code;
+  }
+  await serverBuildProm;
+  if (hasServerWork) {
+    await Promise.all([...allServerFiles.entries()].map(async ([key, filePath]) => {
+      const raw = await readFile(join(serverTmpOut, `${key}.js`), "utf-8");
+      const { serverCode } = transformBundle(raw, filePath);
+      await writeFile(serverMjsPath(key), serverCode);
+    }));
+  }
+  await Promise.all([...keyToLayoutPath.entries()].map(async ([lk, layoutPath]) => {
+    const raw = await readFile(join(clientTmpOut, `${lk}.js`), "utf-8");
+    const { preClientCode: rawPre } = transformBundle(raw, layoutPath);
+    const preClientCode = replaceChunkUrls(rawPre);
+    let layoutBundle = generateLayoutBundle(preClientCode, layoutPath);
+    if (minify) layoutBundle = await minifyCode(layoutBundle);
+    await Promise.all([
+      writeFile(clientMjsPath(lk), layoutBundle),
+      writeFile(chunkClientPath(lk), layoutBundle)
+    ]);
+  }));
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all([...keyToRoute.entries()].map(async ([key, route]) => {
+    const [clientRaw, rawServerCode] = await Promise.all([
+      readFile(join(clientTmpOut, `${key}.js`), "utf-8"),
+      readFile(serverMjsPath(key), "utf-8")
+    ]);
+    const { preClientCode: rawPreClientCode } = transformBundle(clientRaw, route.pageFile);
+    let preClientCode = replaceChunkUrls(rawPreClientCode);
+    const sharedChunkPaths = chunkFiles.filter((f) => clientRaw.includes(`./${f}`)).map((f) => `/chunks/${f}`);
+    await writeFile(preClientMjsPath(key), preClientCode);
+    results.set(route.pathname, {
+      pathname: route.pathname,
+      pageFile: route.pageFile,
+      layouts: route.layouts,
+      serverCode: rawServerCode,
+      preClientCode,
+      sharedChunkPaths
+    });
+  }));
+  await Promise.all([
+    rm(clientTmpOut, { recursive: true, force: true }).catch(() => {
+    }),
+    rm(serverTmpOut, { recursive: true, force: true }).catch(() => {
+    })
+  ]);
+  return results;
+}
+async function loadLayoutFromCache(pathname, cacheKey) {
+  try {
+    const { module, buildCallbacks, postBuildHooks, preBuildHooks, publishFiles, atomSeeds } = await importModule(`copycat://${resolve(pathname)}?real=${serverMjsPath(cacheKey)}`);
+    if (typeof module.default !== "function") {
+      throw richError({
+        title: "Invalid Layout",
+        cause: "Could not get default export. For a layout to be valid, it must export a function that resolved into a VirtualNode",
+        hint: "Did you forget the *export* keyword?",
+        doShowStack: false
+      });
+    }
+    if (module.meta && typeof module.meta !== "function") {
+      throw richError({
+        title: "Invalid Layout",
+        cause: 'Meta export is not of type "function"',
+        hint: "The 'meta' export of a layout should be a function that resolves into an array of VirtualNodes.",
+        doShowStack: false
+      });
+    }
+    return {
+      default: module.default,
+      metadata: module.metadata ? module.metadata : () => [],
+      pathname,
+      buildCallbacks,
+      postBuildHooks,
+      preBuildHooks,
+      publishFiles,
+      atomSeeds
+    };
+  } catch (err) {
+    if (isRichError(err)) throw err;
+    throw richError({
+      title: "Failed to Import Layout",
+      cause: err,
+      origin: pathname,
+      doShowStack: true
+    });
+  }
+}
+async function loadRouteFromCache(entry) {
+  const { module, preBuildHooks, buildCallbacks, postBuildHooks, publishFiles, atomSeeds } = await importCompiledModule(entry.pageFile, serverMjsPath(entry.cacheKey));
+  if (typeof module.default !== "function") {
+    throw richError({
+      title: "Invalid Page",
+      cause: "Could not find default export.",
+      hint: "Did you forget the *default* keyword?",
+      doShowStack: false
+    });
+  }
+  const layoutModules = await Promise.all(
+    entry.layouts.map(
+      (layoutPath, i) => loadLayoutFromCache(layoutPath, entry.layoutCacheKeys[i])
+    )
+  );
+  for (const layout of layoutModules) {
+    preBuildHooks.push(...layout.preBuildHooks);
+    postBuildHooks.push(...layout.postBuildHooks);
+    buildCallbacks.push(...layout.buildCallbacks);
+    publishFiles.push(...layout.publishFiles);
+    atomSeeds.push(...layout.atomSeeds);
+  }
+  return {
+    default: composeRenderFn(module, layoutModules),
+    metadata: async (params) => gatherMetaFromModules(module, layoutModules, params ?? {}),
+    getEnumeratedRoutes: module.getEnumeratedRoutes,
+    pathname: entry.pathname,
+    preBuildHooks,
+    buildCallbacks,
+    postBuildHooks,
+    publishFiles,
+    atomSeeds
+  };
+}
+export {
+  ROUTE_ESBUILD_BASE,
+  buildClientRuntime,
+  chunkClientPath,
+  clientMjsPath,
+  computeFileHash,
+  copyPublicDir,
+  copyPublicDirIncremental,
+  discoverApiRoutes,
+  discoverMiddlewares,
+  fileHasExports,
+  findAndCacheStatusCodePages,
+  getSlugParamName,
+  importContext,
+  importModule,
+  layoutFileCacheKey,
+  loadIncrementalState,
+  loadLayoutFromCache,
+  loadRouteFromCache,
+  minifyCode,
+  minifyHtml,
+  pageCacheKey,
+  preClientMjsPath,
+  runBuildHooks,
+  saveIncrementalState,
+  serverMjsPath,
+  statusCodeCacheKey,
+  transpileAllRoutes
+};

package/dist/build/dev.d.ts

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

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

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