@nexusts/view 0.7.2

package/dist/index.js

@@ -0,0 +1,843 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/view/src/rendu.ts
+import { compileTemplate } from "rendu";
+
+class RenduAdapter {
+  name = "rendu";
+  cache = new Map;
+  render(template, data, context, options) {
+    const safe = {};
+    for (const [k, v] of Object.entries(data)) {
+      safe[k] = typeof v === "string" ? v : v == null ? "" : String(v);
+    }
+    const merged = this.mergeData(safe, context, options);
+    return this.getCompiled(template, options)(merged);
+  }
+  compile(template, options) {
+    const compiled = this.getCompiled(template, options);
+    return (data) => compiled(data);
+  }
+  getCompiled(template, options) {
+    const cacheKey = options ? `${options.stream ? "s" : ""}` : "";
+    let compiled = this.cache.get(cacheKey);
+    if (!compiled) {
+      compiled = compileTemplate(template, {
+        stream: options?.stream ?? false
+      });
+      this.cache.set(cacheKey, compiled);
+    }
+    return compiled;
+  }
+  mergeData(data, context, options) {
+    const merged = { ...data };
+    if (context) {
+      if (context.request)
+        merged.$REQUEST = context.request;
+      if (context.response)
+        merged.$RESPONSE = context.response;
+      if (context.globals)
+        Object.assign(merged, context.globals);
+    }
+    if (options?.layout)
+      merged.$LAYOUT = options.layout;
+    return merged;
+  }
+}
+// packages/view/src/edge.ts
+class EdgeAdapter {
+  edge;
+  name = "edge";
+  constructor(edge) {
+    this.edge = edge;
+  }
+  async render(template, data, context, options) {
+    if (!this.edge) {
+      throw new Error("EdgeAdapter requires an Edge instance. " + "Install `edge.js` and pass it to `new EdgeAdapter(edge)`, " + "or use the default RenduAdapter instead.");
+    }
+    const fn = this.edge.renderRaw ?? this.edge.renderString;
+    if (!fn) {
+      throw new Error("Provided Edge instance does not implement renderRaw/renderString.");
+    }
+    return fn.call(this.edge, template, { ...data, $OPTIONS: options });
+  }
+}
+// packages/view/src/eta.ts
+class EtaAdapter {
+  name = "eta";
+  cache = new Map;
+  async render(template, data, _context, _options) {
+    const compiled = this.getCompiled(template);
+    return compiled(data);
+  }
+  compile(template, _options) {
+    const compiled = this.getCompiled(template);
+    return (data) => Promise.resolve(compiled(data));
+  }
+  getCompiled(template) {
+    let fn = this.cache.get(template);
+    if (!fn) {
+      let Eta;
+      try {
+        Eta = __require("eta").Eta;
+      } catch (e) {
+        throw new Error(`[nexus] EtaAdapter: the "eta" package is not installed. ` + `Run \`bun add eta\` (or \`npm install eta\`) to use .eta templates.`);
+      }
+      const eta = new Eta;
+      fn = (data) => eta.renderString(template, data);
+      this.cache.set(template, fn);
+    }
+    return fn;
+  }
+}
+// packages/view/src/inertia/inertia-adapter.ts
+import"reflect-metadata";
+
+// packages/view/src/inertia/helpers.ts
+class DeferredProp {
+  callback;
+  group;
+  __inertiaKind = "deferred";
+  constructor(callback, group = "default") {
+    this.callback = callback;
+    this.group = group;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function defer(callback, group = "default") {
+  return new DeferredProp(callback, group);
+}
+
+class AlwaysProp {
+  callback;
+  __inertiaKind = "always";
+  constructor(callback) {
+    this.callback = callback;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function always(callback) {
+  return new AlwaysProp(callback);
+}
+
+class OptionalProp {
+  callback;
+  threshold;
+  __inertiaKind = "optional";
+  constructor(callback, threshold = 0) {
+    this.callback = callback;
+    this.threshold = threshold;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function optional(callback, threshold = 0) {
+  return new OptionalProp(callback, threshold);
+}
+
+class MergeProp {
+  __inertiaKind = "merge";
+  matchPropsOn;
+  constructor(callback, matchPropsOn = []) {
+    this.matchPropsOn = matchPropsOn;
+    this.callback = callback;
+  }
+  callback;
+  resolve() {
+    return this.callback();
+  }
+}
+function merge(callback, matchPropsOn = []) {
+  return new MergeProp(callback, matchPropsOn);
+}
+
+class DeepMergeProp {
+  callback;
+  __inertiaKind = "deepMerge";
+  constructor(callback) {
+    this.callback = callback;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function deepMerge(callback) {
+  return new DeepMergeProp(callback);
+}
+
+class OnceProp {
+  callback;
+  __inertiaKind = "once";
+  constructor(callback) {
+    this.callback = callback;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function once(callback) {
+  return new OnceProp(callback);
+}
+function isInertiaHelper(value) {
+  return value !== null && typeof value === "object" && typeof value.__inertiaKind === "string" && typeof value.resolve === "function";
+}
+
+// packages/view/src/inertia/default-ssr.ts
+async function renderDefaultRoot(adapter, ssr, component, page, c) {
+  const title = adapter.title();
+  const headTags = [];
+  let bodyHtml = "";
+  if (ssr) {
+    try {
+      const result = await ssr.render(component, page.props);
+      bodyHtml = result.html ?? "";
+      if (result.head)
+        headTags.push(...result.head);
+      if (result.data) {
+        Object.assign(page, result.data);
+      }
+    } catch (err) {
+      console.error(`[inertia] SSR render failed for "${component}":`, err);
+    }
+  }
+  if (ssr?.head) {
+    try {
+      const extra = await ssr.head();
+      headTags.push(...extra);
+    } catch {}
+  }
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+${headTags.join(`
+`)}
+</head>
+<body>
+<div id="app" data-page="${escapeAttr(JSON.stringify(page))}">${bodyHtml}</div>
+</body>
+</html>`;
+  return c.html(html, 200, {
+    Vary: "X-Inertia"
+  });
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(s) {
+  return escapeHtml(s).replace(/'/g, "&#39;");
+}
+
+// packages/view/src/inertia/inertia-response.ts
+var INERTIA_RESPONSE_TAG = "__nexus_inertia_response__";
+
+class InertiaResponse {
+  adapter;
+  component;
+  props;
+  [INERTIA_RESPONSE_TAG] = true;
+  options = {};
+  lazyCache = new Map;
+  constructor(adapter, component, props) {
+    this.adapter = adapter;
+    this.component = component;
+    this.props = props;
+  }
+  withEncryptHistory(encrypt = true) {
+    this.options.encryptHistory = encrypt;
+    return this;
+  }
+  withClearHistory(clear = true) {
+    this.options.clearHistory = clear;
+    return this;
+  }
+  async toResponse(c) {
+    const url = c.req.url;
+    const info = this.parseInertiaRequest(c);
+    if (info.isInertia && info.clientVersion !== undefined) {
+      const serverVersion = await this.adapter.resolveVersion();
+      if (serverVersion !== undefined && info.clientVersion !== serverVersion) {
+        return this.assetVersionMismatch(c.req.url);
+      }
+    }
+    const page = await this.buildPage(url, info, c);
+    if (info.isInertia) {
+      return this.jsonResponse(page);
+    }
+    return this.htmlResponse(c, page);
+  }
+  async buildPage(url, info, c) {
+    const shared = await this.adapter.getSharedFor(c);
+    const allProps = { ...shared, ...this.props };
+    const resolved = {};
+    const deferredProps = {};
+    const mergeProps = [];
+    const deepMergeProps = [];
+    const matchPropsOn = [];
+    for (const [key, value] of Object.entries(allProps)) {
+      if (isInertiaHelper(value)) {
+        const helper = value;
+        switch (helper.__inertiaKind) {
+          case "deferred": {
+            const d = helper;
+            const group = d.group ?? "default";
+            (deferredProps[group] ??= []).push(key);
+            resolved[key] = null;
+            break;
+          }
+          case "always": {
+            resolved[key] = await Promise.resolve(helper.resolve());
+            break;
+          }
+          case "optional": {
+            const v = await Promise.resolve(helper.resolve());
+            const o = helper;
+            const threshold = o.threshold ?? 0;
+            if (Array.isArray(v) && v.length <= threshold) {
+              if (this.isPartialReload(info)) {
+                continue;
+              }
+            }
+            resolved[key] = v;
+            break;
+          }
+          case "merge": {
+            const v = await Promise.resolve(helper.resolve());
+            mergeProps.push(key);
+            const m = helper;
+            if (m.matchPropsOn && m.matchPropsOn.length > 0) {
+              deepMergeProps.push(key);
+              matchPropsOn.push(m.matchPropsOn);
+            }
+            resolved[key] = v;
+            break;
+          }
+          case "deepMerge": {
+            resolved[key] = await Promise.resolve(helper.resolve());
+            mergeProps.push(key);
+            deepMergeProps.push(key);
+            break;
+          }
+          case "once": {
+            if (info.isInertia) {
+              continue;
+            }
+            resolved[key] = await Promise.resolve(helper.resolve());
+            break;
+          }
+          case "lazy": {
+            const lz = helper;
+            const tag = lz.tag;
+            if (this.lazyCache.has(tag)) {
+              resolved[key] = this.lazyCache.get(tag);
+            } else {
+              const v = await Promise.resolve(helper.resolve());
+              this.lazyCache.set(tag, v);
+              resolved[key] = v;
+            }
+            break;
+          }
+          default: {
+            resolved[key] = await Promise.resolve(helper.resolve());
+          }
+        }
+      } else {
+        resolved[key] = value;
+      }
+    }
+    const sharedKeys = new Set(Object.keys(shared));
+    this.applyPartialFilter(resolved, info, sharedKeys);
+    const version = await this.adapter.resolveVersion();
+    return {
+      component: this.component,
+      props: resolved,
+      url,
+      version: version ?? "",
+      encryptHistory: this.options.encryptHistory ?? this.adapter.encryptHistory(),
+      clearHistory: this.options.clearHistory ?? false,
+      deferredProps: Object.keys(deferredProps).length > 0 ? deferredProps : undefined,
+      mergeProps: mergeProps.length > 0 ? mergeProps : undefined,
+      deepMergeProps: deepMergeProps.length > 0 ? deepMergeProps : undefined,
+      matchPropsOn: matchPropsOn.length > 0 ? matchPropsOn : undefined,
+      scrollRegions: {}
+    };
+  }
+  applyPartialFilter(resolved, info, sharedKeys) {
+    if (!this.isPartialReload(info))
+      return;
+    if (info.partialOnly) {
+      for (const key of Object.keys(resolved)) {
+        const isAlways = sharedKeys.has(key);
+        if (!info.partialOnly.includes(key) && !isAlways) {
+          delete resolved[key];
+        }
+      }
+    }
+    if (info.partialExcept) {
+      for (const key of Object.keys(resolved)) {
+        const isAlways = sharedKeys.has(key);
+        if (info.partialExcept.includes(key) && !isAlways) {
+          delete resolved[key];
+        }
+      }
+    }
+  }
+  isPartialReload(info) {
+    return info.isInertia && (!!info.partialOnly || !!info.partialExcept);
+  }
+  parseInertiaRequest(c) {
+    const isInertia = c.req.header("x-inertia") === "true";
+    const partialOnlyHeader = c.req.header("x-inertia-partial-data");
+    const partialExceptHeader = c.req.header("x-inertia-partial-except");
+    const resetHeader = c.req.header("x-inertia-reset");
+    return {
+      isInertia,
+      clientVersion: c.req.header("x-inertia-version") ?? undefined,
+      partialComponent: c.req.header("x-inertia-partial-component") ?? undefined,
+      partialOnly: this.csv(partialOnlyHeader),
+      partialExcept: this.csv(partialExceptHeader),
+      reset: this.csv(resetHeader),
+      isHardReload: c.req.header("x-inertia-hard-reload") === "true"
+    };
+  }
+  csv(value) {
+    if (!value)
+      return;
+    const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+    return parts.length > 0 ? parts : undefined;
+  }
+  jsonResponse(page) {
+    return new Response(JSON.stringify(page), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        Vary: "X-Inertia",
+        "X-Inertia": "true"
+      }
+    });
+  }
+  htmlResponse(c, page) {
+    const ssr = this.adapter.ssr();
+    return renderDefaultRoot(this.adapter, ssr ?? null, this.component, page, c);
+  }
+  assetVersionMismatch(url) {
+    return new Response(null, {
+      status: 409,
+      headers: {
+        "X-Inertia-Location": url
+      }
+    });
+  }
+}
+
+// packages/view/src/inertia/form-helper.ts
+class InertiaFormBuilder {
+  adapter;
+  component;
+  props;
+  errorMap = {};
+  errorBagName;
+  constructor(adapter, component, initialProps = {}) {
+    this.adapter = adapter;
+    this.component = component;
+    this.props = { ...initialProps };
+  }
+  withProps(extra) {
+    Object.assign(this.props, extra);
+    return this;
+  }
+  with(key, value) {
+    this.props[key] = value;
+    return this;
+  }
+  withErrors(errors) {
+    for (const [field, message] of Object.entries(errors)) {
+      const list = Array.isArray(message) ? message : [message];
+      this.errorMap[field] = [...this.errorMap[field] ?? [], ...list];
+    }
+    return this;
+  }
+  withError(field, message) {
+    (this.errorMap[field] ??= []).push(message);
+    return this;
+  }
+  withErrorBag(name) {
+    this.errorBagName = name;
+    return this;
+  }
+  withValues(values) {
+    this.props.values = values;
+    return this;
+  }
+  render() {
+    if (Object.keys(this.errorMap).length > 0) {
+      this.props.errors = { ...this.errorMap };
+    }
+    if (this.errorBagName) {
+      this.props.errorBag = this.errorBagName;
+    }
+    return this.adapter.render(this.component, this.props);
+  }
+  redirect(url) {
+    return new Response(null, {
+      status: 303,
+      headers: { Location: url }
+    });
+  }
+  back(to) {
+    return new Response(null, {
+      status: 303,
+      headers: { Location: to ?? "back" }
+    });
+  }
+  getErrors() {
+    return { ...this.errorMap };
+  }
+  getProps() {
+    return { ...this.props };
+  }
+}
+
+// packages/view/src/inertia/inertia-adapter.ts
+var INERTIA_TOKEN = Symbol.for("nexus:Inertia");
+
+class Inertia {
+  config;
+  shared = {};
+  constructor(config = {}) {
+    this.config = {
+      encryptHistory: false,
+      ...config
+    };
+  }
+  render(component, propsOrDeferred, maybeProps) {
+    const { component: comp, props } = this.normalizeRenderArgs(component, propsOrDeferred, maybeProps);
+    return new InertiaResponse(this, comp, props);
+  }
+  location(url) {
+    return new Response(null, {
+      status: 409,
+      headers: {
+        "X-Inertia-Location": url
+      }
+    });
+  }
+  redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: { Location: url }
+    });
+  }
+  back() {
+    return new Response(null, {
+      status: 302,
+      headers: { Location: "back" }
+    });
+  }
+  form(component, initialProps = {}) {
+    return new InertiaFormBuilder(this, component, initialProps);
+  }
+  setVersion(version) {
+    this.config.version = version;
+    return this;
+  }
+  setSsrAdapter(adapter) {
+    this.config.ssr = adapter ?? undefined;
+    return this;
+  }
+  setTitle(title) {
+    this.config.title = title;
+    return this;
+  }
+  setEncryptHistory(encrypt = true) {
+    this.config.encryptHistory = encrypt;
+    return this;
+  }
+  setSharedProps(shared) {
+    this.config.sharedProps = shared;
+    return this;
+  }
+  share(key, value) {
+    if (typeof key === "string") {
+      this.shared[key] = value;
+    } else if (key && typeof key === "object") {
+      Object.assign(this.shared, key);
+    }
+  }
+  unshare(key) {
+    delete this.shared[key];
+  }
+  getShared() {
+    return { ...this.shared };
+  }
+  title() {
+    return this.config.title ?? "Nexus";
+  }
+  encryptHistory() {
+    return this.config.encryptHistory ?? false;
+  }
+  ssr() {
+    return this.config.ssr ?? null;
+  }
+  async resolveVersion() {
+    const v = this.config.version;
+    if (typeof v === "function")
+      return await v();
+    return v;
+  }
+  async getSharedFor(_c) {
+    const static_ = this.getShared();
+    const configured = this.config.sharedProps;
+    if (typeof configured === "function") {
+      const dyn = await configured();
+      return { ...static_, ...dyn };
+    }
+    return { ...static_, ...configured ?? {} };
+  }
+  static TOKEN = INERTIA_TOKEN;
+  normalizeRenderArgs(component, propsOrDeferred, maybeProps) {
+    if (maybeProps !== undefined) {
+      const deferred = {};
+      for (const [k, v] of Object.entries(propsOrDeferred)) {
+        if (v instanceof DeferredProp)
+          deferred[k] = v;
+        else
+          throw new Error(`Inertia.render: 3-arg form expects the second argument to be a map of deferred props. ` + `Got non-deferred value at key "${k}".`);
+      }
+      return { component, props: { ...deferred, ...maybeProps } };
+    }
+    return { component, props: propsOrDeferred ?? {} };
+  }
+}
+// packages/view/src/inertia/form-middleware.ts
+var FORM_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function inertiaFormMiddleware(options = {}) {
+  const csrfHeader = (options.csrfHeader ?? "X-CSRF-Token").toLowerCase();
+  const csrfField = options.csrfField ?? "_token";
+  const csrfSharedKey = options.csrfSharedKey ?? "csrfToken";
+  const csrfStatus = options.csrfFailureStatus ?? 419;
+  return async (c, next) => {
+    const method = c.req.method;
+    if (!FORM_METHODS.has(method)) {
+      await next();
+      return;
+    }
+    if (options.validateCsrf) {
+      const expected = options.getCsrfToken ? options.getCsrfToken(c) : c.get("nexusjs")?.shared?.[csrfSharedKey];
+      if (typeof expected === "string" && expected.length > 0) {
+        const submittedHeader = c.req.header(csrfHeader);
+        const submittedField = await readFieldFromBody(c, csrfField);
+        const submitted = submittedHeader ?? submittedField;
+        if (submitted !== expected) {
+          return c.json({ message: "CSRF token mismatch" }, csrfStatus);
+        }
+      }
+    }
+    const contentType = c.req.header("content-type") ?? "";
+    if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+      try {
+        const parsed = await c.req.parseBody();
+        c.set("formBody", parsed);
+      } catch {}
+    }
+    await next();
+    return;
+  };
+}
+async function readFieldFromBody(c, field) {
+  const cached = c.get("formBody");
+  if (cached && Object.hasOwn(cached, field)) {
+    const v = cached[field];
+    return Array.isArray(v) ? v[0] : v;
+  }
+  try {
+    const body = await c.req.parseBody();
+    if (body && Object.hasOwn(body, field)) {
+      const v = body[field];
+      return Array.isArray(v) ? v[0] : v;
+    }
+  } catch {}
+  return;
+}
+// packages/view/src/inertia/ssr/registry.ts
+class ComponentRegistry {
+  map = new Map;
+  register(name, component) {
+    this.map.set(name, component);
+    return this;
+  }
+  registerAll(components) {
+    for (const [name, component] of Object.entries(components)) {
+      this.map.set(name, component);
+    }
+    return this;
+  }
+  resolve(name) {
+    return this.map.get(name);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+  unregister(name) {
+    return this.map.delete(name);
+  }
+  names() {
+    return [...this.map.keys()];
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+function createRegistry(initial) {
+  const reg = new ComponentRegistry;
+  if (initial)
+    reg.registerAll(initial);
+  return reg;
+}
+function asRegistry(input) {
+  return input instanceof ComponentRegistry ? input : createRegistry(input);
+}
+
+// packages/view/src/inertia/ssr/react-adapter.ts
+function createReactAdapter(options) {
+  const registry = asRegistry(options.components);
+  return {
+    name: "react",
+    async render(component, props) {
+      const [{ renderToString }, React] = await Promise.all([
+        import("react-dom/server"),
+        import("react")
+      ]);
+      const Component = registry.resolve(component);
+      if (!Component) {
+        throw new Error(`[inertia/react] Component "${component}" is not registered. ` + `Use createReactAdapter({ components: { ${component}: ... } }) ` + `or registry.register('${component}', Component).`);
+      }
+      const element = React.createElement(Component, props);
+      const html = renderToString(element);
+      return { html, head: [] };
+    }
+  };
+}
+// packages/view/src/inertia/ssr/vue-adapter.ts
+function createVueAdapter(options) {
+  const registry = asRegistry(options.components);
+  return {
+    name: "vue",
+    async render(component, props) {
+      const [{ renderToString }, { createSSRApp, h }] = await Promise.all([
+        import("vue/server-renderer"),
+        import("vue")
+      ]);
+      const Component = registry.resolve(component);
+      if (!Component) {
+        throw new Error(`[inertia/vue] Component "${component}" is not registered. ` + `Use createVueAdapter({ components: { ${component}: ... } }) ` + `or registry.register('${component}', Component).`);
+      }
+      const app = createSSRApp({
+        render() {
+          return h(Component, props);
+        }
+      });
+      const html = await renderToString(app);
+      return { html, head: [] };
+    }
+  };
+}
+// packages/view/src/view-engine.ts
+var viewPath = "";
+function setViewPaths(path) {
+  viewPath = path ? path.endsWith("/") || path.endsWith("\\") ? path : `${path}/` : "";
+}
+function getViewPaths() {
+  return viewPath;
+}
+var VIEW_FILE_EXTS = [".html", ".edge", ".rendu", ".eta"];
+function isViewFilePath(name) {
+  const lower = name.toLowerCase();
+  return VIEW_FILE_EXTS.some((ext) => lower.endsWith(ext));
+}
+function selectAdapter(template) {
+  const lower = template.toLowerCase();
+  if (lower.endsWith(".edge"))
+    return new EdgeAdapter;
+  if (lower.endsWith(".eta"))
+    return new EtaAdapter;
+  return new RenduAdapter;
+}
+async function renderView(template, data, context) {
+  let source = template;
+  if (isViewFilePath(template) && viewPath.length > 0) {
+    const loaded = await loadTemplate(viewPath, template);
+    if (loaded === null) {
+      throw new Error(`[nexus] View file not found: "${template}" (searched: ${viewPath})`);
+    }
+    source = loaded;
+  }
+  const adapter = selectAdapter(source);
+  return adapter.render(source, data, context);
+}
+async function loadTemplate(dir, name) {
+  if (!dir)
+    return null;
+  const full = joinPath(dir, name);
+  try {
+    const file = await readFile(full);
+    if (file !== null)
+      return file;
+  } catch {}
+  return null;
+}
+function joinPath(dir, name) {
+  if (!dir.endsWith("/") && !dir.endsWith("\\"))
+    return `${dir}/${name}`;
+  return `${dir}${name}`;
+}
+async function readFile(path) {
+  if (typeof globalThis.Bun !== "undefined") {
+    try {
+      const file = globalThis.Bun.file(path);
+      if (await file.exists())
+        return file.text();
+    } catch {}
+  }
+  try {
+    const fs = await import("fs/promises");
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+export {
+  setViewPaths,
+  renderView,
+  renderDefaultRoot,
+  optional,
+  once,
+  merge,
+  loadTemplate,
+  inertiaFormMiddleware,
+  getViewPaths,
+  defer,
+  deepMerge,
+  createVueAdapter,
+  createRegistry,
+  createReactAdapter,
+  asRegistry,
+  always,
+  RenduAdapter,
+  InertiaFormBuilder,
+  Inertia,
+  EtaAdapter,
+  EdgeAdapter,
+  ComponentRegistry
+};
+
+//# debugId=7E50D43C00788D4B64756E2164756E21
+//# sourceMappingURL=index.js.map