elegance-js 2.1.37 → 3.0.1

package/dist/config.js

@@ -0,0 +1,80 @@
+import { existsSync } from "fs";
+import { join } from "path";
+const defaultConfig = {
+  security: {
+    contentSecurityPolicy: {
+      defaultSrc: [],
+      scriptSrc: ["'self'", "blob:"],
+      scriptSrcElem: ["'self'", "blob:"],
+      imgSrc: ["'self'", "data:", "https:"],
+      fontSrc: [],
+      connectSrc: [],
+      frameSrc: ["'none'"],
+      objectSrc: ["'none'"],
+      baseUri: ["'self'"],
+      formAction: ["'self'"],
+      upgradeInsecureRequests: false
+    },
+    strictTransportSecurity: {
+      maxAge: 31536e3,
+      includeSubDomains: true
+    },
+    xFrameOptions: "DENY",
+    xContentTypeOptions: true,
+    referrerPolicy: "strict-origin-when-cross-origin",
+    permissionsPolicy: {
+      camera: ["'none'"],
+      microphone: ["'none'"],
+      geolocation: ["'none'"]
+    },
+    crossOriginOpenerPolicy: "same-origin",
+    crossOriginResourcePolicy: "same-origin",
+    xDnsPrefetchControl: "off"
+  },
+  output: {
+    outputDirectory: ".elegance",
+    pagesDirectory: "pages"
+  },
+  server: {
+    port: 3e3,
+    serveAPI: true,
+    allowDynamicPages: true,
+    allowStatusCodePages: true
+  }
+};
+let userConfig;
+async function loadConfig() {
+  const CONFIG_PATH = join(process.cwd(), "elegance.config.ts");
+  if (!existsSync(CONFIG_PATH)) {
+    userConfig = defaultConfig;
+    return;
+  }
+  const module = await import(CONFIG_PATH);
+  if (module.config) {
+    userConfig = module.config;
+    return;
+  }
+  userConfig = defaultConfig;
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key in overrides) {
+    const override = overrides[key];
+    const defaultValue = defaults[key];
+    if (override && typeof override === "object" && !Array.isArray(override) && defaultValue && typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
+      result[key] = deepMerge(defaultValue, override);
+    } else if (override !== void 0) {
+      result[key] = override;
+    }
+  }
+  return result;
+}
+async function getConfig() {
+  if (!userConfig) {
+    await loadConfig();
+  }
+  return deepMerge(defaultConfig, userConfig);
+}
+export {
+  getConfig
+};

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+export type OutputOptions = {
+    outputDirectory?: string;
+    pagesDirectory?: string;
+};
+export declare let OUT_DIR: string;
+export declare let DIST_DIR: string;
+export declare let CACHE_DIR: string;
+export declare let PAGES_DIR: string;
+export declare function loadPaths(): Promise<void>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,aAAa,GAAG;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,eAAO,IAAI,OAAO,EAAE,MAAM,CAAC;AAC3B,eAAO,IAAI,QAAQ,EAAE,MAAM,CAAC;AAC5B,eAAO,IAAI,SAAS,EAAE,MAAM,CAAC;AAC7B,eAAO,IAAI,SAAS,EAAE,MAAM,CAAC;AAE7B,wBAAsB,SAAS,kBAQ9B"}

package/dist/constants.js

@@ -0,0 +1,20 @@
+import { join } from "node:path";
+import { getConfig } from "./config.js";
+let OUT_DIR;
+let DIST_DIR;
+let CACHE_DIR;
+let PAGES_DIR;
+async function loadPaths() {
+  const config = await getConfig();
+  OUT_DIR = config.output.outputDirectory;
+  DIST_DIR = join(OUT_DIR, "dist");
+  CACHE_DIR = join(OUT_DIR, "cache");
+  PAGES_DIR = config.output.pagesDirectory;
+}
+export {
+  CACHE_DIR,
+  DIST_DIR,
+  OUT_DIR,
+  PAGES_DIR,
+  loadPaths
+};

package/dist/elements.d.ts

@@ -0,0 +1,2 @@
+export declare function makeEl<T extends AnyTag>(tagName: T): ElementGenerator<T>;
+//# sourceMappingURL=elements.d.ts.map

package/dist/elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elements.d.ts","sourceRoot":"","sources":["../src/elements.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAoBxE"}

