npm - @noego/forge - Versions diffs - 0.0.1 - Mend

@noego/forge 0.0.1

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 (145) hide show

package/README.md +620 -0
package/dist/client/client.d.ts +8 -0
package/dist/client/client.d.ts.map +1 -0
package/dist/client/events.d.ts +4 -0
package/dist/client/events.d.ts.map +1 -0
package/dist/client/index.d.ts +6 -0
package/dist/client/index.d.ts.map +1 -0
package/dist/client/navigation.svelte.d.ts +4 -0
package/dist/client/navigation.svelte.d.ts.map +1 -0
package/dist/client/page.svelte.d.ts +4 -0
package/dist/client/page.svelte.d.ts.map +1 -0
package/dist/client.cjs +2 -0
package/dist/client.cjs.map +1 -0
package/dist/client.d.ts +2 -0
package/dist/client.mjs +605 -0
package/dist/client.mjs.map +1 -0
package/dist/index.d.ts +3 -0
package/dist/index.d.ts.map +1 -0
package/dist/options/ServerOptions.d.ts +16 -0
package/dist/options/ServerOptions.d.ts.map +1 -0
package/dist/page.cjs +2 -0
package/dist/page.cjs.map +1 -0
package/dist/page.d.ts +2 -0
package/dist/page.mjs +7 -0
package/dist/page.mjs.map +1 -0
package/dist/page.svelte-C4chAYK2.js +137 -0
package/dist/page.svelte-C4chAYK2.js.map +1 -0
package/dist/page.svelte-Dvj7306U.cjs +2 -0
package/dist/page.svelte-Dvj7306U.cjs.map +1 -0
package/dist/parser/IRoute.d.ts +31 -0
package/dist/parser/IRoute.d.ts.map +1 -0
package/dist/parser/openapi.d.ts +9 -0
package/dist/parser/openapi.d.ts.map +1 -0
package/dist/parser/path.d.ts +9 -0
package/dist/parser/path.d.ts.map +1 -0
package/dist/routing/base.d.ts +10 -0
package/dist/routing/base.d.ts.map +1 -0
package/dist/routing/component_loader/component_loader.d.ts +27 -0
package/dist/routing/component_loader/component_loader.d.ts.map +1 -0
package/dist/routing/component_loader/component_manager.d.ts +12 -0
package/dist/routing/component_loader/component_manager.d.ts.map +1 -0
package/dist/routing/html_render/html_render.d.ts +20 -0
package/dist/routing/html_render/html_render.d.ts.map +1 -0
package/dist/routing/manifest/base.d.ts +11 -0
package/dist/routing/manifest/base.d.ts.map +1 -0
package/dist/routing/manifest/store.svelte.d.ts +3 -0
package/dist/routing/manifest/store.svelte.d.ts.map +1 -0
package/dist/routing/page.d.ts +7 -0
package/dist/routing/page.d.ts.map +1 -0
package/dist/routing/server_adapter/api_adapter.d.ts +23 -0
package/dist/routing/server_adapter/api_adapter.d.ts.map +1 -0
package/dist/routing/server_adapter/express_server_adapter.d.ts +20 -0
package/dist/routing/server_adapter/express_server_adapter.d.ts.map +1 -0
package/dist/routing/server_adapter/middleware_adapter.d.ts +12 -0
package/dist/routing/server_adapter/middleware_adapter.d.ts.map +1 -0
package/dist/routing/server_adapter/server_adapter.d.ts +5 -0
package/dist/routing/server_adapter/server_adapter.d.ts.map +1 -0
package/dist/routing/shadow/shadow_route.d.ts +2 -0
package/dist/routing/shadow/shadow_route.d.ts.map +1 -0
package/dist/routing/url_parser.d.ts +12 -0
package/dist/routing/url_parser.d.ts.map +1 -0
package/dist/server/server.d.ts +5 -0
package/dist/server/server.d.ts.map +1 -0
package/dist/shared.cjs +2 -0
package/dist/shared.cjs.map +1 -0
package/dist/shared.d.ts +2 -0
package/dist/shared.d.ts.map +1 -0
package/dist/shared.mjs +5 -0
package/dist/shared.mjs.map +1 -0
package/dist/types/Callback.d.ts +2 -0
package/dist/types/Callback.d.ts.map +1 -0
package/dist/types/FetchMiddleware.d.ts +21 -0
package/dist/types/FetchMiddleware.d.ts.map +1 -0
package/dist/vite-env.d.ts +19 -0
package/dist-ssr/client/client.d.ts +8 -0
package/dist-ssr/client/client.d.ts.map +1 -0
package/dist-ssr/client/events.d.ts +4 -0
package/dist-ssr/client/events.d.ts.map +1 -0
package/dist-ssr/client/index.d.ts +6 -0
package/dist-ssr/client/index.d.ts.map +1 -0
package/dist-ssr/client/navigation.svelte.d.ts +4 -0
package/dist-ssr/client/navigation.svelte.d.ts.map +1 -0
package/dist-ssr/client/page.svelte.d.ts +4 -0
package/dist-ssr/client/page.svelte.d.ts.map +1 -0
package/dist-ssr/index.d.ts +3 -0
package/dist-ssr/index.d.ts.map +1 -0
package/dist-ssr/options/ServerOptions.d.ts +16 -0
package/dist-ssr/options/ServerOptions.d.ts.map +1 -0
package/dist-ssr/parser/IRoute.d.ts +31 -0
package/dist-ssr/parser/IRoute.d.ts.map +1 -0
package/dist-ssr/parser/openapi.d.ts +9 -0
package/dist-ssr/parser/openapi.d.ts.map +1 -0
package/dist-ssr/parser/path.d.ts +9 -0
package/dist-ssr/parser/path.d.ts.map +1 -0
package/dist-ssr/path-CyGuWUeq.cjs +68 -0
package/dist-ssr/path-CyGuWUeq.cjs.map +1 -0
package/dist-ssr/path-ODk1FhWY.js +69 -0
package/dist-ssr/path-ODk1FhWY.js.map +1 -0
package/dist-ssr/routing/base.d.ts +10 -0
package/dist-ssr/routing/base.d.ts.map +1 -0
package/dist-ssr/routing/component_loader/component_loader.d.ts +27 -0
package/dist-ssr/routing/component_loader/component_loader.d.ts.map +1 -0
package/dist-ssr/routing/component_loader/component_manager.d.ts +12 -0
package/dist-ssr/routing/component_loader/component_manager.d.ts.map +1 -0
package/dist-ssr/routing/html_render/html_render.d.ts +20 -0
package/dist-ssr/routing/html_render/html_render.d.ts.map +1 -0
package/dist-ssr/routing/manifest/base.d.ts +11 -0
package/dist-ssr/routing/manifest/base.d.ts.map +1 -0
package/dist-ssr/routing/manifest/store.svelte.d.ts +3 -0
package/dist-ssr/routing/manifest/store.svelte.d.ts.map +1 -0
package/dist-ssr/routing/page.d.ts +7 -0
package/dist-ssr/routing/page.d.ts.map +1 -0
package/dist-ssr/routing/server_adapter/api_adapter.d.ts +23 -0
package/dist-ssr/routing/server_adapter/api_adapter.d.ts.map +1 -0
package/dist-ssr/routing/server_adapter/express_server_adapter.d.ts +20 -0
package/dist-ssr/routing/server_adapter/express_server_adapter.d.ts.map +1 -0
package/dist-ssr/routing/server_adapter/middleware_adapter.d.ts +12 -0
package/dist-ssr/routing/server_adapter/middleware_adapter.d.ts.map +1 -0
package/dist-ssr/routing/server_adapter/server_adapter.d.ts +5 -0
package/dist-ssr/routing/server_adapter/server_adapter.d.ts.map +1 -0
package/dist-ssr/routing/shadow/shadow_route.d.ts +2 -0
package/dist-ssr/routing/shadow/shadow_route.d.ts.map +1 -0
package/dist-ssr/routing/url_parser.d.ts +12 -0
package/dist-ssr/routing/url_parser.d.ts.map +1 -0
package/dist-ssr/server/server.d.ts +5 -0
package/dist-ssr/server/server.d.ts.map +1 -0
package/dist-ssr/server.cjs +876 -0
package/dist-ssr/server.cjs.map +1 -0
package/dist-ssr/server.d.ts +2 -0
package/dist-ssr/server.js +838 -0
package/dist-ssr/server.js.map +1 -0
package/dist-ssr/shared.cjs +31 -0
package/dist-ssr/shared.cjs.map +1 -0
package/dist-ssr/shared.d.ts +2 -0
package/dist-ssr/shared.d.ts.map +1 -0
package/dist-ssr/shared.js +31 -0
package/dist-ssr/shared.js.map +1 -0
package/dist-ssr/types/Callback.d.ts +2 -0
package/dist-ssr/types/Callback.d.ts.map +1 -0
package/dist-ssr/types/FetchMiddleware.d.ts +21 -0
package/dist-ssr/types/FetchMiddleware.d.ts.map +1 -0
package/dist-ssr/vite-env.d.ts +19 -0
package/loaders/loader.mjs +20 -0
package/package.json +121 -0
package/schema.json +333 -0

