npm - exta2 - Versions diffs - 0.0.1-beta.29 - Mend

exta2 0.0.1-beta.29

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,885 @@
+// packages/exta/src/vite/index.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import { join as join12, relative as relative6 } from "node:path";
+// packages/exta/src/core/index.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join as join2, relative } from "node:path";
+// packages/exta/src/core/index.html.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var cache;
+function getIndexHtml() {
+  if (cache)
+    return cache;
+  let path2 = join(process.cwd(), "index.html");
+  return existsSync(path2) ? (cache = readFileSync(path2, "utf-8"), cache) : `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    %head%
+  </head>
+  <body>
+    %body%
+  </body>
+</html>`;
+}
+// packages/exta/src/core/index.ts
+function initialize(dist = join2(process.cwd(), ".exta"), pages) {
+  mkdirSync(dist, { recursive: !0 }), writeFileSync(
+    join2(dist, "index.html"),
+    getIndexHtml().replace("%body%", '<div id="_app"></div>').replace("%head%", '<script src="/.exta/client.js" type="module"></script>')
+  ), writeFileSync(join2(dist, "client.js"), 'import "$exta-client";'), writeFileSync(
+    join2(dist, "manifest.js"),
+    `export default {${Object.keys(pages).map(
+      (page) => `  "${page}": () => import("./${relative(dist, pages[page].client).replace(/\\/g, "/")}"),
+`
+    ).join(`
+`)}}`
+  );
+}
+// packages/exta/src/core/routing.ts
+import { join as join8, parse as parse2, relative as relative4 } from "node:path";
+// packages/exta/src/compiler/index.ts
+import { readFile } from "node:fs/promises";
+import { join as join6, relative as relative3 } from "node:path";
+import { build } from "esbuild";
+// packages/exta/src/compiler/constants.ts
+var PAGE_STATIC_DATA_FUNCTION = "getStaticProps", PAGE_STATIC_PARAMS_FUNCTION = "getStaticParams";
+// packages/exta/src/compiler/utils.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join as join4, relative as relative2 } from "node:path";
+import oxc from "oxc-parser";
+// packages/exta/src/logger.ts
+import "colors";
+process.env.EXTA_DEBUG && (global.COMPILER_LOG_LEVEL = "debug");
+function getLogLevel(logLevel) {
+  if (!logLevel)
+    return 2 /* INFO */;
+  switch (logLevel.toUpperCase()) {
+    case "ERROR":
+      return 0 /* ERROR */;
+    case "WARN":
+      return 1 /* WARN */;
+    case "INFO":
+      return 2 /* INFO */;
+    case "DEBUG":
+      return 3 /* DEBUG */;
+    default:
+      return 2 /* INFO */;
+  }
+}
+var currentLogLevel = getLogLevel(
+  global.COMPILER_LOG_LEVEL
+);
+function error(message) {
+  currentLogLevel >= 0 /* ERROR */ && console.error(`[ERROR]: ${message}`.red);
+}
+function warn(message) {
+  currentLogLevel >= 1 /* WARN */ && console.warn(`[WARN]: ${message}`.yellow);
+}
+function debug(message) {
+  currentLogLevel >= 3 /* DEBUG */ && console.debug(`[DEBUG]: ${message}`.cyan);
+}
+// packages/exta/src/utils/path.ts
+import { join as join3, normalize, parse, resolve } from "node:path";
+function changeExtension(filename, to) {
+  let { dir, name } = parse(filename);
+  return join3(dir, name + to).replace(/\\/g, "/");
+}
+// packages/exta/src/compiler/utils.ts
+async function getExports(code, filename = "@virtual.ts") {
+  let result = await oxc.parseAsync(filename, code, {
+    lang: "tsx",
+    sourceType: "module"
+  });
+  if (result.errors && process.argv.includes("--show-parser-error"))
+    for (let parserError of result.errors)
+      error(
+        `[exta/compiler:oxc-parser] ${parserError.message}
+ - ${JSON.stringify(parserError).red}`
+      );
+  let exports = [];
+  for (let _export_entries of result.module.staticExports)
+    for (let [, _export] of Object.entries(_export_entries.entries))
+      _export.exportName.name ? exports.push(_export.exportName.name) : _export.exportName ? exports.push("__default") : warn(`Cannot resolve export name - ${code.slice(_export.start, _export.end)}`);
+  return exports;
+}
+async function generateOriginalServerFile(filename, hasFunction, cwd = process.cwd()) {
+  isAbsolute(filename) || (filename = join4(cwd, filename));
+  let basePageDirectory = join4(cwd, "pages"), relativeFilename = relative2(basePageDirectory, filename), outdirectory = join4(cwd, ".exta"), funcList = [];
+  hasFunction.params && funcList.push(PAGE_STATIC_PARAMS_FUNCTION), hasFunction.data && funcList.push(PAGE_STATIC_DATA_FUNCTION);
+  let outServerFile = join4(
+    outdirectory,
+    "intermediate",
+    "server",
+    changeExtension(relativeFilename, ".ts")
+  ), outClientFile = join4(
+    outdirectory,
+    "intermediate",
+    "client",
+    changeExtension(relativeFilename, ".tsx")
+  );
+  return await mkdir(dirname(outServerFile), { recursive: !0 }), await mkdir(dirname(outClientFile), { recursive: !0 }), await writeFile(
+    outServerFile,
+    `export { ${funcList.join(", ")} } from "${relative2(dirname(outServerFile), filename).replace(/\\/g, "/")}";`
+  ), await writeFile(
+    outClientFile,
+    hasFunction.default ? `export { default as _page } from "${relative2(dirname(outClientFile), filename).replace(/\\/g, "/")}";export const __exta_page=true;` : "export const _page = () => null;export const __exta_page=true;"
+  ), {
+    outServerFile,
+    outClientFile
+  };
+}
+// packages/exta/src/compiler/plugin.ts
+import { builtinModules } from "node:module";
+import { join as join5 } from "node:path";
+var BUILTIN_MODULES = builtinModules.concat(builtinModules.map((m) => `node:${m}`));
+function sideEffectPlugin(options) {
+  return {
+    name: "exta/esbuild-sideeffect-plugin",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, async (args) => {
+        if (BUILTIN_MODULES.includes(args.path) || options?.ignoreSideEffects && (options?.preserveSideEffects || []).includes(args.path))
+          return {
+            sideEffects: !1,
+            path: args.path,
+            external: !0
+          };
+      });
+    }
+  };
+}
+function vmPlugin() {
+  return {
+    name: "my-virtual-module-plugin",
+    setup(build2) {
+      build2.onResolve({ filter: /^\$exta-router$/ }, (args) => ({ path: args.path, namespace: "virtual" })), build2.onLoad({ filter: /^\$exta-router$/, namespace: "virtual" }, () => ({
+        contents: "module.exports = {};",
+        loader: "js"
+      }));
+    }
+  };
+}
+function onlyReact(extensions = [".css", ".scss", ".sass", ".less"], isServerSide = !1, options) {
+  return options.assetsExtensions && extensions.push(...options.assetsExtensions), {
+    name: "exta/esbuild-react-plugin",
+    setup(build2) {
+      build2.onResolve(
+        {
+          filter: new RegExp(
+            `\\.(${extensions.map((ext) => ext.replace(".", "")).join("|")})$`
+          )
+        },
+        (args) => isServerSide ? {
+          path: args.path,
+          namespace: "exta:ignore"
+        } : args.path.startsWith(".") ? {
+          path: join5(args.resolveDir, args.path),
+          external: !0
+        } : {
+          path: args.path,
+          external: !0
+        }
+      ), build2.onLoad({ filter: /.*/, namespace: "exta:ignore" }, () => ({
+        contents: "",
+        loader: "js"
+      }));
+    }
+  };
+}
+// packages/exta/src/compiler/index.ts
+async function compilePage(filename, options = {}, ignoreAssets) {
+  let cwd = process.cwd(), source = await readFile(filename, "utf-8"), exports = await getExports(source, filename), hasStaticPropsFunction = exports.includes(PAGE_STATIC_DATA_FUNCTION), hasStaticParamsFunction = exports.includes(PAGE_STATIC_PARAMS_FUNCTION), intermeddiateFiles = await generateOriginalServerFile(filename, {
+    data: hasStaticPropsFunction,
+    params: hasStaticParamsFunction,
+    default: exports.includes("__default")
+  }), basePageDirectory = join6(cwd, "pages"), relativeFilename = relative3(basePageDirectory, filename), outdirectory = options.outdir ?? join6(cwd, ".exta"), outfiles = {
+    client: join6(outdirectory, "client", changeExtension(relativeFilename, ".js")),
+    server: join6(outdirectory, "server", changeExtension(relativeFilename, ".mjs"))
+  };
+  return await build({
+    entryPoints: [intermeddiateFiles.outClientFile],
+    outfile: outfiles.client,
+    packages: "external",
+    sourcemap: "inline",
+    format: "esm",
+    platform: "browser",
+    treeShaking: !0,
+    bundle: !0,
+    jsx: "automatic",
+    ignoreAnnotations: !0,
+    plugins: [sideEffectPlugin(options), onlyReact(void 0, ignoreAssets, options)]
+  }), await build({
+    entryPoints: [intermeddiateFiles.outServerFile],
+    outfile: outfiles.server,
+    packages: "external",
+    format: "esm",
+    platform: "node",
+    treeShaking: !0,
+    bundle: !0,
+    ignoreAnnotations: !0,
+    plugins: [sideEffectPlugin(options), onlyReact(void 0, !0, options), vmPlugin()]
+  }), { outfiles };
+}
+// packages/exta/src/utils/fs.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function scanDirectory(directoryPath, fileList = []) {
+  return fs.readdirSync(directoryPath).forEach((item) => {
+    let fullPath = path.join(directoryPath, item);
+    fs.statSync(fullPath).isDirectory() ? scanDirectory(fullPath, fileList) : fileList.push(fullPath);
+  }), fileList;
+}
+// packages/exta/src/core/routing.ts
+function prettyURL(path2) {
+  return path2 === "." && (path2 = ""), path2.startsWith("/") || (path2 = `/${path2}`), path2.endsWith("/") && (path2 = path2.slice(0, -1)), path2;
+}
+async function compilePages(compileOptions, ignoreAssets = !1) {
+  let baseDir = join8(process.cwd(), "pages"), pages = scanDirectory(baseDir), output = {};
+  for await (let page of pages) {
+    let pageName = parse2(page).name, name = prettyURL(relative4(baseDir, page).replace(/\\/g, "/"));
+    pageName === "_layout" ? name = "[layout]" : pageName === "_error" && (name = "[error]"), output[name] = (await compilePage(page, compileOptions, ignoreAssets)).outfiles;
+  }
+  return output;
+}
+// packages/exta/src/utils/params.ts
+function matchUrlToRoute(url, routeResult) {
+  let { regex, params } = routeResult, match = regex.exec(url);
+  if (!match)
+    return null;
+  let result = {};
+  for (let i = 0; i < params.length; i++) {
+    let paramName = params[i], capturedValue = match[i + 1];
+    if (paramName.startsWith("..."))
+      throw new Error(
+        "[... file names are not supported due to static data generation issues."
+      );
+    result[paramName] = capturedValue;
+  }
+  return result;
+}
+// packages/exta/src/utils/url.ts
+function encodeJSON(input) {
+  if (typeof input == "string")
+    try {
+      return encodeURIComponent(input);
+    } catch {
+      return input;
+    }
+  else {
+    if (Array.isArray(input))
+      return input.map((item) => encodeJSON(item));
+    if (input && typeof input == "object") {
+      let result = {};
+      for (let [key, value] of Object.entries(input))
+        result[key] = encodeJSON(value);
+      return result;
+    }
+  }
+  return input;
+}
+// packages/exta/src/utils/urlPath.ts
+function convertToRegex(path2) {
+  let params = [], processedPath = path2.replace(/\.[^/.]+$/, "");
+  processedPath.endsWith("/index") && (processedPath = processedPath.slice(0, -6));
+  let regexString = `^/${processedPath.split("/").filter((part) => part !== "").map((part) => {
+    if (part.startsWith("[...") && part.endsWith("]")) {
+      let paramName = part.slice(4, -1);
+      return params.push(paramName), "(.*)";
+    }
+    if (part.startsWith("[") && part.endsWith("]")) {
+      let paramName = part.slice(1, -1);
+      return params.push(paramName), "([^/]+)";
+    }
+    return part;
+  }).join("/")}/?$`;
+  return { regex: new RegExp(regexString), params };
+}
+// packages/exta/src/utils/find.ts
+var findPage = (url, _manifest_object) => {
+  let sortedManifest = [..._manifest_object].sort(
+    (a, b) => a.params.length - b.params.length
+  );
+  for (let route of sortedManifest)
+    if (route.regexp.test(decodeURIComponent(url)) && !route.path.startsWith("[") && !route.path.endsWith("]"))
+      return route;
+  return null;
+};
+// packages/exta/src/vite/build.ts
+import { readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join11, parse as parse3, relative as relative5 } from "node:path";
+import { createServer } from "vite";
+// packages/exta/src/vite/builder/ssr.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join9, dirname as dirname2 } from "node:path";
+import { performance } from "node:perf_hooks";
+import { pathToFileURL } from "node:url";
+import { renderToString } from "react-dom/server";
+import React3 from "react";
+// packages/exta/src/client/components/_error.ts
+import React from "react";
+var containerStyle = {
+  display: "flex",
+  justifyContent: "center",
+  alignItems: "center",
+  width: "100%",
+  height: "100vh",
+  textAlign: "center",
+  flexDirection: "column"
+}, defaultProps = {
+  status: 404,
+  message: "Page not found"
+}, DefaultError = ({ status, message } = defaultProps) => (status = status ?? defaultProps.status, message = message ?? defaultProps.message, React.createElement("div", { style: containerStyle }, [
+  React.createElement("h1", { key: "status" }, String(status)),
+  React.createElement("p", { key: "message" }, message)
+]));
+// packages/exta/src/client/components/_layout..ts
+import React2 from "react";
+var DefaultLayout = ({ children }) => React2.createElement(React2.Fragment, null, children);
+// packages/exta/src/vite/builder/shared.ts
+function replaceParamsInRoute(route, params) {
+  let result = route, paramRegex = /\[([^\]]+)\]/g;
+  return result = result.replace(paramRegex, (match, paramName) => params[paramName] || match), result = result.replace(/\.[^/.]+$/, ""), result = result.replace(/\/index$/, "") || "/", result;
+}
+// packages/exta/src/utils/spinner.ts
+import readline from "node:readline";
+import "colors";
+var stream = process.stdout, defaultSpinner = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map(
+  (item) => item.cyan
+), Spinner = class {
+  tick;
+  spinner;
+  message;
+  processor;
+  constructor(opts = {}) {
+    this.tick = opts.tick || 50, this.spinner = opts.spinner || defaultSpinner, this.message = opts.message || "";
+  }
+  clearLine() {
+    return readline.clearLine(stream, 0), readline.cursorTo(stream, 0), this;
+  }
+  start() {
+    let index = 0;
+    return this.processor = setInterval(() => {
+      this.clearLine(), stream.write(`${this.spinner[index % this.spinner.length]} ${this.message}`), index += 1;
+    }, this.tick), this;
+  }
+  stop(message = "") {
+    return this.processor && (clearInterval(this.processor), this.clearLine(), stream.write(message)), this;
+  }
+  edit(message) {
+    return this.message = message, this;
+  }
+};
+// packages/exta/src/utils/array.ts
+function getUniqueArray(arr) {
+  return [...new Set(arr)];
+}
+// packages/exta/src/vite/builder/ssr.ts
+var fileRegexp = /^[^/\\]+[\\/]/;
+function parsePathname(url) {
+  let { pathname } = new URL(url, "http://localhost/");
+  return pathname.endsWith("/") && (pathname = pathname.slice(0, -1)), pathname;
+}
+function collectCssFiles(manifest, entry) {
+  let result = [], visited = /* @__PURE__ */ new Set();
+  function recurse(key) {
+    if (visited.has(key))
+      return;
+    visited.add(key);
+    let chunk = manifest[key];
+    if (chunk && (chunk.css && result.push(...chunk.css), chunk.imports))
+      for (let imported of chunk.imports)
+        recurse(imported);
+  }
+  return recurse(entry), result;
+}
+function collectJavaScriptFiles(manifest, entry) {
+  let result = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
+  function recurse(key) {
+    if (visited.has(key))
+      return;
+    visited.add(key);
+    let chunk = manifest[key];
+    if (chunk) {
+      if (chunk.imports)
+        for (let importedKey of chunk.imports)
+          recurse(importedKey);
+      result.add(chunk.file);
+    }
+  }
+  return recurse(entry), [...result];
+}
+var serverRendering = (children, { Layout, props, template, cssFiles, staticManifest, path: path2, scripts }) => {
+  global.__EXTA_SSR_DATA__ = {
+    pathname: path2,
+    params: props.params || {},
+    preload: [],
+    head: []
+  };
+  let component = React3.createElement(children, {
+    ...props,
+    key: path2
+  }), string = renderToString(React3.createElement(Layout, null, component)), insert = [];
+  for (let cssChunk of cssFiles)
+    insert.push(`<link rel="stylesheet" href="/${cssChunk}" />`);
+  for (let preloadFile of global.__EXTA_SSR_DATA__.preload)
+    insert.push(`<link rel="prefetch" href="${preloadFile}" />`);
+  for (let script of scripts)
+    insert.push(`<link rel="modulepreload" href="/${script}"></link>`);
+  insert.push(
+    `<script id="__STATIC_MANIFEST__" type="application/json">${JSON.stringify(staticManifest)}</script>`
+  );
+  for (let head of global.__EXTA_SSR_DATA__.head)
+    switch (head.type) {
+      case "html":
+        insert.push(head.data);
+        break;
+      case "preload-data-link": {
+        let page = parsePathname(head.data).replace(/\//g, "_") + ".json";
+        staticManifest[page] ? insert.push(
+          `<link rel="preload" href="/data/${staticManifest[page]}.json" as="fetch"></link>`
+        ) : insert.push(`<!--${head.data}-->`);
+        break;
+      }
+      default:
+        break;
+    }
+  return template = template.replace(/<head[^>]*>([\s\S]*?)<\/head>/, (match, inner) => `<head${match.match(/<head([^>]*)>/)?.[1] || ""}>${insert.join("")}
+${inner}</head>`), template.replace('<div id="_app"></div>', `<div id="_app">${string}</div>`);
+};
+async function createStaticHTML(pages, outdir, vite, template, manifest, staticManifest) {
+  let startTime = performance.now(), spinner = new Spinner();
+  spinner.message = "Generating html files...", spinner.start();
+  let getLayout = async () => pages["[layout]"] ? (await vite.ssrLoadModule(pages["[layout]"].client))._page : DefaultLayout, getError = async () => pages["[error]"] ? (await vite.ssrLoadModule(pages["[error]"].client))._page : DefaultError, getClientComponent = async (path2) => (await vite.ssrLoadModule(path2))._page, ErrorComponent = await getError(), Layout = await getLayout(), layoutCompiledFile = `.exta/${pages["[layout]"].client.replace(fileRegexp, "")}`.replace(/\\/g, "/"), layoutCss = pages["[layout]"] ? collectCssFiles(manifest, layoutCompiledFile) : [], layoutScript = manifest[layoutCompiledFile]?.file;
+  writeFileSync2(join9(outdir, "data", "_empty.json"), "{}");
+  for (let pageName in pages) {
+    let page = pages[pageName], data = await import(pathToFileURL(page.server).href), compiledFile = `.exta/${page.client.replace(fileRegexp, "")}`.replace(
+      /\\/g,
+      "/"
+    ), cssFiles = collectCssFiles(manifest, compiledFile), script = collectJavaScriptFiles(manifest, compiledFile);
+    if (data[PAGE_STATIC_PARAMS_FUNCTION]) {
+      let paramsModule = await data[PAGE_STATIC_PARAMS_FUNCTION]();
+      if (!Array.isArray(paramsModule))
+        throw new Error(
+          `An error occurred while generating HTML file. - Static params function must return array. (in ${pageName})`
+        );
+      for (let params of paramsModule) {
+        let route = replaceParamsInRoute(pageName, params), outStaticPage = changeExtension(join9(outdir, route), ".html"), staticDataPath = changeExtension(
+          join9(
+            outdir,
+            "data",
+            staticManifest[route.replace(/\//g, "_") + ".json"] || "_empty"
+          ),
+          ".json"
+        );
+        spinner.message = `Generating html files... - ${route}`;
+        let Client = await getClientComponent(page.client), ssrProps2 = {
+          Layout,
+          props: {
+            props: JSON.parse(readFileSync2(staticDataPath).toString()),
+            params: matchUrlToRoute(route, convertToRegex(pageName))
+          },
+          template,
+          cssFiles: getUniqueArray([...cssFiles, ...layoutCss]),
+          staticManifest,
+          path: route,
+          scripts: getUniqueArray([layoutScript, ...script])
+        };
+        mkdirSync2(dirname2(outStaticPage), { recursive: !0 }), writeFileSync2(outStaticPage, serverRendering(Client, ssrProps2));
+      }
+    } else {
+      if (pageName.startsWith("[") && pageName.endsWith("]"))
+        continue;
+      let route = replaceParamsInRoute(pageName, {}), outStaticPage = join9(outdir, route) + "/index.html", staticDataPath = changeExtension(
+        join9(
+          outdir,
+          "data",
+          staticManifest[route.replace(/\//g, "_") + ".json"] || "_empty"
+        ),
+        ".json"
+      );
+      spinner.message = `Generating html files... - ${route}`;
+      let Client = await getClientComponent(page.client), ssrProps2 = {
+        Layout,
+        props: {
+          props: JSON.parse(readFileSync2(staticDataPath).toString()),
+          params: {}
+        },
+        template,
+        cssFiles: getUniqueArray([...cssFiles, ...layoutCss]),
+        staticManifest,
+        path: route,
+        scripts: getUniqueArray([layoutScript, ...script])
+      };
+      mkdirSync2(dirname2(outStaticPage), { recursive: !0 }), writeFileSync2(outStaticPage, serverRendering(Client, ssrProps2));
+    }
+  }
+  let ssrProps = {
+    Layout,
+    props: {},
+    template,
+    cssFiles: [...layoutCss],
+    staticManifest,
+    path: ".exta/ssr:unknown",
+    scripts: []
+  };
+  writeFileSync2(join9(outdir, "404.html"), serverRendering(ErrorComponent, ssrProps)), spinner.stop(
+    `html files generated. (${((performance.now() - startTime) / 1e3).toFixed(2)}s)`
+  );
+}
+// packages/exta/src/vite/builder/props.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join10, dirname as dirname3 } from "node:path";
+import { performance as performance2 } from "node:perf_hooks";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+// packages/exta/src/utils/random.ts
+function randomString16() {
+  let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  return Array.from(
+    { length: 16 },
+    () => chars[Math.floor(Math.random() * chars.length)]
+  ).join("");
+}
+// packages/exta/src/vite/builder/props.ts
+async function createStaticProps(pages, outdir) {
+  let startTime = performance2.now(), staticManifest = {}, spinner = new Spinner();
+  spinner.message = "Generating static data", spinner.start();
+  for (let pageName in pages) {
+    spinner.message = `Generating static data - collecting pages (${pageName})`;
+    let page = pages[pageName], data = await import(pathToFileURL2(page.server).href);
+    if (data[PAGE_STATIC_PARAMS_FUNCTION]) {
+      let paramsModule = await data[PAGE_STATIC_PARAMS_FUNCTION]();
+      if (!Array.isArray(paramsModule))
+        throw new Error(
+          `An error occurred while building the page. - Static params function must return array. (in ${pageName})`
+        );
+      for (let params of paramsModule) {
+        let originalURL = replaceParamsInRoute(pageName, params), outfile = changeExtension(originalURL, ".json").replace(/\//g, "_"), random = randomString16(), outStaticPage = join10(outdir, "data", `${random}.json`);
+        if (spinner.message = `Generating static data - ${originalURL}`, mkdirSync3(dirname3(outStaticPage), { recursive: !0 }), staticManifest[outfile] = random, data[PAGE_STATIC_DATA_FUNCTION]) {
+          let staticProps = await data[PAGE_STATIC_DATA_FUNCTION]({ params });
+          writeFileSync3(outStaticPage, JSON.stringify(staticProps));
+        } else
+          staticManifest[outfile] = null;
+      }
+    } else {
+      let originalURL = replaceParamsInRoute(pageName, {}), outfile = changeExtension(originalURL, ".json").replace(/\//g, "_"), random = randomString16(), outStaticPage = join10(outdir, "data", `${random}.json`);
+      if (spinner.message = `Generating static data - ${originalURL}`, staticManifest[outfile] = random, mkdirSync3(dirname3(outStaticPage), { recursive: !0 }), data[PAGE_STATIC_DATA_FUNCTION]) {
+        let staticProps = await data[PAGE_STATIC_DATA_FUNCTION]();
+        writeFileSync3(outStaticPage, JSON.stringify(staticProps));
+      } else
+        staticManifest[outfile] = null;
+    }
+  }
+  return spinner.stop(
+    `Static props generated. (${((performance2.now() - startTime) / 1e3).toFixed(2)}s)`
+  ), staticManifest;
+}
+// packages/exta/src/vite/build.ts
+function extaBuild(compilerOptions = {}) {
+  let viteConfig, pageMap = {}, pages, vite, staticManifest;
+  function generatePageMap(bundle) {
+    if (Object.keys(pageMap).length !== 0)
+      return pageMap;
+    for (let key in bundle) {
+      if (bundle[key].type === "asset" || !bundle[key].isDynamicEntry && !bundle[key].exports.includes("__exta_page"))
+        continue;
+      let setKey = relative5(
+        join11(".exta", "client").replace(/\\/g, "/"),
+        bundle[key].facadeModuleId
+      ), pageName = parse3(setKey).name;
+      pageName === "_layout" && (setKey = "[layout]"), pageName === "_error" && (setKey = "[error]"), pageMap[setKey] = key;
+    }
+    return pageMap;
+  }
+  return {
+    name: "exta:build",
+    apply: "build",
+    async config(config) {
+      initialize(config.build.outDir || "dist", {}), pages = await compilePages({
+        ...compilerOptions,
+        outdir: config.build.outDir || "dist"
+      }), config.build ??= {}, config.build.rollupOptions ??= {}, config.build.rollupOptions.input ??= {}, config.build.manifest = !0, config.build.rollupOptions.input["index.html"] = "index.html", vite = await createServer({
+        server: { middlewareMode: !0, hmr: !1 },
+        ...config
+      });
+    },
+    async configResolved(config) {
+      viteConfig = config;
+    },
+    async buildStart() {
+    },
+    async generateBundle(options, bundle) {
+      pages = await compilePages({ ...compilerOptions, outdir: viteConfig.build.outDir }), initialize(viteConfig.build.outDir, pages), console.log(), console.log(), staticManifest = await createStaticProps(pages, viteConfig.build.outDir), console.log(), writeFileSync4(
+        join11(viteConfig.build.outDir, "map.json"),
+        JSON.stringify(generatePageMap(bundle))
+      );
+    },
+    async writeBundle() {
+      let { outDir } = viteConfig.build, indexHTML = readFileSync3(join11(outDir, "index.html")).toString();
+      pages = await compilePages(
+        { ...compilerOptions, outdir: viteConfig.build.outDir },
+        !0
+      );
+      let manifestPath = join11(outDir, ".vite/manifest.json"), manifest = JSON.parse(readFileSync3(manifestPath).toString());
+      if (console.log(), await createStaticHTML(
+        pages,
+        viteConfig.build.outDir,
+        vite,
+        indexHTML,
+        manifest,
+        staticManifest
+      ), await vite.close(), rmSync(join11(outDir, "map.json"), { recursive: !0, force: !0 }), rmSync(join11(outDir, "manifest.js"), { recursive: !0, force: !0 }), rmSync(join11(outDir, "client.js"), { recursive: !0, force: !0 }), rmSync(join11(outDir, "server"), { recursive: !0, force: !0 }), rmSync(join11(outDir, "client"), { recursive: !0, force: !0 }), process.env.BUILD_SUMMARY) {
+        let buildSummary = [];
+        buildSummary.push("Build Summary");
+        for (let staticFile in staticManifest) {
+          let filename = changeExtension(staticFile.replace(/_/g, "/"), "");
+          if (!staticManifest[staticFile]) {
+            buildSummary.push(`${filename}`);
+            continue;
+          }
+          buildSummary.push(
+            `${filename.padEnd(60)}${`${staticManifest[staticFile] || "null"}.json`}`
+          );
+        }
+        writeFileSync4(join11(__dirname, "../summary.txt"), buildSummary.join(`
+`)), console.log(
+          `
+Check the ${join11(__dirname, "../summary.txt")} file to view the build summary.`
+        );
+      }
+      console.log();
+    },
+    transformIndexHtml(html) {
+      return {
+        html,
+        tags: [
+          {
+            tag: "script",
+            injectTo: "head",
+            attrs: { id: "__PAGE_MAP__", type: "text/javascript" },
+            children: `window.__EXTA_PAGEMAP__ = ${JSON.stringify(pageMap)}`
+          }
+        ]
+      };
+    }
+  };
+}
+// packages/exta/src/vite/index.ts
+var manifestModuleId = "$exta-manifest", resolvedManifestModuleId = "\0" + manifestModuleId, clientModuleId = "$exta-client", resolvedClientModuleId = "\0" + clientModuleId, routerModuleId = "$exta-router", resolvedRouterModuleId = "\0" + routerModuleId;
+function exta(options) {
+  let isDev = process.env.NODE_ENV === "development", dist = options?.compileOptions.outdir ?? join12(process.cwd(), ".exta"), _manifest_object = [], _server_props = /* @__PURE__ */ new Map(), _pages, _manifest = null, logger, env;
+  existsSync2(dist) && rmSync2(dist, { recursive: !0, force: !0 }), mkdirSync4(dist);
+  function generateManifest(rawManif, force = !1) {
+    if (_manifest && !force)
+      return _manifest;
+    let manifest = [];
+    for (let path2 in rawManif) {
+      let converted = convertToRegex(path2), relativePath = relative6(
+        join12(process.cwd(), ".exta"),
+        rawManif[path2].client
+      ).replace(/\\/g, "/"), code = `{path: ${JSON.stringify(path2)}, regexp: ${converted.regex.toString()}, params: ${JSON.stringify(converted.params)}, buildPath: ${JSON.stringify(relativePath)}, originalPath: ${JSON.stringify(path2)}}`;
+      manifest.push(code), _manifest_object.push({
+        path: path2,
+        originalPath: path2,
+        regexp: converted.regex,
+        params: converted.params,
+        buildPath: relativePath,
+        buildServerPath: rawManif[path2].server
+      });
+    }
+    return _manifest = `export const PAGES_MANIFEST = [
+  ${manifest.join(`,
+  `)}
+]`, _manifest;
+  }
+  let findPage2 = (url) => findPage(url, _manifest_object);
+  return [
+    {
+      name: "exta",
+      config(config, _env) {
+        env = _env, config.server ??= {}, config.server.watch ??= {}, config.server.watch.ignored = [
+          "/.exta/**",
+          ...Array.isArray(config.server.watch.ignored) ? config.server.watch.ignored : config.server.watch.ignored ? [config.server.watch.ignored] : []
+        ], config.resolve ??= {}, config.resolve.alias ??= {}, config.resolve.alias["$exta-pages"] = join12(
+          env.command === "serve" ? dist : config.build.outDir || "dist",
+          "manifest.js"
+        );
+      },
+      configResolved(config) {
+        logger = config.logger;
+      },
+      async handleHotUpdate({ server, file }) {
+        if (file.includes(".exta"))
+          return [];
+        let dist2 = options?.compileOptions?.outdir || join12(process.cwd(), ".exta");
+        _pages = await compilePages(options?.compileOptions), _server_props.clear();
+        let beforeManifest = `${_manifest}`, afterManifest = generateManifest(_pages, !0);
+        if (beforeManifest !== afterManifest)
+          return server.ws.send({ type: "full-reload" }), [];
+        writeFileSync5(
+          join12(dist2, "manifest.js"),
+          `export default {${Object.keys(_pages).map(
+            (page) => `  "${page}": () => import("./${relative6(dist2, _pages[page].client).replace(/\\/g, "/")}"),
+`
+          ).join(`
+`)}}`
+        );
+        let invalidateAndUpdate = (modid, isVirtual = !0) => {
+          if (!modid)
+            return;
+          let mod = server.moduleGraph.getModuleById(modid);
+          mod && (server.moduleGraph.invalidateModule(mod), server.ws.send({
+            type: "update",
+            updates: [
+              {
+                type: "js-update",
+                path: isVirtual ? "/@id/" + mod.id : mod.url,
+                acceptedPath: isVirtual ? "/@id/" + mod.id : mod.url,
+                timestamp: Date.now()
+              }
+            ]
+          }));
+        };
+        invalidateAndUpdate(resolvedManifestModuleId), invalidateAndUpdate(
+          (await server.moduleGraph.getModuleByUrl("$exta-pages"))?.id ?? null
+        );
+        let normalizedFile = file.replace(/\\/g, "/"), pagesDirectory = join12(process.cwd(), "pages"), pagesFiles = scanDirectory(pagesDirectory).map(
+          (p) => p.replace(/\\/g, "/")
+        ), compiledFile = changeExtension(
+          join12(
+            process.cwd(),
+            ".exta",
+            "client",
+            relative6(pagesDirectory, normalizedFile)
+          ),
+          ".js"
+        ).replace(/\\/g, "/");
+        if (pagesFiles.includes(normalizedFile)) {
+          let modules = Array.from(server.moduleGraph.urlToModuleMap.values()).filter(
+            (mod) => mod.file && mod.file.replace(/\\/g, "/") === compiledFile
+          );
+          for (let mod of modules)
+            invalidateAndUpdate(mod.id, !1);
+        }
+        logger.info(
+          `${"[exta]".gray} ${relative6(process.cwd(), file).cyan.bold} updated`,
+          {}
+        );
+      },
+      async buildStart() {
+        _pages = await compilePages(options?.compileOptions);
+      },
+      async configureServer(server) {
+        _pages = await compilePages(options?.compileOptions), initialize(options?.compileOptions?.outdir, _pages), isDev && server.middlewares.use("/.exta/__page_data", async (req, res) => {
+          let page = new URL(req.url, "http://localhost").searchParams.get("page") || "/";
+          if (debug(`Requested "${page}"`), page === "$IS_CONNECTED$")
+            return res.end(JSON.stringify({ connected: !0 }));
+          let clientURL = new URL(page, "http://localhost"), pageManifest = findPage2(page), prettyPathname = prettyURL(decodeURIComponent(clientURL.pathname));
+          if (res.setHeader("Content-Type", "application/json"), !pageManifest?.buildServerPath)
+            return res.end(JSON.stringify({ props: {}, status: 404 }));
+          if (_server_props.has(prettyPathname))
+            return res.end(
+              JSON.stringify({
+                props: _server_props.get(prettyPathname),
+                status: 200,
+                cached: !0
+              })
+            );
+          try {
+            let serverModule = await import(`${pathToFileURL3(pageManifest.buildServerPath).href}?v=${Date.now()}`), params = matchUrlToRoute(clientURL.pathname, {
+              regex: pageManifest.regexp,
+              params: pageManifest.params
+            }), data = {};
+            if (serverModule[PAGE_STATIC_PARAMS_FUNCTION]) {
+              let availableParams = await serverModule[PAGE_STATIC_PARAMS_FUNCTION](), success = !1;
+              for (let allowedParams of availableParams)
+                isDeepStrictEqual(encodeJSON(allowedParams), params) && (success = !0);
+              if (!success)
+                return res.end(
+                  JSON.stringify({
+                    props: {},
+                    status: 404
+                  })
+                );
+            }
+            serverModule[PAGE_STATIC_DATA_FUNCTION] && (data = await serverModule[PAGE_STATIC_DATA_FUNCTION]({
+              params
+            })), _server_props.set(prettyPathname, data), res.end(JSON.stringify({ props: data, status: 200 })), debug(`Request ended "${page}"`);
+          } catch (e) {
+            console.error(e), res.end(
+              JSON.stringify({
+                message: "Internal Server Error",
+                detail: e.message,
+                status: 500
+              })
+            );
+          }
+        });
+      },
+      transformIndexHtml(html) {
+        return html.replace("%body%", '<div id="_app"></div>');
+      },
+      resolveId(id) {
+        if (id === manifestModuleId)
+          return resolvedManifestModuleId;
+        if (id === clientModuleId)
+          return resolvedClientModuleId;
+        if (id === routerModuleId)
+          return resolvedRouterModuleId;
+      },
+      load(id) {
+        if (id === resolvedClientModuleId)
+          return {
+            code: readFileSync4(join12(__dirname, "client.mjs"), "utf-8")
+          };
+        if (id === resolvedManifestModuleId)
+          return {
+            code: generateManifest(_pages)
+          };
+        if (id === resolvedRouterModuleId)
+          return {
+            code: readFileSync4(join12(__dirname, "router.mjs"), "utf-8")
+          };
+      }
+    },
+    extaBuild(options?.compileOptions || {})
+  ];
+}
+export {
+  compilePage,
+  exta
+};