package/dist/elements.js

@@ -0,0 +1,14 @@
+function makeEl(tagName) {
+  return function(options, ...children) {
+    const isOptions = typeof options === "object" && options !== null && !Array.isArray(options) && !("__type" in options);
+    return {
+      __type: "element",
+      tag: tagName,
+      options: isOptions ? options : {},
+      children: isOptions ? children : [options, ...children]
+    };
+  };
+}
+export {
+  makeEl
+};

package/dist/error.d.ts

@@ -0,0 +1,20 @@
+export interface RichErrorOptions {
+    title: string;
+    message?: string;
+    description?: string;
+    hint?: string;
+    origin?: string;
+    meta?: Record<string, unknown>;
+    cause?: unknown;
+    doShowStack: boolean;
+}
+export type RichError = Error & RichErrorOptions;
+export declare function richError(opts: RichErrorOptions): RichError;
+export declare function isRichError(value: unknown): value is RichError;
+export interface FormatOptions {
+    colors?: boolean;
+    maxCauseDepth?: number;
+}
+export declare function formatError(err: unknown, opts?: FormatOptions): string;
+export declare function printError(err: unknown, opts?: FormatOptions): void;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAS,MAAM,CAAA;IACpB,OAAO,CAAC,EAAM,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAS,MAAM,CAAA;IACpB,MAAM,CAAC,EAAO,MAAM,CAAA;IACpB,IAAI,CAAC,EAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrC,KAAK,CAAC,EAAQ,OAAO,CAAA;IACrB,WAAW,EAAG,OAAO,CAAA;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,gBAAgB,CAAA;AAEhD,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAwB3D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D;AAgBD,MAAM,WAAW,aAAa;IAC1B,MAAM,CAAC,EAAS,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAQD,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,GAAE,aAAkB,GAAG,MAAM,CAa1E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,CAEnE"}

package/dist/error.js

