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.js ADDED Viewed

@@ -0,0 +1,851 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dist_exports = {};
+__export(dist_exports, {
+  compilePage: () => compilePage,
+  exta: () => exta
+});
+module.exports = __toCommonJS(dist_exports);
+var import_node_fs = require("node:fs");
+var import_node_url = require("node:url");
+var import_node_util = require("node:util");
+var import_node_path = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
+var import_promises = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+var import_esbuild = require("esbuild");
+var import_promises2 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
+var import_oxc_parser = __toESM(require("oxc-parser"), 1);
+var import_colors = require("colors");
+var import_node_path7 = require("node:path");
+var import_node_module = require("node:module");
+var import_node_path8 = require("node:path");
+var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_node_fs4 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_vite = require("vite");
+var import_node_fs5 = require("node:fs");
+var import_node_path10 = require("node:path");
+var import_node_perf_hooks = require("node:perf_hooks");
+var import_node_url2 = require("node:url");
+var import_server = require("react-dom/server");
+var import_react = __toESM(require("react"), 1);
+var import_react2 = __toESM(require("react"), 1);
+var import_react3 = __toESM(require("react"), 1);
+var import_node_readline = __toESM(require("node:readline"), 1);
+var import_colors2 = require("colors");
+var import_node_fs6 = require("node:fs");
+var import_node_path11 = require("node:path");
+var import_node_perf_hooks2 = require("node:perf_hooks");
+var import_node_url3 = require("node:url");
+var cache;
+function getIndexHtml() {
+  if (cache)
+    return cache;
+  let path2 = (0, import_node_path3.join)(process.cwd(), "index.html");
+  return (0, import_node_fs3.existsSync)(path2) ? (cache = (0, import_node_fs3.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>`;
+}
+function initialize(dist = (0, import_node_path2.join)(process.cwd(), ".exta"), pages) {
+  (0, import_node_fs2.mkdirSync)(dist, { recursive: true }), (0, import_node_fs2.writeFileSync)(
+    (0, import_node_path2.join)(dist, "index.html"),
+    getIndexHtml().replace("%body%", '<div id="_app"></div>').replace("%head%", '<script src="/.exta/client.js" type="module"><\/script>')
+  ), (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(dist, "client.js"), 'import "$exta-client";'), (0, import_node_fs2.writeFileSync)(
+    (0, import_node_path2.join)(dist, "manifest.js"),
+    `export default {${Object.keys(pages).map(
+      (page) => `  "${page}": () => import("./${(0, import_node_path2.relative)(dist, pages[page].client).replace(/\\/g, "/")}"),
+`
+    ).join(`
+`)}}`
+  );
+}
+var PAGE_STATIC_DATA_FUNCTION = "getStaticProps", PAGE_STATIC_PARAMS_FUNCTION = "getStaticParams";
+process.env.EXTA_DEBUG && (global.COMPILER_LOG_LEVEL = "debug");
+function getLogLevel(logLevel) {
+  if (!logLevel)
+    return 2;
+  switch (logLevel.toUpperCase()) {
+    case "ERROR":
+      return 0;
+    case "WARN":
+      return 1;
+    case "INFO":
+      return 2;
+    case "DEBUG":
+      return 3;
+    default:
+      return 2;
+  }
+}
+var currentLogLevel = getLogLevel(
+  global.COMPILER_LOG_LEVEL
+);
+function error(message) {
+  currentLogLevel >= 0 && console.error(`[ERROR]: ${message}`.red);
+}
+function warn(message) {
+  currentLogLevel >= 1 && console.warn(`[WARN]: ${message}`.yellow);
+}
+function debug(message) {
+  currentLogLevel >= 3 && console.debug(`[DEBUG]: ${message}`.cyan);
+}
+function changeExtension(filename, to) {
+  let { dir, name } = (0, import_node_path7.parse)(filename);
+  return (0, import_node_path7.join)(dir, name + to).replace(/\\/g, "/");
+}
+async function getExports(code, filename = "@virtual.ts") {
+  let result = await import_oxc_parser.default.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()) {
+  (0, import_node_path6.isAbsolute)(filename) || (filename = (0, import_node_path6.join)(cwd, filename));
+  let basePageDirectory = (0, import_node_path6.join)(cwd, "pages"), relativeFilename = (0, import_node_path6.relative)(basePageDirectory, filename), outdirectory = (0, import_node_path6.join)(cwd, ".exta"), funcList = [];
+  hasFunction.params && funcList.push(PAGE_STATIC_PARAMS_FUNCTION), hasFunction.data && funcList.push(PAGE_STATIC_DATA_FUNCTION);
+  let outServerFile = (0, import_node_path6.join)(
+    outdirectory,
+    "intermediate",
+    "server",
+    changeExtension(relativeFilename, ".ts")
+  ), outClientFile = (0, import_node_path6.join)(
+    outdirectory,
+    "intermediate",
+    "client",
+    changeExtension(relativeFilename, ".tsx")
+  );
+  return await (0, import_promises2.mkdir)((0, import_node_path6.dirname)(outServerFile), { recursive: true }), await (0, import_promises2.mkdir)((0, import_node_path6.dirname)(outClientFile), { recursive: true }), await (0, import_promises2.writeFile)(
+    outServerFile,
+    `export { ${funcList.join(", ")} } from "${(0, import_node_path6.relative)((0, import_node_path6.dirname)(outServerFile), filename).replace(/\\/g, "/")}";`
+  ), await (0, import_promises2.writeFile)(
+    outClientFile,
+    hasFunction.default ? `export { default as _page } from "${(0, import_node_path6.relative)((0, import_node_path6.dirname)(outClientFile), filename).replace(/\\/g, "/")}";export const __exta_page=true;` : "export const _page = () => null;export const __exta_page=true;"
+  ), {
+    outServerFile,
+    outClientFile
+  };
+}
+var BUILTIN_MODULES = import_node_module.builtinModules.concat(import_node_module.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: false,
+            path: args.path,
+            external: true
+          };
+      });
+    }
+  };
+}
+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 = false, 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: (0, import_node_path8.join)(args.resolveDir, args.path),
+          external: true
+        } : {
+          path: args.path,
+          external: true
+        }
+      ), build2.onLoad({ filter: /.*/, namespace: "exta:ignore" }, () => ({
+        contents: "",
+        loader: "js"
+      }));
+    }
+  };
+}
+async function compilePage(filename, options = {}, ignoreAssets) {
+  let cwd = process.cwd(), source = await (0, import_promises.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 = (0, import_node_path5.join)(cwd, "pages"), relativeFilename = (0, import_node_path5.relative)(basePageDirectory, filename), outdirectory = options.outdir ?? (0, import_node_path5.join)(cwd, ".exta"), outfiles = {
+    client: (0, import_node_path5.join)(outdirectory, "client", changeExtension(relativeFilename, ".js")),
+    server: (0, import_node_path5.join)(outdirectory, "server", changeExtension(relativeFilename, ".mjs"))
+  };
+  return await (0, import_esbuild.build)({
+    entryPoints: [intermeddiateFiles.outClientFile],
+    outfile: outfiles.client,
+    packages: "external",
+    sourcemap: "inline",
+    format: "esm",
+    platform: "browser",
+    treeShaking: true,
+    bundle: true,
+    jsx: "automatic",
+    ignoreAnnotations: true,
+    plugins: [sideEffectPlugin(options), onlyReact(void 0, ignoreAssets, options)]
+  }), await (0, import_esbuild.build)({
+    entryPoints: [intermeddiateFiles.outServerFile],
+    outfile: outfiles.server,
+    packages: "external",
+    format: "esm",
+    platform: "node",
+    treeShaking: true,
+    bundle: true,
+    ignoreAnnotations: true,
+    plugins: [sideEffectPlugin(options), onlyReact(void 0, true, options), vmPlugin()]
+  }), { outfiles };
+}
+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;
+}
+function prettyURL(path2) {
+  return path2 === "." && (path2 = ""), path2.startsWith("/") || (path2 = `/${path2}`), path2.endsWith("/") && (path2 = path2.slice(0, -1)), path2;
+}
+async function compilePages(compileOptions, ignoreAssets = false) {
+  let baseDir = (0, import_node_path4.join)(process.cwd(), "pages"), pages = scanDirectory(baseDir), output = {};
+  for await (let page of pages) {
+    let pageName = (0, import_node_path4.parse)(page).name, name = prettyURL((0, import_node_path4.relative)(baseDir, page).replace(/\\/g, "/"));
+    pageName === "_layout" ? name = "[layout]" : pageName === "_error" && (name = "[error]"), output[name] = (await compilePage(page, compileOptions, ignoreAssets)).outfiles;
+  }
+  return output;
+}
+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;
+}
+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;
+}
+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 };
+}
+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;
+};
+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, import_react2.default.createElement("div", { style: containerStyle }, [
+  import_react2.default.createElement("h1", { key: "status" }, String(status)),
+  import_react2.default.createElement("p", { key: "message" }, message)
+]));
+var DefaultLayout = ({ children }) => import_react3.default.createElement(import_react3.default.Fragment, null, children);
+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;
+}
+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 import_node_readline.default.clearLine(stream, 0), import_node_readline.default.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;
+  }
+};
+function getUniqueArray(arr) {
+  return [...new Set(arr)];
+}
+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 = import_react.default.createElement(children, {
+    ...props,
+    key: path2
+  }), string = (0, import_server.renderToString)(import_react.default.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 = import_node_perf_hooks.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;
+  (0, import_node_fs5.writeFileSync)((0, import_node_path10.join)(outdir, "data", "_empty.json"), "{}");
+  for (let pageName in pages) {
+    let page = pages[pageName], data = await import((0, import_node_url2.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((0, import_node_path10.join)(outdir, route), ".html"), staticDataPath = changeExtension(
+          (0, import_node_path10.join)(
+            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((0, import_node_fs5.readFileSync)(staticDataPath).toString()),
+            params: matchUrlToRoute(route, convertToRegex(pageName))
+          },
+          template,
+          cssFiles: getUniqueArray([...cssFiles, ...layoutCss]),
+          staticManifest,
+          path: route,
+          scripts: getUniqueArray([layoutScript, ...script])
+        };
+        (0, import_node_fs5.mkdirSync)((0, import_node_path10.dirname)(outStaticPage), { recursive: true }), (0, import_node_fs5.writeFileSync)(outStaticPage, serverRendering(Client, ssrProps2));
+      }
+    } else {
+      if (pageName.startsWith("[") && pageName.endsWith("]"))
+        continue;
+      let route = replaceParamsInRoute(pageName, {}), outStaticPage = (0, import_node_path10.join)(outdir, route) + "/index.html", staticDataPath = changeExtension(
+        (0, import_node_path10.join)(
+          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((0, import_node_fs5.readFileSync)(staticDataPath).toString()),
+          params: {}
+        },
+        template,
+        cssFiles: getUniqueArray([...cssFiles, ...layoutCss]),
+        staticManifest,
+        path: route,
+        scripts: getUniqueArray([layoutScript, ...script])
+      };
+      (0, import_node_fs5.mkdirSync)((0, import_node_path10.dirname)(outStaticPage), { recursive: true }), (0, import_node_fs5.writeFileSync)(outStaticPage, serverRendering(Client, ssrProps2));
+    }
+  }
+  let ssrProps = {
+    Layout,
+    props: {},
+    template,
+    cssFiles: [...layoutCss],
+    staticManifest,
+    path: ".exta/ssr:unknown",
+    scripts: []
+  };
+  (0, import_node_fs5.writeFileSync)((0, import_node_path10.join)(outdir, "404.html"), serverRendering(ErrorComponent, ssrProps)), spinner.stop(
+    `html files generated. (${((import_node_perf_hooks.performance.now() - startTime) / 1e3).toFixed(2)}s)`
+  );
+}
+function randomString16() {
+  let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  return Array.from(
+    { length: 16 },
+    () => chars[Math.floor(Math.random() * chars.length)]
+  ).join("");
+}
+async function createStaticProps(pages, outdir) {
+  let startTime = import_node_perf_hooks2.performance.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((0, import_node_url3.pathToFileURL)(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 = (0, import_node_path11.join)(outdir, "data", `${random}.json`);
+        if (spinner.message = `Generating static data - ${originalURL}`, (0, import_node_fs6.mkdirSync)((0, import_node_path11.dirname)(outStaticPage), { recursive: true }), staticManifest[outfile] = random, data[PAGE_STATIC_DATA_FUNCTION]) {
+          let staticProps = await data[PAGE_STATIC_DATA_FUNCTION]({ params });
+          (0, import_node_fs6.writeFileSync)(outStaticPage, JSON.stringify(staticProps));
+        } else
+          staticManifest[outfile] = null;
+      }
+    } else {
+      let originalURL = replaceParamsInRoute(pageName, {}), outfile = changeExtension(originalURL, ".json").replace(/\//g, "_"), random = randomString16(), outStaticPage = (0, import_node_path11.join)(outdir, "data", `${random}.json`);
+      if (spinner.message = `Generating static data - ${originalURL}`, staticManifest[outfile] = random, (0, import_node_fs6.mkdirSync)((0, import_node_path11.dirname)(outStaticPage), { recursive: true }), data[PAGE_STATIC_DATA_FUNCTION]) {
+        let staticProps = await data[PAGE_STATIC_DATA_FUNCTION]();
+        (0, import_node_fs6.writeFileSync)(outStaticPage, JSON.stringify(staticProps));
+      } else
+        staticManifest[outfile] = null;
+    }
+  }
+  return spinner.stop(
+    `Static props generated. (${((import_node_perf_hooks2.performance.now() - startTime) / 1e3).toFixed(2)}s)`
+  ), staticManifest;
+}
+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 = (0, import_node_path9.relative)(
+        (0, import_node_path9.join)(".exta", "client").replace(/\\/g, "/"),
+        bundle[key].facadeModuleId
+      ), pageName = (0, import_node_path9.parse)(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 = true, config.build.rollupOptions.input["index.html"] = "index.html", vite = await (0, import_vite.createServer)({
+        server: { middlewareMode: true, hmr: false },
+        ...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(), (0, import_node_fs4.writeFileSync)(
+        (0, import_node_path9.join)(viteConfig.build.outDir, "map.json"),
+        JSON.stringify(generatePageMap(bundle))
+      );
+    },
+    async writeBundle() {
+      let { outDir } = viteConfig.build, indexHTML = (0, import_node_fs4.readFileSync)((0, import_node_path9.join)(outDir, "index.html")).toString();
+      pages = await compilePages(
+        { ...compilerOptions, outdir: viteConfig.build.outDir },
+        true
+      );
+      let manifestPath = (0, import_node_path9.join)(outDir, ".vite/manifest.json"), manifest = JSON.parse((0, import_node_fs4.readFileSync)(manifestPath).toString());
+      if (console.log(), await createStaticHTML(
+        pages,
+        viteConfig.build.outDir,
+        vite,
+        indexHTML,
+        manifest,
+        staticManifest
+      ), await vite.close(), (0, import_node_fs4.rmSync)((0, import_node_path9.join)(outDir, "map.json"), { recursive: true, force: true }), (0, import_node_fs4.rmSync)((0, import_node_path9.join)(outDir, "manifest.js"), { recursive: true, force: true }), (0, import_node_fs4.rmSync)((0, import_node_path9.join)(outDir, "client.js"), { recursive: true, force: true }), (0, import_node_fs4.rmSync)((0, import_node_path9.join)(outDir, "server"), { recursive: true, force: true }), (0, import_node_fs4.rmSync)((0, import_node_path9.join)(outDir, "client"), { recursive: true, force: true }), 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`}`
+          );
+        }
+        (0, import_node_fs4.writeFileSync)((0, import_node_path9.join)(__dirname, "../summary.txt"), buildSummary.join(`
+`)), console.log(
+          `
+Check the ${(0, import_node_path9.join)(__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)}`
+          }
+        ]
+      };
+    }
+  };
+}
+var manifestModuleId = "$exta-manifest", resolvedManifestModuleId = "\0" + manifestModuleId, clientModuleId = "$exta-client", resolvedClientModuleId = "\0" + clientModuleId, routerModuleId = "$exta-router", resolvedRouterModuleId = "\0" + routerModuleId;
+function exta(options) {
+  let isDev = true, dist = options?.compileOptions.outdir ?? (0, import_node_path.join)(process.cwd(), ".exta"), _manifest_object = [], _server_props = /* @__PURE__ */ new Map(), _pages, _manifest = null, logger, env;
+  (0, import_node_fs.existsSync)(dist) && (0, import_node_fs.rmSync)(dist, { recursive: true, force: true }), (0, import_node_fs.mkdirSync)(dist);
+  function generateManifest(rawManif, force = false) {
+    if (_manifest && !force)
+      return _manifest;
+    let manifest = [];
+    for (let path2 in rawManif) {
+      let converted = convertToRegex(path2), relativePath = (0, import_node_path.relative)(
+        (0, import_node_path.join)(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"] = (0, import_node_path.join)(
+          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 || (0, import_node_path.join)(process.cwd(), ".exta");
+        _pages = await compilePages(options?.compileOptions), _server_props.clear();
+        let beforeManifest = `${_manifest}`, afterManifest = generateManifest(_pages, true);
+        if (beforeManifest !== afterManifest)
+          return server.ws.send({ type: "full-reload" }), [];
+        (0, import_node_fs.writeFileSync)(
+          (0, import_node_path.join)(dist2, "manifest.js"),
+          `export default {${Object.keys(_pages).map(
+            (page) => `  "${page}": () => import("./${(0, import_node_path.relative)(dist2, _pages[page].client).replace(/\\/g, "/")}"),
+`
+          ).join(`
+`)}}`
+        );
+        let invalidateAndUpdate = (modid, isVirtual = true) => {
+          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 = (0, import_node_path.join)(process.cwd(), "pages"), pagesFiles = scanDirectory(pagesDirectory).map(
+          (p) => p.replace(/\\/g, "/")
+        ), compiledFile = changeExtension(
+          (0, import_node_path.join)(
+            process.cwd(),
+            ".exta",
+            "client",
+            (0, import_node_path.relative)(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, false);
+        }
+        logger.info(
+          `${"[exta]".gray} ${(0, import_node_path.relative)(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: true }));
+          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: true
+              })
+            );
+          try {
+            let serverModule = await import(`${(0, import_node_url.pathToFileURL)(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 = false;
+              for (let allowedParams of availableParams)
+                (0, import_node_util.isDeepStrictEqual)(encodeJSON(allowedParams), params) && (success = true);
+              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: (0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "client.mjs"), "utf-8")
+          };
+        if (id === resolvedManifestModuleId)
+          return {
+            code: generateManifest(_pages)
+          };
+        if (id === resolvedRouterModuleId)
+          return {
+            code: (0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "router.mjs"), "utf-8")
+          };
+      }
+    },
+    extaBuild(options?.compileOptions || {})
+  ];
+}