@arponascension/express-inertia 0.1.0

package/dist/index.js

@@ -0,0 +1,1268 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var ejs = require('ejs');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var ejs__default = /*#__PURE__*/_interopDefault(ejs);
+var path__default = /*#__PURE__*/_interopDefault(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__default.default.resolve(config.root, options.hotFile || "public/hot");
+      const actual = server?.resolvedUrls?.local?.[0];
+      const url = actual || resolveDevServerUrl(config, options.devServerUrl);
+      fs__default.default.mkdirSync(path__default.default.dirname(hotFile), { recursive: true });
+      fs__default.default.writeFileSync(hotFile, url.replace(/\/$/, ""));
+    } catch (err) {
+      logger2.warn("Failed to write Vite hot file", { error: err.message });
+    }
+  };
+  const remove = (config) => {
+    try {
+      const hotFile = path__default.default.resolve(config.root, options.hotFile || "public/hot");
+      fs__default.default.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__default.default.resolve(config.publicDir) : path__default.default.resolve("public");
+    const buildDir = config?.buildDir || "build";
+    this.config = {
+      publicDir,
+      buildDir,
+      devServerUrl: config?.devServerUrl || "http://localhost:5173",
+      hotFile: path__default.default.resolve(config?.hotFile || path__default.default.join(publicDir, "hot")),
+      manifestPath: path__default.default.resolve(
+        config?.manifestPath || path__default.default.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__default.default.resolve("hot"),
+      path__default.default.join(this.config.publicDir, "hot")
+    ];
+    return candidatePaths.some((p) => fs__default.default.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__default.default.resolve("hot"),
+      path__default.default.join(this.config.publicDir, "hot")
+    ];
+    for (const p of candidatePaths) {
+      if (fs__default.default.existsSync(p)) {
+        try {
+          const content = fs__default.default.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__default.default.existsSync(p));
+  }
+  getManifestCandidatePaths() {
+    const { publicDir, buildDir } = this.config;
+    return [
+      this.config.manifestPath,
+      path__default.default.resolve(publicDir, buildDir, ".vite", "manifest.json"),
+      path__default.default.resolve(publicDir, buildDir, "manifest.json"),
+      path__default.default.resolve(buildDir, ".vite", "manifest.json"),
+      path__default.default.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__default.default.existsSync(p)) {
+        try {
+          const raw = fs__default.default.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__default.default.resolve(this.config.publicDir, assetPath);
+    const content = fs__default.default.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__default.default.readFileSync(filePath, "utf-8");
+        const compiledSource = options?.compileTemplate ? options.compileTemplate(templateSource) : compileBladeDirectives(templateSource, options?.directives);
+        compiledTemplate = ejs__default.default.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;
+
+exports.CircuitBreaker = CircuitBreaker;
+exports.DEFAULT_COMPONENT_NAME_PATTERN = DEFAULT_COMPONENT_NAME_PATTERN;
+exports.PrefetchHelper = PrefetchHelper;
+exports.ViteHelper = ViteHelper;
+exports.always = always;
+exports.calculateBackoff = calculateBackoff;
+exports.clearEngineCache = clearEngineCache;
+exports.compileBladeDirectives = compileBladeDirectives;
+exports.createInertia = createInertia;
+exports.createInertiaEngine = createInertiaEngine;
+exports.createLogger = createLogger;
+exports.createPrefetchHelper = createPrefetchHelper;
+exports.createViteHelper = createViteHelper;
+exports.default = src_default;
+exports.defaultViteHelper = defaultViteHelper;
+exports.defer = defer;
+exports.escapeHtmlAttr = escapeHtmlAttr;
+exports.generateSriHash = generateSriHash;
+exports.getGlobalLogger = getGlobalLogger;
+exports.inertia = createInertia;
+exports.inertiaEngine = inertiaEngine;
+exports.inertiaVitePlugin = inertiaVitePlugin;
+exports.isAlways = isAlways;
+exports.isDeferred = isDeferred;
+exports.isLazy = isLazy;
+exports.isMerge = isMerge;
+exports.isOptional = isOptional;
+exports.lazy = lazy;
+exports.merge = merge;
+exports.optional = optional;
+exports.registerDirective = registerDirective;
+exports.renderSSR = renderSSR;
+exports.requestIdMiddleware = requestIdMiddleware;
+exports.resetAllCircuitBreakers = resetAllCircuitBreakers;
+exports.resolveProps = resolveProps;
+exports.safeStringify = safeStringify;
+exports.sanitizeViewData = sanitizeViewData;
+exports.serializePage = serializePage;
+exports.setGlobalLogger = setGlobalLogger;
+exports.shouldRetry = shouldRetry;
+exports.validateComponentName = validateComponentName;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map