@@ -0,0 +1,123 @@
+import { relative } from "node:path";
+function richError(opts) {
+  const message = opts.message ?? opts.title;
+  const err = new Error(message);
+  err.title = opts.title;
+  err.description = opts.description;
+  err.hint = opts.hint;
+  err.origin = relative(process.cwd(), opts.origin ?? "");
+  err.meta = opts.meta;
+  err.doShowStack = opts.doShowStack;
+  if (opts.cause !== void 0) err.cause = opts.cause;
+  if (opts.message !== void 0) err.message = opts.message;
+  if (typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(err, richError);
+  } else if (err.stack) {
+    err.stack = err.stack.split("\n").filter((l, i) => i === 0 || !l.includes("richError")).join("\n");
+  }
+  return err;
+}
+function isRichError(value) {
+  return value instanceof Error && "title" in value;
+}
+const ansi = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m"
+};
+const BOX_W = 56;
+const I1 = "  ";
+const I2 = "    ";
+const I3 = "      ";
+function formatError(err, opts = {}) {
+  const { colors = true, maxCauseDepth = 4 } = opts;
+  const paint = colors ? (text, ...keys) => keys.map((k) => ansi[k]).join("") + text + ansi.reset : (text) => text;
+  const out = [""];
+  out.push(...banner(paint));
+  out.push("");
+  renderNode(err, 0, out, paint, maxCauseDepth);
+  out.push("");
+  return out.join("\n");
+}
+function printError(err, opts) {
+  console.error(formatError(err, opts));
+}
+function banner(paint) {
+  const W = BOX_W;
+  const top = paint(`\u256D${"\u2500".repeat(W)}\u256E`, "red");
+  const bot = paint(`\u2570${"\u2500".repeat(W)}\u256F`, "red");
+  const rawLabel = "  \u2717  ERROR";
+  const pad = " ".repeat(W - rawLabel.length);
+  const mid = paint("\u2502", "red") + "  " + paint("\u2717", "red", "bold") + "  " + paint("ERROR", "red", "bold") + pad + paint("\u2502", "red");
+  return [top, mid, bot];
+}
+function renderNode(error, depth, out, paint, maxDepth) {
+  if (depth > maxDepth) {
+    out.push(`${I2}${paint("\u21B3  \u2026 further causes omitted", "dim")}`);
+    return;
+  }
+  if (error === null || error === void 0 || typeof error !== "object") {
+    const label = typeof error === "string" ? error : error === null || error === void 0 ? String(error) : `(${typeof error}) ${String(error)}`;
+    const indent = depth === 0 ? I1 : I2;
+    out.push(`${indent}${paint("\u26A0", "yellow", "bold")}  ${paint(label, "dim")}`);
+    return;
+  }
+  const err = error;
+  const rich = isRichError(err);
+  const titleText = rich ? err.title : `${err.constructor?.name ?? "Error"}: ${err.message}`;
+  const titleIndent = depth === 0 ? I1 : I2;
+  out.push(
+    `${titleIndent}${paint("\u26A0", "yellow", "bold")}  ${paint(titleText, "bold")}`
+  );
+  const fi = depth === 0 ? I2 : I3;
+  const si = depth === 0 ? I3 : I3 + "  ";
+  if (rich && err.description) {
+    out.push("");
+    out.push(`${fi}${err.description}`);
+  }
+  if (rich && err.origin) {
+    out.push(`${fi}${paint(err.origin, "gray")}`);
+  }
+  const hasFields = rich && (err.hint || err.origin);
+  if (hasFields) out.push("");
+  const cause = err.cause;
+  if (cause !== void 0) {
+    out.push("");
+    if (typeof cause === "string" && cause.startsWith("\\")) {
+      out.push(paint(cause.slice(1)));
+    } else {
+      out.push(`${fi}${paint(cause)}`);
+    }
+  }
+  if (rich && err.hint) {
+    out.push("");
+    if (err.hint.startsWith("\\")) {
+      out.push(paint(err.hint.slice(1), "yellow"));
+    } else {
+      out.push(`${fi}${paint(err.hint, "yellow")}`);
+    }
+  }
+  const showStack = (err.stack || err.cause instanceof Error) && (rich ? err.doShowStack : depth > 0);
+  if (showStack) {
+    const stack = err.cause instanceof Error ? cause.stack : err.stack;
+    const frames = stack.split("\n").slice(1).filter(Boolean);
+    if (frames.length > 0) {
+      out.push("");
+      out.push(`${fi}${paint("Stack", "gray")}`);
+      for (const frame of frames) {
+        out.push(`${si}${paint("\u254E", "dim")}  ${paint(frame.trim(), "dim")}`);
+      }
+    }
+  }
+}
+export {
+  formatError,
+  isRichError,
+  printError,
+  richError
+};

package/dist/globals.d.ts

@@ -0,0 +1,6 @@
+/**
+ * this is quite literallyll the worst file that i have ever seen in my entire life
+ * i hate every single thing about this file, and the fact that it even exists at all.
+ */
+export declare function hookGlobals(): void;
+//# sourceMappingURL=globals.d.ts.map

package/dist/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,WAAW,SA4H1B"}

package/dist/globals.js

