@arponascension/express-inertia 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1218 @@
+import fs from 'fs';
+import ejs from 'ejs';
+import path from 'path';
+
+// src/utils.ts
+function lazy(callback) {
+  return {
+    __inertia_lazy: true,
+    callback
+  };
+}
+function always(value) {
+  return {
+    __inertia_always: true,
+    value
+  };
+}
+function defer(callback, options) {
+  return {
+    __inertia_deferred: true,
+    callback,
+    group: options?.group
+  };
+}
+function merge(value) {
+  return {
+    __inertia_merge: true,
+    value
+  };
+}
+function optional(callback) {
+  return {
+    __inertia_optional: true,
+    callback
+  };
+}
+function isLazy(val) {
+  return val && typeof val === "object" && val.__inertia_lazy === true;
+}
+function isAlways(val) {
+  return val && typeof val === "object" && val.__inertia_always === true;
+}
+function isDeferred(val) {
+  return val && typeof val === "object" && val.__inertia_deferred === true;
+}
+function isMerge(val) {
+  return val && typeof val === "object" && val.__inertia_merge === true;
+}
+function isOptional(val) {
+  return val && typeof val === "object" && val.__inertia_optional === true;
+}
+async function resolveProps(rawProps, req, component) {
+  const isPartial = req.header("X-Inertia-Partial-Component") === component && Boolean(req.header("X-Inertia-Partial-Data"));
+  const partialKeys = isPartial ? (req.header("X-Inertia-Partial-Data") || "").split(",").map((k) => k.trim()).filter(Boolean) : [];
+  const resolvedProps = {};
+  const deferredMap = {};
+  const mergeKeys = [];
+  for (const [key, rawValue] of Object.entries(rawProps)) {
+    if (isMerge(rawValue)) {
+      mergeKeys.push(key);
+    }
+    if (isDeferred(rawValue)) {
+      const group = rawValue.group || "default";
+      if (!deferredMap[group]) {
+        deferredMap[group] = [];
+      }
+      deferredMap[group].push(key);
+    }
+    if (isPartial) {
+      const isRequested = partialKeys.includes(key);
+      const isAlwaysIncluded = isAlways(rawValue);
+      if (!isRequested && !isAlwaysIncluded) {
+        continue;
+      }
+    } else {
+      if (isLazy(rawValue) || isDeferred(rawValue)) {
+        continue;
+      }
+    }
+    resolvedProps[key] = await unwrapValue(rawValue, req);
+  }
+  return {
+    resolvedProps,
+    deferredProps: Object.keys(deferredMap).length > 0 ? deferredMap : void 0,
+    mergeProps: mergeKeys.length > 0 ? mergeKeys : void 0
+  };
+}
+async function unwrapValue(val, req) {
+  if (val === null || val === void 0) {
+    return val;
+  }
+  if (isLazy(val)) {
+    val = val.callback;
+  } else if (isAlways(val)) {
+    val = val.value;
+  } else if (isDeferred(val)) {
+    val = val.callback;
+  } else if (isMerge(val)) {
+    val = val.value;
+  } else if (isOptional(val)) {
+    val = val.callback;
+  }
+  if (typeof val === "function") {
+    val = val(req);
+  }
+  if (val && typeof val.then === "function") {
+    val = await val;
+  }
+  return val;
+}
+function escapeHtmlAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializePage(page) {
+  return escapeHtmlAttr(safeStringify(page));
+}
+function safeStringify(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(obj, (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return null;
+      }
+      seen.add(value);
+    }
+    return value;
+  });
+}
+var DEFAULT_COMPONENT_NAME_PATTERN = /^[\w-]+(?:\/[\w-]+)*$/;
+function validateComponentName(component, pattern = DEFAULT_COMPONENT_NAME_PATTERN) {
+  if (!pattern.test(component)) {
+    throw new TypeError(
+      `Invalid component name "${component}". Component names must match the pattern ${pattern}.`
+    );
+  }
+}
+function sanitizeViewData(data) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function sanitize(value) {
+    if (typeof value === "function" || value === void 0) {
+      return void 0;
+    }
+    if (value === null || typeof value !== "object" || Buffer.isBuffer(value)) {
+      return value;
+    }
+    if (seen.has(value)) {
+      return void 0;
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      return value.map((item) => sanitize(item));
+    }
+    const sanitized = {};
+    for (const [key, val] of Object.entries(value)) {
+      const cleaned = sanitize(val);
+      if (cleaned !== void 0) {
+        sanitized[key] = cleaned;
+      }
+    }
+    return sanitized;
+  }
+  return sanitize(data);
+}
+async function generateSriHash(content) {
+  const crypto = await import('crypto');
+  const hash = crypto.createHash("sha384").update(content);
+  return `sha384-${hash.digest("base64")}`;
+}
+
+// src/logger.ts
+var DEFAULT_PREFIX = "express-inertia";
+function createConsoleLogger(prefix) {
+  return {
+    warn(message, meta) {
+      const payload = meta ? { ...meta } : void 0;
+      if (payload && Object.keys(payload).length > 0) {
+        console.warn(`[${prefix}] ${message}`, JSON.stringify(payload));
+      } else {
+        console.warn(`[${prefix}] ${message}`);
+      }
+    },
+    error(message, meta) {
+      const payload = meta ? { ...meta } : void 0;
+      if (payload && Object.keys(payload).length > 0) {
+        console.error(`[${prefix}] ${message}`, JSON.stringify(payload));
+      } else {
+        console.error(`[${prefix}] ${message}`);
+      }
+    },
+    info(message, meta) {
+      const payload = meta ? { ...meta } : void 0;
+      if (payload && Object.keys(payload).length > 0) {
+        console.info(`[${prefix}] ${message}`, JSON.stringify(payload));
+      } else {
+        console.info(`[${prefix}] ${message}`);
+      }
+    },
+    debug(message, meta) {
+      const payload = meta ? { ...meta } : void 0;
+      if (payload && Object.keys(payload).length > 0) {
+        console.debug(`[${prefix}] ${message}`, JSON.stringify(payload));
+      } else {
+        console.debug(`[${prefix}] ${message}`);
+      }
+    }
+  };
+}
+var globalLogger = createConsoleLogger(DEFAULT_PREFIX);
+function setGlobalLogger(logger2) {
+  globalLogger = logger2;
+}
+function getGlobalLogger() {
+  return globalLogger;
+}
+function createLogger(options = {}) {
+  const prefix = options.prefix || DEFAULT_PREFIX;
+  if (options.logger) {
+    return options.logger;
+  }
+  return createConsoleLogger(prefix);
+}
+
+// src/circuit-breaker.ts
+var DEFAULT_CIRCUIT_OPTIONS = {
+  failureThreshold: 5,
+  cooldownMs: 3e4,
+  probeDelayMs: 1e3
+};
+var CircuitBreaker = class {
+  constructor(options = DEFAULT_CIRCUIT_OPTIONS) {
+    this.options = options;
+  }
+  options;
+  state = "CLOSED";
+  failures = 0;
+  openedAt = 0;
+  probeTimer = null;
+  pendingProbe = null;
+  getState() {
+    if (this.state === "OPEN" && Date.now() - this.openedAt >= this.options.cooldownMs) {
+      this.state = "HALF_OPEN";
+    }
+    return this.state;
+  }
+  async execute(fn) {
+    const state = this.getState();
+    if (state === "OPEN") {
+      throw new Error("Circuit breaker is open");
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (err) {
+      this.onFailure();
+      throw err;
+    }
+  }
+  onSuccess() {
+    this.failures = 0;
+    this.state = "CLOSED";
+    if (this.probeTimer) {
+      clearTimeout(this.probeTimer);
+      this.probeTimer = null;
+    }
+  }
+  onFailure() {
+    this.failures++;
+    if (this.failures >= this.options.failureThreshold) {
+      this.state = "OPEN";
+      this.openedAt = Date.now();
+    }
+  }
+  async allowProbe(fn) {
+    if (this.getState() !== "HALF_OPEN") {
+      throw new Error("Circuit breaker is not in HALF_OPEN state");
+    }
+    if (this.pendingProbe) {
+      return this.pendingProbe.then(() => fn());
+    }
+    this.pendingProbe = new Promise((resolve) => {
+      this.probeTimer = setTimeout(() => {
+        this.pendingProbe = null;
+        resolve();
+      }, this.options.probeDelayMs);
+    });
+    return this.pendingProbe.then(() => fn());
+  }
+  reset() {
+    this.failures = 0;
+    this.state = "CLOSED";
+    this.openedAt = 0;
+    if (this.probeTimer) {
+      clearTimeout(this.probeTimer);
+      this.probeTimer = null;
+    }
+    this.pendingProbe = null;
+  }
+};
+function shouldRetry(error, statusCode, retryableStatusCodes) {
+  if (error?.name === "AbortError" || error?.name === "TypeError") {
+    return true;
+  }
+  if (typeof statusCode === "number" && retryableStatusCodes.includes(statusCode)) {
+    return true;
+  }
+  return false;
+}
+function calculateBackoff(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = baseDelayMs * Math.pow(2, attempt);
+  const jitter = Math.random() * baseDelayMs;
+  return Math.min(exponential + jitter, maxDelayMs);
+}
+
+// src/ssr.ts
+var DEFAULT_SSR_URL = "http://127.0.0.1:13714/render";
+var DEFAULT_TIMEOUT = 2e3;
+var logger = createLogger({ prefix: "express-inertia:ssr" });
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 2,
+  baseDelayMs: 200,
+  maxDelayMs: 2e3,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+var circuitBreakers = /* @__PURE__ */ new Map();
+function getCircuitBreaker(endpoint, options) {
+  const key = options?.circuitBreaker ? `${endpoint}:${JSON.stringify(options.circuitBreaker)}` : endpoint;
+  let breaker = circuitBreakers.get(key);
+  if (!breaker) {
+    const cbOptions = {
+      ...DEFAULT_CIRCUIT_OPTIONS,
+      ...options?.circuitBreaker
+    };
+    breaker = new CircuitBreaker(cbOptions);
+    circuitBreakers.set(key, breaker);
+  }
+  return breaker;
+}
+function resetAllCircuitBreakers() {
+  for (const breaker of circuitBreakers.values()) {
+    breaker.reset();
+  }
+  circuitBreakers.clear();
+}
+async function renderSSR(page, options) {
+  if (!options) {
+    return null;
+  }
+  const ssrConfig = typeof options === "boolean" ? { enabled: options } : options;
+  if (ssrConfig.enabled === false) {
+    return null;
+  }
+  if (typeof ssrConfig.render === "function") {
+    try {
+      return await renderWithRetry(async () => {
+        return await ssrConfig.render(page);
+      }, ssrConfig.retry, page.component);
+    } catch (err) {
+      if (ssrConfig.fallback === false) {
+        throw err;
+      }
+      logger.warn("Custom SSR render failed, falling back to client-side", {
+        error: err.message,
+        component: page.component
+      });
+      return null;
+    }
+  }
+  const endpoint = ssrConfig.url || DEFAULT_SSR_URL;
+  const timeout = ssrConfig.timeout || DEFAULT_TIMEOUT;
+  const retryOptions = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...ssrConfig.retry
+  };
+  const breaker = getCircuitBreaker(endpoint, ssrConfig);
+  try {
+    const result = await breaker.execute(
+      () => renderWithRetry(
+        () => renderHttpSSR(page, endpoint, timeout),
+        retryOptions,
+        page.component
+      )
+    );
+    return result;
+  } catch (err) {
+    if (ssrConfig.fallback === false) {
+      throw err;
+    }
+    logger.warn("SSR rendering failed, falling back to client rendering", {
+      endpoint,
+      component: page.component,
+      error: err.message
+    });
+    return null;
+  }
+}
+async function renderHttpSSR(page, endpoint, timeout) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  let pageJson;
+  try {
+    pageJson = JSON.stringify(page);
+  } catch (err) {
+    throw new Error(`Failed to serialize page for SSR: ${err.message}`);
+  }
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: pageJson,
+    signal: controller.signal
+  });
+  clearTimeout(timer);
+  if (!response.ok) {
+    throw new Error(`SSR server responded with status: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return {
+    head: Array.isArray(data.head) ? data.head : [],
+    body: typeof data.body === "string" ? data.body : ""
+  };
+}
+async function renderWithRetry(fn, retryOptions, context) {
+  const options = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...retryOptions
+  };
+  let lastError;
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt >= options.maxRetries) {
+        break;
+      }
+      const statusCode = err.status || err.response?.status;
+      if (!shouldRetry(err, statusCode, options.retryableStatusCodes)) {
+        break;
+      }
+      const delay = calculateBackoff(attempt, options.baseDelayMs, options.maxDelayMs);
+      logger.warn("SSR request failed, retrying", {
+        attempt: attempt + 1,
+        maxRetries: options.maxRetries,
+        delayMs: Math.round(delay),
+        error: err.message,
+        component: context
+      });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+
+// src/response.ts
+function createInertiaResponse(req, res, options, globalSharedProps = {}) {
+  const requestSharedProps = {};
+  let currentRootView = options.rootView || "base.ejs";
+  let currentVersion = options.version;
+  let historyEncryption = options.encryptHistory;
+  let clearHistorySetting;
+  const flashMessages = {};
+  async function resolveVersionValue() {
+    if (!currentVersion) {
+      return null;
+    }
+    if (typeof currentVersion === "function") {
+      const result = await currentVersion();
+      return result || null;
+    }
+    return currentVersion;
+  }
+  const renderFn = async (component, props = {}, viewData = {}) => {
+    const securityOptions = options.security ?? { validateComponentNames: true };
+    if (securityOptions.validateComponentNames !== false) {
+      const pattern = securityOptions.componentNamePattern ?? DEFAULT_COMPONENT_NAME_PATTERN;
+      validateComponentName(component, pattern);
+    }
+    let dynamicGlobal = {};
+    if (typeof options.shared === "function") {
+      dynamicGlobal = await options.shared(req);
+    } else if (options.shared) {
+      dynamicGlobal = options.shared;
+    }
+    const allProps = {
+      ...globalSharedProps,
+      ...dynamicGlobal,
+      ...requestSharedProps,
+      ...Object.keys(flashMessages).length > 0 ? { flash: flashMessages } : {},
+      ...props
+    };
+    const version = await resolveVersionValue();
+    const { resolvedProps, deferredProps, mergeProps } = await resolveProps(
+      allProps,
+      req,
+      component
+    );
+    const pageUrl = req.originalUrl || req.url;
+    const page = {
+      component,
+      props: resolvedProps,
+      url: pageUrl,
+      version
+    };
+    if (historyEncryption !== void 0) {
+      page.encryptHistory = historyEncryption;
+    }
+    if (clearHistorySetting !== void 0) {
+      page.clearHistory = clearHistorySetting;
+    }
+    if (deferredProps) {
+      page.deferredProps = deferredProps;
+    }
+    if (mergeProps) {
+      page.mergeProps = mergeProps;
+    }
+    if (req.header("X-Inertia")) {
+      res.setHeader("X-Inertia", "true");
+      res.setHeader("Vary", "Accept, X-Inertia");
+      if (historyEncryption) {
+        res.setHeader("X-Inertia-Encrypt-History", "true");
+      }
+      if (clearHistorySetting) {
+        res.setHeader("X-Inertia-Clear-History", "true");
+      }
+      res.status(200).setHeader("Content-Type", "application/json").send(safeStringify(page));
+      return;
+    }
+    let ssrResult = null;
+    if (options.ssr) {
+      ssrResult = await renderSSR(page, options.ssr);
+    }
+    let globalViewData = {};
+    if (typeof options.viewData === "function") {
+      globalViewData = await options.viewData(req);
+    } else if (options.viewData) {
+      globalViewData = options.viewData;
+    }
+    const sanitizedViewData = securityOptions.validateComponentNames !== false ? sanitizeViewData(viewData) : viewData;
+    const sanitizedGlobalViewData = securityOptions.validateComponentNames !== false ? sanitizeViewData(globalViewData) : globalViewData;
+    const templateData = {
+      ...res.locals,
+      ...sanitizedGlobalViewData,
+      ...sanitizedViewData,
+      page,
+      ssr: ssrResult,
+      inertiaVersion: options.inertiaVersion,
+      rootElement: options.rootElement,
+      req
+    };
+    res.setHeader("Vary", "Accept, X-Inertia");
+    res.render(currentRootView, templateData);
+  };
+  const handler = renderFn;
+  handler.render = renderFn;
+  handler.inertia = renderFn;
+  handler.share = (keyOrObject, value) => {
+    if (typeof keyOrObject === "string") {
+      requestSharedProps[keyOrObject] = value;
+    } else if (typeof keyOrObject === "object" && keyOrObject !== null) {
+      Object.assign(requestSharedProps, keyOrObject);
+    }
+    return handler;
+  };
+  handler.getShared = (key) => {
+    if (key) {
+      return requestSharedProps[key] ?? globalSharedProps[key];
+    }
+    return { ...globalSharedProps, ...requestSharedProps };
+  };
+  handler.location = (url) => {
+    if (req.header("X-Inertia")) {
+      res.setHeader("X-Inertia-Location", url);
+      res.status(409).end();
+    } else {
+      res.redirect(url);
+    }
+  };
+  handler.back = (fallbackUrl = "/") => {
+    const referer = req.header("Referer") || fallbackUrl;
+    res.redirect(303, referer);
+  };
+  handler.version = (ver) => {
+    currentVersion = ver;
+    return handler;
+  };
+  handler.rootView = (view) => {
+    currentRootView = view;
+    return handler;
+  };
+  handler.encryptHistory = (encrypt = true) => {
+    historyEncryption = encrypt;
+    return handler;
+  };
+  handler.clearHistory = (clear = true) => {
+    clearHistorySetting = clear;
+    return handler;
+  };
+  handler.withFlash = (key, value) => {
+    flashMessages[key] = value;
+    return handler;
+  };
+  handler.postForm = (component, props, viewData) => {
+    return renderFn(component, props, viewData);
+  };
+  handler.putForm = (component, props, viewData) => {
+    return renderFn(component, props, viewData);
+  };
+  handler.patchForm = (component, props, viewData) => {
+    return renderFn(component, props, viewData);
+  };
+  handler.deleteForm = (component, props, viewData) => {
+    return renderFn(component, props, viewData);
+  };
+  return handler;
+}
+
+// src/middleware.ts
+function createInertia(options = {}) {
+  const globalShared = typeof options.shared === "object" && options.shared !== null ? options.shared : {};
+  return async function inertiaMiddleware(req, res, next) {
+    try {
+      const isInertia = Boolean(req.header("X-Inertia"));
+      const versionHeader = req.header("X-Inertia-Version") || null;
+      const partialComponent = req.header("X-Inertia-Partial-Component") || null;
+      const partialDataHeader = req.header("X-Inertia-Partial-Data");
+      const resetDataHeader = req.header("X-Inertia-Reset");
+      const partialData = partialDataHeader ? partialDataHeader.split(",").map((s) => s.trim()).filter(Boolean) : [];
+      const resetData = resetDataHeader ? resetDataHeader.split(",").map((s) => s.trim()).filter(Boolean) : [];
+      req.inertia = {
+        isInertia,
+        version: versionHeader,
+        partialComponent,
+        partialData,
+        resetData
+      };
+      res.inertia = createInertiaResponse(req, res, options, { ...globalShared });
+      const securityOptions = options.security ?? { validateComponentNames: true };
+      if (securityOptions.validateComponentNames !== false && isInertia) {
+        const pattern = securityOptions.componentNamePattern ?? DEFAULT_COMPONENT_NAME_PATTERN;
+        const partialComponent2 = req.header("X-Inertia-Partial-Component");
+        if (partialComponent2 && !pattern.test(partialComponent2)) {
+          res.setHeader("X-Inertia-Location", req.originalUrl || req.url);
+          res.status(409).end();
+          return;
+        }
+      }
+      if (isInertia && req.method === "GET" && options.version) {
+        let currentVersion = null;
+        if (typeof options.version === "function") {
+          currentVersion = await options.version();
+        } else {
+          currentVersion = options.version;
+        }
+        if (versionHeader && currentVersion && versionHeader !== currentVersion) {
+          res.setHeader("X-Inertia-Location", req.originalUrl || req.url);
+          res.status(409).end();
+          return;
+        }
+      }
+      const originalRedirect = res.redirect.bind(res);
+      res.redirect = function(...args) {
+        const method = req.method.toUpperCase();
+        const isInertiaMethod = method === "PUT" || method === "PATCH" || method === "DELETE";
+        if (isInertia && isInertiaMethod) {
+          if (args.length === 1) {
+            return originalRedirect(303, args[0]);
+          } else if (args.length === 2 && typeof args[0] === "number") {
+            const status = args[0] === 301 || args[0] === 302 ? 303 : args[0];
+            return originalRedirect(status, args[1]);
+          }
+        }
+        return originalRedirect(...args);
+      };
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+function requestIdMiddleware() {
+  return (req, _res, next) => {
+    req.id = req.header("X-Request-ID") || generateRequestId();
+    next();
+  };
+}
+function generateRequestId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${timestamp}-${random}`;
+}
+
+// src/directives.ts
+var customDirectives = {};
+function escapeJsString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function registerDirective(name, handler) {
+  customDirectives[name] = handler;
+}
+function compileBladeDirectives(templateSource, localDirectives) {
+  let compiled = templateSource;
+  compiled = compiled.replace(
+    /<x-inertia(\s[^>]*)?\s*(\/|><\/x-inertia>)/gi,
+    (_match, attrs) => {
+      const idMatch = attrs?.match(/id=(?:"([^"]*)"|'([^']*)')/);
+      const id = idMatch ? idMatch[1] || idMatch[2] : void 0;
+      return id ? `<%- inertia('${escapeJsString(id)}') %>` : `<%- inertia() %>`;
+    }
+  );
+  compiled = compiled.replace(
+    /<x-inertia-(?:script|data)(\s[^>]*)?\s*(\/|><\/x-inertia-(?:script|data)>)/gi,
+    (_match, attrs) => {
+      const idMatch = attrs?.match(/id=(?:"([^"]*)"|'([^']*)')/);
+      const id = idMatch ? idMatch[1] || idMatch[2] : void 0;
+      return id ? `<%- inertiaScript('${escapeJsString(id)}') %>` : `<%- inertiaScript() %>`;
+    }
+  );
+  compiled = compiled.replace(
+    /<x-inertia-head\s*(?:\/>|><\/x-inertia-head>)|<x-inertiaHead\s*(?:\/>|><\/x-inertiaHead>)/gi,
+    "<%- inertiaHead() %>"
+  );
+  compiled = compiled.replace(
+    /<x-vite(\s[^>]*)?\s*(?:\/>|><\/x-vite>)/gi,
+    (_match, attrs) => {
+      const srcMatch = attrs?.match(/(?:src|entries)=(?:"([^"]*)"|'([^']*)')/);
+      const val = srcMatch ? srcMatch[1] || srcMatch[2] : "";
+      if (val.startsWith("[") && val.endsWith("]")) {
+        return `<%- vite(${val}) %>`;
+      }
+      return `<%- vite('${escapeJsString(val)}') %>`;
+    }
+  );
+  compiled = compiled.replace(
+    /<x-vite-react-refresh\s*(?:\/>|><\/x-vite-react-refresh>)|<x-viteReactRefresh\s*(?:\/>|><\/x-viteReactRefresh>)/gi,
+    "<%- viteReactRefresh() %>"
+  );
+  compiled = compiled.replace(/<x-csrf\s*(?:\/>|><\/x-csrf>)/gi, "<%- csrf() %>");
+  compiled = compiled.replace(
+    /<x-routes(\s[^>]*)?\s*(?:\/>|><\/x-routes>)/gi,
+    (_match, attrs) => {
+      const groupMatch = attrs?.match(/group=(?:"([^"]*)"|'([^']*)')/);
+      const group = groupMatch ? groupMatch[1] || groupMatch[2] : void 0;
+      return group ? `<%- routes('${escapeJsString(group)}') %>` : `<%- routes() %>`;
+    }
+  );
+  compiled = compiled.replace(/@inertiaHead\b/g, "<%- inertiaHead() %>");
+  compiled = compiled.replace(/@(inertiaScript|inertiaData)(\([^)]*\))?(?!\w)/g, (_match, _d, args) => {
+    return args ? `<%- inertiaScript${args} %>` : `<%- inertiaScript() %>`;
+  });
+  compiled = compiled.replace(/@inertia(\([^)]*\))?(?!\w)/g, (_match, args) => {
+    return args ? `<%- inertia${args} %>` : `<%- inertia() %>`;
+  });
+  compiled = compiled.replace(/@viteReactRefresh\b/g, "<%- viteReactRefresh() %>");
+  compiled = compiled.replace(/@vite\(([^)]*(?:\([^)]*\)[^)]*)*)\)/g, (_match, args) => {
+    return `<%- vite(${args.trim()}) %>`;
+  });
+  compiled = compiled.replace(/@csrf\b/g, "<%- csrf() %>");
+  compiled = compiled.replace(/@routes(\([^)]*\))?(?!\w)/g, (_match, args) => {
+    return args ? `<%- routes${args} %>` : `<%- routes() %>`;
+  });
+  compiled = compiled.replace(/@json\(([^)]*(?:\([^)]*\)[^)]*)*)\)/g, (_match, args) => {
+    return `<%- json(${args.trim()}) %>`;
+  });
+  const allDirectives = { ...customDirectives, ...localDirectives || {} };
+  for (const [name, handler] of Object.entries(allDirectives)) {
+    const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`@${escapedName}(\\([^)]*(?:\\([^)]*\\)[^)]*)*\\))?(?!\\w)`, "g");
+    compiled = compiled.replace(pattern, (_match, args) => {
+      return handler(args ? args.slice(1, -1).trim() : "", {});
+    });
+  }
+  return compiled;
+}
+function resolveDevServerUrl(config, override) {
+  if (override) return override.replace(/\/$/, "");
+  const server = config?.server || {};
+  if (typeof server.origin === "string" && server.origin) {
+    return server.origin.replace(/\/$/, "");
+  }
+  const scheme = server.https ? "https" : "http";
+  let host = server.host;
+  if (!host || host === "0.0.0.0" || host === "::" || host === "::0" || host === true) {
+    host = "localhost";
+  }
+  if (host.includes(":") && !host.startsWith("[")) {
+    host = `[${host}]`;
+  }
+  const port = server.port ?? 5173;
+  return `${scheme}://${host}:${port}`;
+}
+function inertiaVitePlugin(options = {}) {
+  const logger2 = createLogger({ prefix: "express-inertia:vite" });
+  const write = (config, server) => {
+    try {
+      const hotFile = path.resolve(config.root, options.hotFile || "public/hot");
+      const actual = server?.resolvedUrls?.local?.[0];
+      const url = actual || resolveDevServerUrl(config, options.devServerUrl);
+      fs.mkdirSync(path.dirname(hotFile), { recursive: true });
+      fs.writeFileSync(hotFile, url.replace(/\/$/, ""));
+    } catch (err) {
+      logger2.warn("Failed to write Vite hot file", { error: err.message });
+    }
+  };
+  const remove = (config) => {
+    try {
+      const hotFile = path.resolve(config.root, options.hotFile || "public/hot");
+      fs.rmSync(hotFile, { force: true });
+    } catch {
+    }
+  };
+  return {
+    name: "express-inertia-hot-file",
+    configResolved(config) {
+      if (config.command === "build") {
+        remove(config);
+      } else {
+        write(config);
+      }
+    },
+    configureServer(server) {
+      write(server.config, server);
+      server.httpServer?.once("listening", () => write(server.config, server));
+      server.httpServer?.on("close", () => remove(server.config));
+      process.once("exit", () => remove(server.config));
+    },
+    buildStart() {
+    }
+  };
+}
+var ViteHelper = class {
+  config;
+  manifestCache = null;
+  logger = createLogger({ prefix: "express-inertia:vite" });
+  constructor(config) {
+    const publicDir = config?.publicDir ? path.resolve(config.publicDir) : path.resolve("public");
+    const buildDir = config?.buildDir || "build";
+    this.config = {
+      publicDir,
+      buildDir,
+      devServerUrl: config?.devServerUrl || "http://localhost:5173",
+      hotFile: path.resolve(config?.hotFile || path.join(publicDir, "hot")),
+      manifestPath: path.resolve(
+        config?.manifestPath || path.join(publicDir, buildDir, ".vite", "manifest.json")
+      ),
+      base: config?.base || `/${buildDir}/`,
+      manifest: config?.manifest || null,
+      isDev: config?.isDev ?? false,
+      devServerUrlOverride: config?.devServerUrlOverride || null
+    };
+  }
+  /**
+   * Detect whether the Vite dev server is running.
+   *
+   * Mirrors Laravel: the presence of the `hot` file is the sole signal. Vite's
+   * dev server writes a `hot` file on startup and removes it on shutdown, so no
+   * NODE_ENV switch is required to toggle between dev and build assets.
+   */
+  isDev() {
+    if (this.config.isDev === true) {
+      return true;
+    }
+    const candidatePaths = [
+      this.config.hotFile,
+      path.resolve("hot"),
+      path.join(this.config.publicDir, "hot")
+    ];
+    return candidatePaths.some((p) => fs.existsSync(p));
+  }
+  /**
+   * Get development server URL from hot file or config.
+   */
+  getDevServerUrl() {
+    if (this.config.devServerUrlOverride) {
+      return this.config.devServerUrlOverride.replace(/\/$/, "");
+    }
+    const candidatePaths = [
+      this.config.hotFile,
+      path.resolve("hot"),
+      path.join(this.config.publicDir, "hot")
+    ];
+    for (const p of candidatePaths) {
+      if (fs.existsSync(p)) {
+        try {
+          const content = fs.readFileSync(p, "utf-8").trim();
+          if (content.startsWith("http://") || content.startsWith("https://")) {
+            return content;
+          }
+        } catch {
+        }
+      }
+    }
+    return this.config.devServerUrl;
+  }
+  /**
+   * Check if manifest file exists.
+   */
+  manifestExists() {
+    if (this.config.manifest) {
+      return true;
+    }
+    const candidatePaths = this.getManifestCandidatePaths();
+    return candidatePaths.some((p) => fs.existsSync(p));
+  }
+  getManifestCandidatePaths() {
+    const { publicDir, buildDir } = this.config;
+    return [
+      this.config.manifestPath,
+      path.resolve(publicDir, buildDir, ".vite", "manifest.json"),
+      path.resolve(publicDir, buildDir, "manifest.json"),
+      path.resolve(buildDir, ".vite", "manifest.json"),
+      path.resolve(buildDir, "manifest.json")
+    ];
+  }
+  /**
+   * Load and cache the production manifest.
+   */
+  getManifest() {
+    if (this.manifestCache) {
+      return this.manifestCache;
+    }
+    if (this.config.manifest) {
+      this.manifestCache = this.config.manifest;
+      return this.config.manifest;
+    }
+    const candidatePaths = this.getManifestCandidatePaths();
+    for (const p of candidatePaths) {
+      if (fs.existsSync(p)) {
+        try {
+          const raw = fs.readFileSync(p, "utf-8");
+          const parsed = JSON.parse(raw);
+          this.manifestCache = parsed;
+          return parsed;
+        } catch (err) {
+          throw new Error(`[express-inertia] Failed to parse Vite manifest at ${p}: ${err.message}`);
+        }
+      }
+    }
+    throw new Error(
+      `[express-inertia] Vite manifest not found. Looked in:
+${candidatePaths.join("\n")}
+Run your build step (e.g. vite build) to generate it.`
+    );
+  }
+  /**
+   * Generate HTML script & link tags for the given entrypoint(s).
+   * @param entrypoints Single entry string or array of entry paths (e.g. 'src/main.ts' or ['src/main.ts', 'src/style.css'])
+   */
+  renderTags(entrypoints) {
+    const entries = Array.isArray(entrypoints) ? entrypoints : [entrypoints];
+    const tags = [];
+    if (this.isDev()) {
+      const devUrl = this.getDevServerUrl().replace(/\/$/, "");
+      tags.push(`<script type="module" src="${devUrl}/@vite/client"></script>`);
+      for (const entry of entries) {
+        const cleanEntry = entry.replace(/^\//, "");
+        if (cleanEntry.endsWith(".css") || cleanEntry.endsWith(".scss") || cleanEntry.endsWith(".less")) {
+          tags.push(`<link rel="stylesheet" href="${devUrl}/${cleanEntry}">`);
+        } else {
+          tags.push(`<script type="module" src="${devUrl}/${cleanEntry}"></script>`);
+        }
+      }
+      return tags.join("\n");
+    }
+    const manifest = this.getManifest();
+    const basePath = this.config.base.endsWith("/") ? this.config.base : `${this.config.base}/`;
+    const renderedCss = /* @__PURE__ */ new Set();
+    const renderedPreload = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const cleanEntry = entry.replace(/^\//, "");
+      const chunk = manifest[cleanEntry] || Object.values(manifest).find(
+        (c) => c.src === cleanEntry || c.file === cleanEntry || c.src && (c.src.endsWith(cleanEntry) || c.src.endsWith(`/${cleanEntry}`)) || c.file && (c.file.endsWith(cleanEntry) || c.file.endsWith(`/${cleanEntry}`))
+      );
+      if (!chunk) {
+        if (!/\.(css|scss|sass|less)$/.test(cleanEntry)) {
+          this.logger.warn("Entry not found in Vite manifest", { entry, manifestPath: this.config.manifestPath });
+        }
+        continue;
+      }
+      if (chunk.css) {
+        for (const cssFile of chunk.css) {
+          if (!renderedCss.has(cssFile)) {
+            renderedCss.add(cssFile);
+            tags.push(`<link rel="stylesheet" href="${basePath}${cssFile}">`);
+          }
+        }
+      }
+      if (chunk.file.endsWith(".css")) {
+        if (!renderedCss.has(chunk.file)) {
+          renderedCss.add(chunk.file);
+          tags.push(`<link rel="stylesheet" href="${basePath}${chunk.file}">`);
+        }
+      } else {
+        tags.push(`<script type="module" src="${basePath}${chunk.file}"></script>`);
+      }
+      if (chunk.imports) {
+        for (const imp of chunk.imports) {
+          const impChunk = manifest[imp];
+          if (impChunk && !renderedPreload.has(impChunk.file)) {
+            renderedPreload.add(impChunk.file);
+            tags.push(`<link rel="modulepreload" href="${basePath}${impChunk.file}">`);
+          }
+        }
+      }
+    }
+    return tags.join("\n");
+  }
+  /**
+   * Generates the React Fast Refresh preamble for development.
+   */
+  renderReactRefresh() {
+    if (!this.isDev()) {
+      return "";
+    }
+    const devUrl = this.getDevServerUrl().replace(/\/$/, "");
+    return `<script type="module">
+  import RefreshRuntime from "${devUrl}/@react-refresh";
+  RefreshRuntime.injectIntoGlobalHook(window);
+  window.$RefreshReg$ = () => {};
+  window.$RefreshSig$ = () => (type) => type;
+  window.__vite_plugin_react_preamble_installed__ = true;
+</script>`;
+  }
+  /**
+   * Generates an SRI hash for the given asset file content.
+   * Useful for adding integrity attributes to script/link tags.
+   */
+  async generateSriHashForAsset(assetPath) {
+    const fullPath = path.resolve(this.config.publicDir, assetPath);
+    const content = fs.readFileSync(fullPath);
+    return generateSriHash(content);
+  }
+};
+function createViteHelper(config) {
+  return new ViteHelper(config);
+}
+var defaultViteHelper = new ViteHelper();
+
+// src/engine.ts
+var engineCaches = /* @__PURE__ */ new Set();
+function createInertiaEngine(options) {
+  const viteHelper = options?.vite ? createViteHelper(options.vite) : createViteHelper();
+  const shouldCache = options?.cache ?? !viteHelper.isDev();
+  const inertiaVersion = options?.inertiaVersion ?? 2;
+  const defaultRootElement = options?.rootElement ?? true;
+  const templateCache = /* @__PURE__ */ new Map();
+  engineCaches.add(templateCache);
+  return function inertiaBladeEngine(filePath, rawOptions, callback) {
+    try {
+      let compiledTemplate = shouldCache ? templateCache.get(filePath) : void 0;
+      if (!compiledTemplate) {
+        const templateSource = options?.templateSource || fs.readFileSync(filePath, "utf-8");
+        const compiledSource = options?.compileTemplate ? options.compileTemplate(templateSource) : compileBladeDirectives(templateSource, options?.directives);
+        compiledTemplate = ejs.compile(compiledSource, {
+          filename: filePath,
+          cache: shouldCache,
+          async: false
+        });
+        if (shouldCache) {
+          templateCache.set(filePath, compiledTemplate);
+        }
+      }
+      const locals = { ...rawOptions };
+      const page = locals.page;
+      const ssr = locals.ssr;
+      const effectiveVersion = locals.inertiaVersion ?? inertiaVersion;
+      const shouldRenderRootElement = locals.rootElement ?? defaultRootElement;
+      locals.inertiaScript = (id = "app") => {
+        if (!page) return "";
+        const jsonSafe = JSON.stringify(page).replace(/</g, "\\u003c");
+        return `<script data-page="${id}" type="application/json">${jsonSafe}</script>`;
+      };
+      locals.inertiaData = locals.inertiaScript;
+      locals.inertia = (idOrOptions = "app", version) => {
+        const id = typeof idOrOptions === "string" ? idOrOptions : "app";
+        const renderElement = typeof idOrOptions === "boolean" ? idOrOptions : shouldRenderRootElement !== false;
+        const ver = version ?? effectiveVersion;
+        if (!page) {
+          return renderElement ? `<div id="${id}"></div>` : "";
+        }
+        const ssrBody = ssr && ssr.body ? ssr.body : "";
+        const ssrFullBody = /<div[^>]*data-server-rendered/.test(ssrBody);
+        if (ver === 1) {
+          const pageData = serializePage(page);
+          return renderElement ? `<div id="${id}" data-page="${pageData}">${ssrBody}</div>` : "";
+        }
+        const jsonSafe = JSON.stringify(page).replace(/</g, "\\u003c");
+        const scriptTag = `<script data-page="${id}" type="application/json">${jsonSafe}</script>`;
+        if (ssrFullBody) {
+          return ssrBody;
+        }
+        if (!renderElement) {
+          return scriptTag;
+        }
+        return `<div id="${id}">${ssrBody}</div>
+${scriptTag}`;
+      };
+      locals.inertiaHead = () => {
+        if (ssr && Array.isArray(ssr.head) && ssr.head.length > 0) {
+          return ssr.head.join("\n");
+        }
+        return "";
+      };
+      locals.vite = (entrypoints) => {
+        return viteHelper.renderTags(entrypoints);
+      };
+      locals.viteReactRefresh = () => {
+        return viteHelper.renderReactRefresh();
+      };
+      locals.csrf = () => {
+        const token = locals._csrf || locals.csrfToken || (typeof locals.req?.csrfToken === "function" ? locals.req.csrfToken() : "") || "";
+        return token ? `<input type="hidden" name="_token" value="${token}">` : "";
+      };
+      locals.json = (value) => {
+        return JSON.stringify(value);
+      };
+      if (!locals.routes) {
+        locals.routes = (group) => {
+          if (locals.routeConfig || locals.ziggy) {
+            const routesData = JSON.stringify(locals.routeConfig || locals.ziggy);
+            return `<script>const Ziggy = ${routesData};</script>`;
+          }
+          return "";
+        };
+      }
+      const html = compiledTemplate(locals);
+      callback(null, html);
+    } catch (err) {
+      callback(err);
+    }
+  };
+}
+var inertiaEngine = createInertiaEngine();
+function clearEngineCache() {
+  for (const cache of engineCaches) {
+    cache.clear();
+  }
+}
+
+// src/prefetch.ts
+var PrefetchHelper = class {
+  constructor(viteHelper) {
+    this.viteHelper = viteHelper;
+  }
+  viteHelper;
+  /**
+   * Generates prefetch tags for the given entrypoints.
+   * Uses the Vite manifest to resolve actual asset paths in production.
+   */
+  prefetch(entries, options = {}) {
+    const entrypoints = Array.isArray(entries) ? entries : [entries];
+    const mode = options.mode || "prefetch";
+    const tags = [];
+    if (this.viteHelper.isDev()) {
+      const devUrl = this.viteHelper["getDevServerUrl"]().replace(/\/$/, "");
+      for (const entry of entrypoints) {
+        const cleanEntry = entry.replace(/^\//, "");
+        tags.push(`<link rel="${mode}" href="${devUrl}/${cleanEntry}" crossorigin>`);
+      }
+      return tags.join("\n");
+    }
+    const manifest = this.viteHelper["getManifest"]();
+    const basePath = this.viteHelper["config"].base.endsWith("/") ? this.viteHelper["config"].base : `${this.viteHelper["config"].base}/`;
+    const rendered = /* @__PURE__ */ new Set();
+    for (const entry of entrypoints) {
+      const cleanEntry = entry.replace(/^\//, "");
+      const chunk = this.resolveChunk(manifest, cleanEntry);
+      if (!chunk) continue;
+      const files = [chunk.file, ...chunk.css || [], ...chunk.assets || []].filter(Boolean);
+      for (const file of files) {
+        if (rendered.has(file)) continue;
+        rendered.add(file);
+        const attrs = [`rel="${mode}"`, `href="${basePath}${file}"`];
+        if (options.crossorigin) {
+          attrs.push("crossorigin");
+        }
+        tags.push(`<link ${attrs.join(" ")}>`);
+      }
+      if (chunk.imports) {
+        for (const imp of chunk.imports) {
+          const impChunk = manifest[imp];
+          if (impChunk?.file && !rendered.has(impChunk.file)) {
+            rendered.add(impChunk.file);
+            const attrs = [`rel="${mode}"`, `href="${basePath}${impChunk.file}"`];
+            if (options.crossorigin) {
+              attrs.push("crossorigin");
+            }
+            tags.push(`<link ${attrs.join(" ")}>`);
+          }
+        }
+      }
+    }
+    return tags.join("\n");
+  }
+  /**
+   * Generates preload tags for critical assets.
+   */
+  preload(entries, options = {}) {
+    return this.prefetch(entries, { ...options, mode: "preload" });
+  }
+  resolveChunk(manifest, entry) {
+    return manifest[entry] || Object.values(manifest).find(
+      (c) => c.src === entry || c.file === entry || c.src && (c.src.endsWith(entry) || c.src.endsWith(`/${entry}`)) || c.file && (c.file.endsWith(entry) || c.file.endsWith(`/${entry}`))
+    );
+  }
+};
+function createPrefetchHelper(viteHelper) {
+  return new PrefetchHelper(viteHelper);
+}
+
+// src/index.ts
+var src_default = createInertia;
+
+export { CircuitBreaker, DEFAULT_COMPONENT_NAME_PATTERN, PrefetchHelper, ViteHelper, always, calculateBackoff, clearEngineCache, compileBladeDirectives, createInertia, createInertiaEngine, createLogger, createPrefetchHelper, createViteHelper, src_default as default, defaultViteHelper, defer, escapeHtmlAttr, generateSriHash, getGlobalLogger, createInertia as inertia, inertiaEngine, inertiaVitePlugin, isAlways, isDeferred, isLazy, isMerge, isOptional, lazy, merge, optional, registerDirective, renderSSR, requestIdMiddleware, resetAllCircuitBreakers, resolveProps, safeStringify, sanitizeViewData, serializePage, setGlobalLogger, shouldRetry, validateComponentName };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map