package/dist-ssr/server.js ADDED Viewed

@@ -0,0 +1,838 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import express from "express";
+import path from "path";
+import deepmerge from "deepmerge";
+import fs from "fs";
+import Handlebars from "handlebars";
+import fs$1 from "fs/promises";
+import yaml from "js-yaml";
+import "clone-deep";
+import join from "url-join";
+import { p as parsePathConfig } from "./path-ODk1FhWY.js";
+import { render } from "svelte/server";
+import pathToRegex from "path-to-regex";
+import * as $ from "svelte/internal/server";
+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 module = await this.vite.ssrLoadModule(vitePath);
+      console.log(`[ViteComponentLoader] Module loaded successfully for: ${vitePath}`);
+      if (!module || !module.default) {
+        console.error(`[ViteComponentLoader] Loaded module for ${vitePath} is invalid or missing a default export. Module content:`, module);
+        throw new Error(`Module ${vitePath} loaded successfully but is invalid or missing default export.`);
+      }
+      return module;
+    } 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 module = await import(component_path.replace(/\.svelte$/, ".js"));
+    return module;
+  }
+}
+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(([_, module]) => {
+    return module;
+  });
+  const modules_path = modules.map((module) => {
+    const basePath = module.basePath || "";
+    const baseLayouts = module.baseLayouts || [];
+    const paths = module.paths;
+    if (!paths) {
+      return;
+    }
+    const configurations = Object.entries(paths).map(([path2, method_config]) => {
+      return Object.entries(method_config).map(([method, config]) => {
+        return 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 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) {
+  $.push();
+  let topLayout, childlayouts, top_data, other_data, view_data, recursive_child_data;
+  let layouts = $.fallback($$props["layouts"], () => [], true);
+  let view = $.fallback($$props["view"], null);
+  let data = $.fallback($$props["data"], () => ({}), true);
+  let params = $.fallback($$props["params"], () => ({}), true);
+  let urlParams = $.fallback($$props["urlParams"], () => ({}), true);
+  let query = $.fallback($$props["query"], () => ({}), true);
+  let page = $.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, $.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, $.spread_props([
+      top_data || {},
+      {
+        params,
+        urlParams,
+        query,
+        page,
+        children: ($$payload2) => {
+          $$payload2.out += `<!---->`;
+          view == null ? void 0 : view($$payload2, $.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, $.spread_props([
+      view_data || {},
+      { params, urlParams, query, page }
+    ]));
+    $$payload.out += `<!---->`;
+  }
+  $$payload.out += `<!--]-->`;
+  $.bind_props($$props, {
+    layouts,
+    view,
+    data,
+    params,
+    urlParams,
+    query,
+    page
+  });
+  $.pop();
+}
+class ExpressServerAdapter extends ServerAdapter {
+  constructor(server, manager, htmlRender, api_adapter, middleware_adapter) {
+    super();
+    this.server = server;
+    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 } = 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 } = 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}`;
+}
+export {
+  createServer
+};
+//# sourceMappingURL=server.js.map