@@ -0,0 +1,106 @@
+import { makeEl } from "./elements.js";
+import { renderContextStorage } from "./build/render.js";
+import { importContext } from "./build/common.js";
+function hookGlobals() {
+  globalThis.__tags = new Proxy({}, {
+    get(_, tag) {
+      return makeEl(tag);
+    }
+  });
+  globalThis.serverAction = (params) => {
+    console.log("Register serverAction:", params.id);
+    if (globalThis.__serverActions === void 0) globalThis.__serverActions = [];
+    globalThis.__serverActions.push(params);
+  };
+  globalThis.rawHTML = (content) => ({ content, __rawHTML: true });
+  globalThis.onPageLoad = () => {
+  };
+  globalThis.atom = function(id, initial) {
+    const context = importContext.getStore();
+    if (!context) {
+      throw new Error("atom() called outside of import context. This is an invalid invocation.");
+    }
+    const seeds = context.atomSeeds;
+    seeds.push({ id, initial });
+    const atom = {
+      id,
+      get value() {
+        const ctx = renderContextStorage.getStore();
+        if (!ctx) return initial;
+        if (!ctx.atomValues.has(id)) {
+          ctx.atomValues.set(id, initial);
+          ctx.atomRegistry.push({ id });
+        }
+        return ctx.atomValues.get(id);
+      },
+      set value(v) {
+        const ctx = renderContextStorage.getStore();
+        if (!ctx) return;
+        if (!ctx.atomValues.has(id)) {
+          ctx.atomValues.set(id, initial);
+          ctx.atomRegistry.push({ id });
+        }
+        ctx.atomValues.set(id, v);
+      }
+    };
+    return atom;
+  };
+  globalThis.view = (fn) => fn;
+  globalThis.component = function component(cfg) {
+    const { __id: cid, view, init, atoms } = cfg;
+    if (!cid) throw "Invalid component call, was the preprocessor ran on this file?";
+    if (!view) {
+      throw new Error(`Component "${cid}": must provide 'view', otherwise the component cannot be rendered.`);
+    }
+    const generator = (props, children) => {
+      const atomsObj = {};
+      if (atoms) {
+        for (const key of Object.keys(atoms)) {
+          let value = atoms[key];
+          atomsObj[key] = {
+            get value() {
+              return value;
+            },
+            set value(v) {
+              value = v;
+            },
+            id: `${cid}:${key}`
+          };
+        }
+      }
+      const self = {
+        props: props ?? {},
+        root: void 0
+      };
+      const descriptor = {
+        __type: "live",
+        __componentId: cid,
+        __definition: {
+          state: () => ({}),
+          callbacks: {},
+          render: () => view({ self, atoms: atomsObj, children }),
+          serverInit: async () => {
+            if (init) await init(self, atomsObj);
+          }
+        },
+        props: props ?? {}
+      };
+      const originalInit = descriptor.__definition.serverInit;
+      descriptor.__definition.serverInit = async () => {
+        await originalInit();
+      };
+      return descriptor;
+    };
+    generator.__config = { ...cfg };
+    return generator;
+  };
+  globalThis.track = () => {
+    console.warn("WARNING: The track() function is a no-op on the server, make sure to only call it within browser-code.");
+  };
+  globalThis.untrack = () => {
+    console.warn("WARNING: The untrack() function is a no-op on the server, make sure to only call it within browser-code.");
+  };
+}
+export {
+  hookGlobals
+};

package/dist/logger.d.ts

