@noego/forge 0.0.1

package/dist-ssr/server.cjs

@@ -0,0 +1,876 @@
+"use strict";
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const express = require("express");
+const path = require("path");
+const deepmerge = require("deepmerge");
+const fs = require("fs");
+const Handlebars = require("handlebars");
+const fs$1 = require("fs/promises");
+const yaml = require("js-yaml");
+require("clone-deep");
+const join = require("url-join");
+const path$1 = require("./path-CyGuWUeq.cjs");
+const server = require("svelte/server");
+const pathToRegex = require("path-to-regex");
+const $ = require("svelte/internal/server");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const $__namespace = /* @__PURE__ */ _interopNamespaceDefault($);
+class ViteComponentLoader {
+  constructor(basePath, vite) {
+    this.basePath = basePath;
+    this.vite = vite;
+  }
+  async load(componentPath, options = { use_base_path: true }) {
+    let absoluteComponentPath;
+    const use_base_path = options.use_base_path || false;
+    if (use_base_path) {
+      absoluteComponentPath = path.join(this.basePath, componentPath);
+    } else {
+      if (path.isAbsolute(componentPath)) {
+        absoluteComponentPath = componentPath;
+      } else {
+        absoluteComponentPath = componentPath;
+      }
+    }
+    let vitePath = path.relative(process.cwd(), absoluteComponentPath);
+    vitePath = vitePath.replace(/\\/g, "/");
+    if (!vitePath.startsWith("/")) {
+      vitePath = "/" + vitePath;
+    }
+    try {
+      const module2 = await this.vite.ssrLoadModule(vitePath);
+      console.log(`[ViteComponentLoader] Module loaded successfully for: ${vitePath}`);
+      if (!module2 || !module2.default) {
+        console.error(`[ViteComponentLoader] Loaded module for ${vitePath} is invalid or missing a default export. Module content:`, module2);
+        throw new Error(`Module ${vitePath} loaded successfully but is invalid or missing default export.`);
+      }
+      return module2;
+    } catch (error) {
+      console.error(`[ViteComponentLoader] Error loading module for vitePath: ${vitePath} (derived from componentPath: ${componentPath})`, error);
+      try {
+        await fs.promises.access(absoluteComponentPath);
+      } catch (fsError) {
+      }
+      throw error;
+    }
+  }
+}
+class ProdComponentLoader {
+  constructor(base_path) {
+    this.base_path = base_path;
+  }
+  async load(componentPath) {
+    const component_path = path.join(this.base_path, componentPath);
+    const module2 = await import(component_path.replace(/\.svelte$/, ".js"));
+    return module2;
+  }
+}
+const default_template = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  {{{HEAD}}}
+  <style>{{{CSS}}}</style>
+</head>
+<body>
+  <div id="app">{{{APP}}}</div>
+  <script>window.__INITIAL_DATA__ = {{{DATA}}}<\/script>
+
+  <script type="module">
+    import { createApp } from '/src/client/client.ts';
+    document.addEventListener('DOMContentLoaded', () => {
+      createApp('/components/');
+    });
+  <\/script>
+</body>
+</html>
+`;
+class BaseHTMLRender {
+  constructor(template = default_template) {
+    this.template = template;
+  }
+  async getTemplate() {
+    return this.template;
+  }
+  async renderHTML(data) {
+    const template = Handlebars.compile(await this.getTemplate());
+    return template(data);
+  }
+}
+class DefaultHTMLRender extends BaseHTMLRender {
+  constructor() {
+    super();
+  }
+}
+class LiveHTMLRender {
+  constructor(html_path) {
+    this.html_path = html_path;
+  }
+  async renderHTML(data) {
+    const template = Handlebars.compile(await this.getTemplate());
+    return template(data);
+  }
+  async getTemplate() {
+    const file_content = await fs$1.readFile(this.html_path, "utf8");
+    return file_content;
+  }
+}
+function parseConfigfile(file_content) {
+  let config = null;
+  try {
+    config = yaml.load(file_content);
+  } catch (e) {
+    console.log(e);
+  }
+  return config;
+}
+function parse_modules(openapi) {
+  const modules_config = openapi.modules || openapi.module;
+  if (!modules_config) {
+    return;
+  }
+  const modules = Object.entries(modules_config).map(([_, module2]) => {
+    return module2;
+  });
+  const modules_path = modules.map((module2) => {
+    const basePath = module2.basePath || "";
+    const baseLayouts = module2.baseLayouts || [];
+    const paths = module2.paths;
+    if (!paths) {
+      return;
+    }
+    const configurations = Object.entries(paths).map(([path2, method_config]) => {
+      return Object.entries(method_config).map(([method, config]) => {
+        return path$1.parsePathConfig(path2, method, config);
+      });
+    });
+    const routes = configurations.reduce((flat_config, config) => {
+      return flat_config.concat(config);
+    }, []);
+    routes.forEach((route) => {
+      route.path = join(basePath, route.path);
+      route.layout = baseLayouts.concat(route.layout || []);
+    });
+    return routes;
+  });
+  return modules_path.reduce(
+    (flat_config, config) => {
+      return flat_config.concat(config);
+    },
+    []
+  );
+}
+function parse_paths(openapi) {
+  const paths = openapi.paths;
+  if (!paths) {
+    return;
+  }
+  const configurations = Object.entries(paths).map(([path2, method_config]) => {
+    return Object.entries(method_config).map(([method, config]) => {
+      return path$1.parsePathConfig(path2, method, config);
+    });
+  });
+  const routes = configurations.reduce((flat_config, config) => {
+    return flat_config.concat(config);
+  }, []);
+  return routes;
+}
+function isStitchConfig(document) {
+  return document && typeof document === "object" && "stitch" in document;
+}
+function isOpenAPIConfig(document) {
+  return document && typeof document === "object" && ("paths" in document || "module" in document || "modules" in document);
+}
+async function parse_openapi_config(openapi_config_path) {
+  const content = fs.readFileSync(openapi_config_path, "utf8");
+  const parsed_config = parseConfigfile(content);
+  let openapi_config;
+  if (isStitchConfig(parsed_config)) {
+    console.log("Detected stitch configuration, building with Node.js stitch engine...");
+    try {
+      const { StitchEngine } = await import("@noego/stitch");
+      const startTime = Date.now();
+      const engine = new StitchEngine();
+      const result = engine.buildSync(openapi_config_path, { format: "json" });
+      if (!result.success) {
+        throw new Error(`Stitch build failed: ${result.error}`);
+      }
+      const buildTime = Date.now() - startTime;
+      console.log(`INFO  Stitch build completed in ${buildTime} ms – ${parsed_config.stitch ? parsed_config.stitch.length : 0} modules processed`);
+      openapi_config = typeof result.data === "string" ? JSON.parse(result.data) : result.data;
+    } catch (error) {
+      throw new Error(`Failed to process stitch configuration: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } else if (isOpenAPIConfig(parsed_config)) {
+    console.log("Detected regular OpenAPI configuration");
+    openapi_config = parsed_config;
+  } else {
+    throw new Error(`Invalid OpenAPI or stitch configuration file: ${openapi_config_path}. File must contain either 'stitch', 'paths', 'module', or 'modules' at the root level.`);
+  }
+  let modules = parse_modules(openapi_config) || [];
+  let paths = parse_paths(openapi_config) || [];
+  let fallback_layout = openapi_config["x-fallback-layout"] || null;
+  let fallback_view = openapi_config["x-fallback-view"] || null;
+  let fallback = {
+    layout: fallback_layout ? [fallback_layout] : [],
+    view: fallback_view
+  };
+  const routes = [...modules, ...paths];
+  let config = {
+    fallback,
+    routes
+  };
+  return config;
+}
+const defaultViteOptions = {
+  appType: "custom",
+  root: process.cwd(),
+  // Explicitly set root
+  server: { middlewareMode: true },
+  ssr: {
+    noExternal: ["svelte", /^svelte\/.*/]
+    // Adjust if needed, maybe add your component specifically if still failing
+  }
+};
+const defaultOptions = {
+  development: process.env.NODE_ENV !== "production",
+  viteOptions: defaultViteOptions,
+  component_dir: "/",
+  build_dir: "dist_ssr",
+  renderer: "default",
+  open_api_path: path.join(process.cwd(), "openapi.yaml"),
+  manifest_endpoint: "/manifest.json"
+};
+class ManifestBuilder {
+  constructor(openapi_path, loader, options) {
+    __publicField(this, "full_options");
+    this.openapi_path = openapi_path;
+    this.loader = loader;
+    this.options = options;
+    this.full_options = deepmerge(defaultOptions, this.options);
+  }
+  async buildManifest() {
+    const configuration = await parse_openapi_config(this.openapi_path);
+    const component_path = this.full_options.component_dir;
+    if (!component_path) {
+      throw new Error("Component path is not defined");
+    }
+    const routes = configuration.routes;
+    const manifest = await routes.reduce(async (acc, route) => {
+      return acc.then(async (acc2) => {
+        const pattern = route.path;
+        const results = await requires_server(route, this.loader);
+        acc2[pattern] = results;
+        return acc2;
+      });
+    }, Promise.resolve({}));
+    return manifest;
+  }
+}
+async function requires_server(route, loader) {
+  return await layout_requires_server(route, loader) || await view_requires_server(route, loader);
+}
+async function layout_requires_server(route, loader) {
+  const layout = route.layout;
+  if (!layout) {
+    return false;
+  }
+  const load_required = await Promise.all(layout.map(async (layout2) => {
+    const component = await loader.load(layout2);
+    return !!component.load;
+  }));
+  return load_required.some((required) => required);
+}
+async function view_requires_server(route, loader) {
+  const view = route.view;
+  if (!view) {
+    return false;
+  }
+  const component = await loader.load(view);
+  return !!component.load;
+}
+class ApiAdapter {
+  constructor(manager) {
+    this.manager = manager;
+  }
+  async getApiData(route, request_data) {
+    const view = await this.manager.getViewComponent(route);
+    const layout_loaders = await this.manager.getLayoutLoaders(route);
+    const loader = view.load;
+    let layout_data = [];
+    let view_data = {};
+    if (layout_loaders.some((loader2) => !!loader2)) {
+      console.log("Layout API Calls");
+      layout_data = await Promise.all(layout_loaders.map(async (layout_loader) => {
+        if (!layout_loader) {
+          return {};
+        }
+        const data = await layout_loader(request_data);
+        return data;
+      }));
+    }
+    if (loader) {
+      view_data = await loader(request_data);
+    }
+    let server_data = {
+      layout: layout_data,
+      view: view_data
+    };
+    return server_data;
+  }
+  async getFallbackData(route, request_data) {
+    const view = await this.manager.getViewComponent(route);
+    const layout_loaders = await this.manager.getLayoutLoaders(route);
+    const loader = view.load;
+    let layout_data = [];
+    let view_data = {};
+    if (layout_loaders.some((loader2) => !!loader2)) {
+      console.log("Layout API Calls");
+      layout_data = await Promise.all(layout_loaders.map(async (layout_loader) => {
+        if (!layout_loader) {
+          return {};
+        }
+        const data = await layout_loader(request_data);
+        return data;
+      }));
+    }
+    if (loader) {
+      view_data = await loader(request_data);
+    }
+    let server_data = {
+      layout: layout_data,
+      view: view_data
+    };
+    return server_data;
+  }
+}
+class ComponentManager {
+  constructor(componentLoader) {
+    this.componentLoader = componentLoader;
+  }
+  async getLayoutComponents(route) {
+    const layout_paths = route.layout || [];
+    const layouts_components = await Promise.all(layout_paths.map((layout) => {
+      console.log("layout path", layout);
+      return this.componentLoader.load(layout);
+    }));
+    return layouts_components;
+  }
+  async getLayouts(route) {
+    const layout_paths = route.layout || [];
+    const layouts_components = await Promise.all(layout_paths.map(async (layout_path) => {
+      const layout = await this.componentLoader.load(layout_path);
+      return layout.default;
+    }));
+    return layouts_components;
+  }
+  async getLayoutLoaders(route) {
+    const layout_components = await this.getLayoutComponents(route);
+    const layout_loaders = await Promise.all(layout_components.map(async (layout) => {
+      return layout.load;
+    }));
+    return layout_loaders;
+  }
+  async getViewComponent(route) {
+    return await this.componentLoader.load(route.view);
+  }
+  async getView(route) {
+    const view = await this.componentLoader.load(route.view);
+    return view.default;
+  }
+}
+class MiddlewareAdapter {
+  constructor(manager) {
+    this.manager = manager;
+  }
+  async handleMiddleware(req, reply, route, request_data, callback) {
+    let components = await this.manager.getLayoutComponents(route);
+    let middleware_stack = await Promise.all(components.map(async (component) => {
+      const middleware = [...component.middleware || [], ...component.middlewares || []];
+      return middleware;
+    }));
+    const layout_middlewares = middleware_stack.flat() || [];
+    console.log("middleware stack loaded", layout_middlewares);
+    req.params = request_data.params;
+    await new Promise((resolve) => {
+      this.runMiddleware(layout_middlewares, req, reply, resolve);
+    });
+    console.log("layout middleware executed");
+    console.log("view middleware loaded");
+    console.log("view middleware", route.view);
+    let view = {};
+    if (route.view) {
+      view = await this.manager.getViewComponent(route);
+    }
+    let view_middlewares = [...view.middleware || [], ...view.middlewares || []];
+    await new Promise((resolve) => {
+      this.runMiddleware(view_middlewares, req, reply, resolve);
+    });
+    callback();
+  }
+  runMiddleware(middleware, req, reply, callback) {
+    middleware = this.dedupe(middleware);
+    let index = 0;
+    if (middleware.length === 0) {
+      callback();
+      return;
+    }
+    let next = () => {
+      if (index >= middleware.length) {
+        callback();
+        return;
+      }
+      const mw = middleware[index];
+      index++;
+      if (typeof mw === "function") {
+        if (!reply.sent)
+          mw(req, reply, next);
+      } else {
+        if (!reply.sent)
+          next();
+      }
+    };
+    next();
+  }
+  dedupe(middlewares) {
+    return Array.from(new Set(middlewares));
+  }
+}
+function makeUrlParser(pattern) {
+  const parser = new pathToRegex(pattern);
+  return (pathname) => {
+    const result = parser.match(pathname);
+    return result || null;
+  };
+}
+function initialize_route_matchers(routes) {
+  return routes.map((route) => {
+    const pattern = route.path;
+    const parser = makeUrlParser(pattern);
+    return { pattern, parser };
+  });
+}
+class ServerAdapter {
+}
+function RecursiveRender($$payload, $$props) {
+  $__namespace.push();
+  let topLayout, childlayouts, top_data, other_data, view_data, recursive_child_data;
+  let layouts = $__namespace.fallback($$props["layouts"], () => [], true);
+  let view = $__namespace.fallback($$props["view"], null);
+  let data = $__namespace.fallback($$props["data"], () => ({}), true);
+  let params = $__namespace.fallback($$props["params"], () => ({}), true);
+  let urlParams = $__namespace.fallback($$props["urlParams"], () => ({}), true);
+  let query = $__namespace.fallback($$props["query"], () => ({}), true);
+  let page = $__namespace.fallback($$props["page"], null);
+  console.log("[page]", page);
+  [topLayout, ...childlayouts] = layouts;
+  [top_data, ...other_data] = data.layout || [];
+  view_data = data.view;
+  recursive_child_data = { layout: other_data, view: data.view };
+  if (childlayouts.length > 0) {
+    $$payload.out += "<!--[-->";
+    $$payload.out += `<!---->`;
+    topLayout == null ? void 0 : topLayout($$payload, $__namespace.spread_props([
+      top_data || {},
+      {
+        params,
+        urlParams,
+        query,
+        page,
+        children: ($$payload2) => {
+          RecursiveRender($$payload2, {
+            layouts: childlayouts,
+            view,
+            data: recursive_child_data,
+            params,
+            urlParams,
+            query,
+            page
+          });
+          $$payload2.out += `<!---->`;
+        },
+        $$slots: { default: true }
+      }
+    ]));
+    $$payload.out += `<!---->`;
+  } else if (topLayout) {
+    $$payload.out += "<!--[1-->";
+    $$payload.out += `<!---->`;
+    topLayout == null ? void 0 : topLayout($$payload, $__namespace.spread_props([
+      top_data || {},
+      {
+        params,
+        urlParams,
+        query,
+        page,
+        children: ($$payload2) => {
+          $$payload2.out += `<!---->`;
+          view == null ? void 0 : view($$payload2, $__namespace.spread_props([
+            view_data || {},
+            { params, urlParams, query, page }
+          ]));
+          $$payload2.out += `<!---->`;
+        },
+        $$slots: { default: true }
+      }
+    ]));
+    $$payload.out += `<!---->`;
+  } else {
+    $$payload.out += "<!--[!-->";
+    $$payload.out += `<!---->`;
+    view == null ? void 0 : view($$payload, $__namespace.spread_props([
+      view_data || {},
+      { params, urlParams, query, page }
+    ]));
+    $$payload.out += `<!---->`;
+  }
+  $$payload.out += `<!--]-->`;
+  $__namespace.bind_props($$props, {
+    layouts,
+    view,
+    data,
+    params,
+    urlParams,
+    query,
+    page
+  });
+  $__namespace.pop();
+}
+class ExpressServerAdapter extends ServerAdapter {
+  constructor(server2, manager, htmlRender, api_adapter, middleware_adapter) {
+    super();
+    this.server = server2;
+    this.manager = manager;
+    this.htmlRender = htmlRender;
+    this.api_adapter = api_adapter;
+    this.middleware_adapter = middleware_adapter;
+  }
+  async handleRoutes(routes, manifest) {
+    const matchers = initialize_route_matchers(routes);
+    this.server.use((req, res, next) => {
+      (async () => {
+        if (res.headersSent) {
+          return;
+        }
+        const method = req.method.toLowerCase();
+        const fullUrl = req.url || "/";
+        const path2 = fullUrl.split("?")[0];
+        const not_found = async () => {
+          next();
+        };
+        const matcher = matchers.find((m) => m.parser(path2));
+        if (!matcher) {
+          await not_found();
+          return;
+        }
+        const route_options = routes.filter((r) => r.path === matcher.pattern);
+        const route = route_options.find((r) => r.method.toLowerCase() === method);
+        if (!route) {
+          await not_found();
+          return;
+        }
+        await this.handleResponse(fullUrl, matcher, route, routes, manifest, req, res).catch((e) => {
+          res.status(500).send(`
+                        <h1>500 Internal Server Error</h1>
+                        <pre>${e}</pre>
+                    `);
+        });
+      })();
+      return;
+    });
+  }
+  async handleResponse(url, matcher, route, routes, manifest, req, res) {
+    var _a, _b;
+    let accepts = req.headers.accept || "";
+    let server_api_call = accepts.toLowerCase().includes("application/json");
+    const context = {};
+    req["context"] = context;
+    const cleanPath = url.split("?")[0];
+    const pathParams = matcher.parser(cleanPath);
+    const queryParams = {};
+    for (const [key, value] of Object.entries(req.query)) {
+      if (typeof value === "string") {
+        queryParams[key] = value;
+      } else if (Array.isArray(value)) {
+        queryParams[key] = value.map((v) => typeof v === "string" ? v : String(v));
+      } else if (value !== void 0) {
+        queryParams[key] = String(value);
+      }
+    }
+    const combinedParams = { ...pathParams, ...queryParams };
+    let request_data = {
+      url,
+      query: req.query,
+      params: combinedParams,
+      headers: req.headers,
+      body: req.body,
+      context
+    };
+    try {
+      await new Promise((resolve, reject) => {
+        this.middleware_adapter.handleMiddleware(req, res, route, request_data, resolve).catch(reject);
+      });
+    } catch (e) {
+      console.log("Error in middleware", e);
+      res.status(500).send(`
+                <h1>500 Internal Server Error</h1>
+                <pre>${e}</pre>
+            `);
+      return;
+    }
+    if (res.headersSent) {
+      return;
+    }
+    let server_data = await this.api_adapter.getApiData(route, request_data);
+    if (server_api_call) {
+      res.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate").header("Pragma", "no-cache").header("Expires", "0").type("application/json").send(server_data);
+      return;
+    }
+    let layouts;
+    let view;
+    try {
+      layouts = await this.manager.getLayouts(route);
+      view = await this.manager.getView(route);
+    } catch (e) {
+      console.log("Error getting view", e);
+      res.status(500).send(`
+                <h1>500 Internal Server Error</h1>
+                <pre>${e}</pre>
+            `);
+      return;
+    }
+    let html_render = "";
+    let response_code = 200;
+    try {
+      let page = {
+        url: request_data.url,
+        pathname: request_data.url.split("?")[0],
+        params: request_data.params || {},
+        query: request_data.query
+      };
+      let { head: head_render, body: body_render, css } = server.render(RecursiveRender, {
+        props: {
+          layouts,
+          view,
+          data: server_data,
+          params: request_data.params,
+          urlParams: pathParams,
+          query: request_data.query,
+          page
+        }
+      });
+      const head_routing = `
+            <script type='text/javascript'>
+            window.__ROUTING__ = ${JSON.stringify(routes)}
+            <\/script>
+
+            <script type='text/javascript'>
+            window.__MANIFEST__ = ${JSON.stringify(manifest)}
+            <\/script>
+
+            <script type='text/javascript'>
+            window.__INITIAL_DATA__ = ${JSON.stringify(server_data || {}).trim()}
+            <\/script>
+            `;
+      html_render = await this.htmlRender.renderHTML({
+        HEAD: head_routing + (head_render || ""),
+        CSS: css,
+        APP: body_render
+      });
+    } catch (e) {
+      response_code = 500;
+      const new_body = `<pre>Error rendering HTML:
+${e}` + (((_a = route.layout) == null ? void 0 : _a.length) ? `layouts: ${(_b = route.layout) == null ? void 0 : _b.join(",\n")}` : "") + `
+view: ${route.view}</pre>`;
+      html_render = await this.htmlRender.renderHTML({
+        APP: new_body
+        // DATA: JSON.stringify({})
+      });
+    }
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.status(response_code);
+    res.end(html_render);
+  }
+  async handleFallback(req, res, server_config) {
+    if (res.headersSent) {
+      console.log("Reply already sent");
+      return;
+    }
+    let route = server_config.fallback;
+    let accepts = req.headers.accept || "";
+    let server_api_call = accepts.toLowerCase().includes("application/json");
+    const url = req.url || "/";
+    const context = {};
+    let fallback_data = {
+      url,
+      query: req.query,
+      params: {},
+      headers: req.headers,
+      body: req.body,
+      context
+    };
+    let request_data = fallback_data;
+    await new Promise((resolve) => {
+      this.middleware_adapter.handleMiddleware(req, res, route, request_data, resolve);
+    });
+    console.log("Completed fallback middleware");
+    let server_data = await this.api_adapter.getApiData(route, request_data);
+    console.log("Completed fallback API call");
+    if (server_api_call) {
+      console.log("Fallback API call");
+      res.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate").header("Pragma", "no-cache").header("Expires", "0").type("application/json").status(404).send(server_data);
+      return;
+    }
+    const layouts = await this.manager.getLayouts(route);
+    const view = await this.manager.getView(route);
+    console.log("Fallback view", view);
+    console.log("Fallback layouts", layouts);
+    let { head: head_render, body: body_render, css } = server.render(RecursiveRender, {
+      props: {
+        layouts,
+        view,
+        data: server_data,
+        params: request_data.params
+      }
+    });
+    const html_render = await this.htmlRender.renderHTML({
+      HEAD: head_render,
+      CSS: css,
+      APP: body_render
+    });
+    res.type("text/html").status(404).send(html_render);
+  }
+}
+async function createServer(app, options) {
+  options = options || defaultOptions;
+  const full_options = deepmerge(defaultOptions, options);
+  full_options.open_api_path = ensureFullPath(full_options.viteOptions.root, full_options.open_api_path);
+  const isProd = full_options.development === false;
+  console.log(`Running in ${isProd ? "production" : "development"} mode`);
+  const COMPONENT_DIR = path.join(full_options.viteOptions.root, full_options.component_dir);
+  const root = full_options.viteOptions.root;
+  let componentLoader;
+  let vite;
+  console.log(`Serving components from ${COMPONENT_DIR} at /components/`);
+  if (full_options.assets) {
+    for (const [asset_path, asset_dir] of Object.entries(full_options.assets)) {
+      for (const asset of asset_dir) {
+        const asset_root = path.join(full_options.viteOptions.root, asset);
+        app.use(asset_path, express.static(asset_root));
+        console.log(`Serving assets from ${asset_root} at ${asset_path}`);
+      }
+    }
+  } else {
+    console.log(`No assets to serve`);
+  }
+  if (!isProd) {
+    console.log("Starting Vite in development mode...");
+    const { createServer: createViteServer } = await import("vite");
+    vite = await createViteServer(options.viteOptions || full_options.viteOptions);
+    componentLoader = new ViteComponentLoader(COMPONENT_DIR, vite);
+    console.log("loaded");
+  } else {
+    console.log("Starting Vite in production mode...");
+    app.use("/", express.static(path.join(options.viteOptions.root, full_options.build_dir)));
+    console.log(`Serving static files from ${path.join(options.viteOptions.root, full_options.build_dir)} at /`);
+    componentLoader = new ProdComponentLoader(COMPONENT_DIR);
+  }
+  const manifest = await new ManifestBuilder(
+    full_options.open_api_path,
+    componentLoader,
+    full_options
+  ).buildManifest();
+  const htmlRenderer = getRenderer(root, full_options.renderer, isProd);
+  const server_config = await parse_openapi_config(full_options.open_api_path);
+  const routeDefs = server_config.routes;
+  const manager = new ComponentManager(componentLoader);
+  const api_adapter = new ApiAdapter(manager);
+  const middleware_adapter = new MiddlewareAdapter(manager);
+  const adapter = new ExpressServerAdapter(
+    app,
+    manager,
+    htmlRenderer,
+    api_adapter,
+    middleware_adapter
+  );
+  await adapter.handleRoutes(routeDefs, manifest);
+  console.log("Routes registered");
+  if (!isProd) {
+    app.use(vite.middlewares);
+  }
+  return app;
+}
+function getRenderer(root, renderer, isProd) {
+  if (renderer === "default") {
+    return new DefaultHTMLRender();
+  } else if (typeof renderer === "string" && !isProd) {
+    return new LiveHTMLRender(ensureFullPath(root, renderer));
+  } else if (typeof renderer === "string" && isProd) {
+    const html = ensureFullPath(root, renderer);
+    const template = fs.readFileSync(html, "utf8");
+    return new BaseHTMLRender(template);
+  } else if (renderer instanceof BaseHTMLRender) {
+    return renderer;
+  } else {
+    throw new Error("Invalid renderer type");
+  }
+}
+function ensureFullPath(root, renderer) {
+  if (path.isAbsolute(renderer)) {
+    console.log(`Renderer path is absolute: ${renderer}`);
+    return urlJoin(root, renderer);
+  } else {
+    console.log(`Renderer path is relative: ${renderer}`);
+    return path.resolve(root, renderer);
+  }
+}
+function urlJoin(base, path2) {
+  if (base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  if (path2.startsWith("/")) {
+    path2 = path2.slice(1);
+  }
+  return `${base}/${path2}`;
+}
+exports.createServer = createServer;
+//# sourceMappingURL=server.cjs.map