@@ -0,0 +1,32 @@
+export declare const c: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly italic: "\u001B[3m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly cyan: "\u001B[36m";
+    readonly magenta: "\u001B[35m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+};
+export type ColorKey = keyof typeof c;
+export interface LogOptions {
+    /** A secondary, dimmed line printed beneath the message. */
+    detail?: string;
+    /** Prepend an HH:MM:SS timestamp to each line. */
+    timestamp?: boolean;
+}
+export declare const logger: {
+    info(msg: string, opts?: LogOptions): void;
+    success(msg: string, opts?: LogOptions): void;
+    warn(msg: string, opts?: LogOptions): void;
+    error(msg: string, opts?: LogOptions): void;
+    debug(msg: string, opts?: LogOptions): void;
+    gap(): void;
+    divider(label?: string): void;
+    field(key: string, value: string, color?: ColorKey): void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,CAAC;;;;;;;;;;;;;CAaJ,CAAA;AAEV,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,CAAA;AAkBrC,MAAM,WAAW,UAAU;IACvB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,SAAS,CAAC,EAAE,OAAO,CAAA;CACtB;AAkBD,eAAO,MAAM,MAAM;cACF,MAAM,SAAS,UAAU,GAAG,IAAI;iBAChC,MAAM,SAAS,UAAU,GAAG,IAAI;cAChC,MAAM,SAAS,UAAU,GAAG,IAAI;eAChC,MAAM,SAAS,UAAU,GAAG,IAAI;eAChC,MAAM,SAAS,UAAU,GAAG,IAAI;WAEtC,IAAI;oBAIK,MAAM,GAAG,IAAI;eAUlB,MAAM,SAAS,MAAM,UAAS,QAAQ,GAAY,IAAI;CAIpE,CAAA"}

package/dist/logger.js

@@ -0,0 +1,72 @@
+const c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+function paint(text, ...styles) {
+  return styles.map((k) => c[k]).join("") + text + c.reset;
+}
+const LEVELS = {
+  info: { icon: "!", badge: "info", color: "cyan" },
+  success: { icon: "\u2713", badge: "ok", color: "green" },
+  warn: { icon: "\u26A0", badge: "warn", color: "yellow" },
+  error: { icon: "\u2717", badge: "error", color: "red" },
+  debug: { icon: "\u25C6", badge: "debug", color: "magenta" }
+};
+const MSG_INDENT = "         ";
+function emit(level, msg, opts = {}) {
+  const { icon, badge, color } = LEVELS[level];
+  const fn = level === "error" ? console.error : console.log;
+  const ts = opts.timestamp ? paint((/* @__PURE__ */ new Date()).toTimeString().slice(0, 8), "gray") + "  " : "";
+  fn(`  ${ts}${paint(icon, color)}  ${paint(badge.padEnd(6), color, "bold")}${msg}`);
+  if (opts.detail) {
+    const tsGap = opts.timestamp ? "          " : "";
+    fn(`  ${tsGap}${MSG_INDENT}${paint(opts.detail, "dim")}`);
+  }
+}
+const logger = {
+  info(msg, opts) {
+    emit("info", msg, opts);
+  },
+  success(msg, opts) {
+    emit("success", msg, opts);
+  },
+  warn(msg, opts) {
+    emit("warn", msg, opts);
+  },
+  error(msg, opts) {
+    emit("error", msg, opts);
+  },
+  debug(msg, opts) {
+    emit("debug", msg, opts);
+  },
+  gap() {
+    console.log("");
+  },
+  divider(label) {
+    const W = 54;
+    if (label) {
+      const dashes = "\u2500".repeat(Math.max(2, W - label.length - 4));
+      console.log("  " + paint(`\u2500\u2500 ${label} ${dashes}`, "gray"));
+    } else {
+      console.log("  " + paint("\u2500".repeat(W), "gray"));
+    }
+  },
+  field(key, value, color = "cyan") {
+    const k = paint(key.padEnd(10), color);
+    console.log(`  ${MSG_INDENT}${k}  ${value}`);
+  }
+};
+export {
+  c,
+  logger
+};

package/dist/page-tools.d.ts

@@ -0,0 +1,19 @@
+import type esbuild from "esbuild";
+import type { CompiledLayout } from "./build/common";
+export interface RouteInfo {
+    pathname: string;
+    pageFile: string;
+    layouts: string[];
+}
+export interface PageRoute extends RouteInfo {
+    isDynamic: boolean;
+}
+export declare function pathnameFromFile(filePath: string): string;
+export declare function getPageRoutes(pagesDir: string): Promise<PageRoute[]>;
+export declare function collectLayouts(pageDir: string, rootDir: string): Promise<string[]>;
+export declare function fileHasDynamicExport(path: string): Promise<boolean>;
+export declare function sanitize(pathname: string): string;
+export declare const eleganceTsxPlugin: esbuild.Plugin;
+export declare function composeRenderFn(pageModule: any, layoutModules: CompiledLayout[]): (params: any, req: any, res: any) => any;
+export declare function gatherMetaFromModules(pageModule: any, layoutModules: any[], params: Record<string, any>): Promise<any[]>;
+//# sourceMappingURL=page-tools.d.ts.map

package/dist/page-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-tools.d.ts","sourceRoot":"","sources":["../src/page-tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,WAAW,SAAS;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAG,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,SAAU,SAAQ,SAAS;IACxC,SAAS,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKzD;AAkCD,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAmB1E;AAmBD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAcxF;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOzE;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,eAAO,MAAM,iBAAiB,EAAE,OAAO,CAAC,MAQvC,CAAC;AAEF,wBAAgB,eAAe,CAC3B,UAAU,EAAK,GAAG,EAClB,aAAa,EAAE,cAAc,EAAE,GAChC,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,GAAG,CAiB1C;AAED,wBAAsB,qBAAqB,CACvC,UAAU,EAAK,GAAG,EAClB,aAAa,EAAE,GAAG,EAAE,EACpB,MAAM,EAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACnC,OAAO,CAAC,GAAG,EAAE,CAAC,CAiBhB"}

package/dist/page-tools.js

@@ -0,0 +1,141 @@
+import { readdir, stat, readFile } from "node:fs/promises";
+import { join, dirname, relative } from "node:path";
+import { transformJSX } from "./processing/tsx.js";
+import { PAGES_DIR } from "./constants.js";
+function pathnameFromFile(filePath) {
+  const withoutExt = filePath.replace(/\.[^.]+$/, "");
+  const rel = relative(PAGES_DIR, withoutExt);
+  const normalized = rel.replace(/[\\/]?index$/, "") || "index";
+  return normalized === "index" ? "/" : `/${normalized}`;
+}
+async function getRoutes(pagesDir) {
+  const routes = [];
+  await walkDir(pagesDir, "/");
+  return routes;
+  async function walkDir(dir, urlPrefix) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const pageFile = await resolveTs(dir, "page");
+    if (pageFile) {
+      const layouts = await collectLayouts(dir, pagesDir);
+      routes.push({
+        pathname: urlPrefix === "/" ? "/" : urlPrefix.replace(/\/$/, ""),
+        pageFile,
+        layouts
+      });
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
+        await walkDir(join(dir, entry.name), urlPrefix + entry.name + "/");
+      }
+    }
+  }
+}
+function hasSlugSegment(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  return segments.some(
+    (seg) => /^\[.+\]$/.test(seg) || /^\.\.\.\[.+\]$/.test(seg) || /^:\[.+\]$/.test(seg)
+  );
+}
+async function getPageRoutes(pagesDir) {
+  const raw = await getRoutes(pagesDir);
+  const result = [];
+  for (const r of raw) {
+    const pageDynamic = await fileHasDynamicExport(r.pageFile) || hasSlugSegment(r.pathname);
+    const layoutInfos = await Promise.all(
+      r.layouts.map(async (lp) => ({
+        path: lp,
+        isDynamic: await fileHasDynamicExport(lp)
+      }))
+    );
+    result.push({
+      ...r,
+      isDynamic: pageDynamic || layoutInfos.some((l) => l.isDynamic)
+    });
+  }
+  return result;
+}
+async function fileExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function resolveTs(dir, base) {
+  for (const ext of [".ts", ".tsx"]) {
+    const p = join(dir, base + ext);
+    if (await fileExists(p)) return p;
+  }
+  return null;
+}
+async function collectLayouts(pageDir, rootDir) {
+  const layouts = [];
+  let current = pageDir;
+  while (current !== rootDir && current !== dirname(current)) {
+    const candidate = await resolveTs(current, "layout");
+    if (candidate) layouts.unshift(candidate);
+    current = dirname(current);
+  }
+  const rootCandidate = await resolveTs(rootDir, "layout");
+  if (rootCandidate) layouts.unshift(rootCandidate);
+  return layouts;
+}
+async function fileHasDynamicExport(path) {
+  try {
+    const source = await readFile(path, "utf-8");
+    return /\bexport\s+(?:const|let)\s+isDynamic\s*=\s*true\b/.test(source);
+  } catch {
+    return false;
+  }
+}
+function sanitize(pathname) {
+  return pathname.replace(/\//g, "_") || "index";
+}
+const eleganceTsxPlugin = {
+  name: "elegance-tsx",
+  setup(build) {
+    build.onLoad({ filter: /\.tsx$/ }, async (args) => {
+      const source = await readFile(args.path, "utf-8");
+      return { contents: transformJSX(source, args.path), loader: "ts" };
+    });
+  }
+};
+function composeRenderFn(pageModule, layoutModules) {
+  return (params, req, res) => {
+    let renderFn = (props) => pageModule.default({ ...props, ...params, req, res });
+    for (let i = layoutModules.length - 1; i >= 0; i--) {
+      const layout = layoutModules[i];
+      const inner = renderFn;
+      renderFn = (props) => layout.default({
+        ...props,
+        child: (childProps) => inner(childProps ?? {})
+      });
+    }
+    return renderFn({});
+  };
+}
+async function gatherMetaFromModules(pageModule, layoutModules, params) {
+  const metas = [];
+  const sources = [...layoutModules, pageModule];
+  for (const src of sources) {
+    try {
+      if (src && typeof src.metadata !== "undefined") {
+        const raw = typeof src.metadata === "function" ? await src.metadata(params) : src.metadata;
+        if (Array.isArray(raw)) metas.push(...raw);
+      }
+    } catch {
+    }
+  }
+  return metas;
+}
+export {
+  collectLayouts,
+  composeRenderFn,
+  eleganceTsxPlugin,
+  fileHasDynamicExport,
+  gatherMetaFromModules,
+  getPageRoutes,
+  pathnameFromFile,
+  sanitize
+};