@adonisjs/inertia 4.0.0-next.0 → 4.0.0-next.10

package/build/chunk-YQ72YL64.js

@@ -0,0 +1,813 @@
+import {
+  debug_default
+} from "./chunk-4EZ2J6OA.js";
+import {
+  InertiaHeaders
+} from "./chunk-DISC5OYC.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  ALWAYS_PROP: () => ALWAYS_PROP,
+  DEEP_MERGE: () => DEEP_MERGE,
+  DEFERRED_PROP: () => DEFERRED_PROP,
+  OPTIONAL_PROP: () => OPTIONAL_PROP,
+  TO_BE_MERGED: () => TO_BE_MERGED
+});
+var ALWAYS_PROP = Symbol.for("ALWAYS_PROP");
+var OPTIONAL_PROP = Symbol.for("OPTIONAL_PROP");
+var TO_BE_MERGED = Symbol.for("TO_BE_MERGED");
+var DEFERRED_PROP = Symbol.for("DEFERRED_PROP");
+var DEEP_MERGE = Symbol.for("DEEP_MERGE");
+
+// src/inertia.ts
+import { createHash } from "crypto";
+
+// src/props.ts
+import { serialize } from "@adonisjs/core/transformers";
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function defer(fn, group = "default") {
+  return {
+    group,
+    compute: fn,
+    merge() {
+      return merge(this);
+    },
+    [DEFERRED_PROP]: true
+  };
+}
+function optional(fn) {
+  return {
+    compute: fn,
+    [OPTIONAL_PROP]: true
+  };
+}
+function always(value) {
+  return {
+    value,
+    [ALWAYS_PROP]: true
+  };
+}
+function merge(value) {
+  return {
+    value,
+    [TO_BE_MERGED]: true,
+    [DEEP_MERGE]: false
+  };
+}
+function deepMerge(value) {
+  return {
+    value,
+    [TO_BE_MERGED]: true,
+    [DEEP_MERGE]: true
+  };
+}
+function isDeferredProp(propValue) {
+  return DEFERRED_PROP in propValue;
+}
+function isMergeableProp(propValue) {
+  return TO_BE_MERGED in propValue;
+}
+function isAlwaysProp(propValue) {
+  return ALWAYS_PROP in propValue;
+}
+function isOptionalProp(propValue) {
+  return OPTIONAL_PROP in propValue;
+}
+async function unpackPropValue(value, containerResolver) {
+  return serialize(value, containerResolver);
+}
+async function buildStandardVisitProps(pageProps, containerResolver) {
+  const mergeProps = [];
+  const deepMergeProps = [];
+  const newProps = {};
+  const deferredProps = {};
+  const unpackedValues = [];
+  for (const [key, value] of Object.entries(pageProps)) {
+    if (isObject(value)) {
+      if (isDeferredProp(value)) {
+        deferredProps[value.group] = deferredProps[value.group] ?? [];
+        deferredProps[value.group].push(key);
+        continue;
+      }
+      if (isOptionalProp(value)) {
+        continue;
+      }
+      if (isAlwaysProp(value)) {
+        unpackedValues.push({ key, value: value.value });
+        continue;
+      }
+      if (isMergeableProp(value)) {
+        if (value[DEEP_MERGE]) {
+          deepMergeProps.push(key);
+        } else {
+          mergeProps.push(key);
+        }
+        if (isObject(value.value) && isDeferredProp(value.value)) {
+          deferredProps[value.value.group] = deferredProps[value.value.group] ?? [];
+          deferredProps[value.value.group].push(key);
+          unpackedValues.push({
+            key,
+            value: value.value.compute
+          });
+        } else {
+          unpackedValues.push({
+            key,
+            value: value.value
+          });
+        }
+        continue;
+      }
+      unpackedValues.push({
+        key,
+        value
+      });
+    } else {
+      if (typeof value === "function") {
+        unpackedValues.push({
+          key,
+          value
+        });
+        continue;
+      }
+      newProps[key] = value;
+    }
+  }
+  await Promise.all(
+    unpackedValues.map(async ({ key, value }) => {
+      if (typeof value === "function") {
+        return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+          newProps[key] = jsonValue;
+        });
+      } else {
+        return unpackPropValue(value, containerResolver).then((jsonValue) => {
+          newProps[key] = jsonValue;
+        });
+      }
+    })
+  );
+  return {
+    props: newProps,
+    mergeProps,
+    deepMergeProps,
+    deferredProps
+  };
+}
+async function buildPartialRequestProps(pageProps, cherryPickProps, containerResolver) {
+  const mergeProps = [];
+  const deepMergeProps = [];
+  const newProps = {};
+  const unpackedValues = [];
+  for (const [key, value] of Object.entries(pageProps)) {
+    if (isObject(value)) {
+      if (isAlwaysProp(value)) {
+        unpackedValues.push({ key, value: value.value });
+        continue;
+      }
+      if (!cherryPickProps.includes(key)) {
+        continue;
+      }
+      if (isDeferredProp(value)) {
+        unpackedValues.push({ key, value: value.compute });
+        continue;
+      }
+      if (isOptionalProp(value)) {
+        unpackedValues.push({ key, value: value.compute });
+        continue;
+      }
+      if (isMergeableProp(value)) {
+        if (value[DEEP_MERGE]) {
+          deepMergeProps.push(key);
+        } else {
+          mergeProps.push(key);
+        }
+        if (isObject(value.value) && isDeferredProp(value.value)) {
+          unpackedValues.push({ key, value: value.value.compute });
+        } else {
+          unpackedValues.push({ key, value: value.value });
+        }
+        continue;
+      }
+      unpackedValues.push({ key, value });
+    } else {
+      if (!cherryPickProps.includes(key)) {
+        continue;
+      }
+      if (typeof value === "function") {
+        unpackedValues.push({ key, value });
+        continue;
+      }
+      newProps[key] = value;
+    }
+  }
+  await Promise.all(
+    unpackedValues.map(async ({ key, value }) => {
+      if (typeof value === "function") {
+        return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+          newProps[key] = jsonValue;
+        });
+      } else {
+        return unpackPropValue(value, containerResolver).then((jsonValue) => {
+          newProps[key] = jsonValue;
+        });
+      }
+    })
+  );
+  return {
+    props: newProps,
+    mergeProps,
+    deepMergeProps,
+    deferredProps: {}
+  };
+}
+
+// src/inertia.ts
+var Inertia = class {
+  /**
+   * Creates a new Inertia instance
+   *
+   * @param ctx - HTTP context for the current request
+   * @param config - Inertia configuration object
+   * @param vite - Vite instance for asset management
+   * @param serverRenderer - Optional server renderer for SSR
+   *
+   * @example
+   * ```js
+   * const inertia = new Inertia(ctx, {
+   *   rootView: 'app',
+   *   ssr: { enabled: true }
+   * }, vite, serverRenderer)
+   * ```
+   */
+  constructor(ctx, config, vite, serverRenderer) {
+    this.ctx = ctx;
+    this.config = config;
+    if (debug_default.enabled) {
+      debug_default(
+        'instantiating inertia instance for request "%s" using config %O',
+        ctx.request.url(),
+        this.config
+      );
+    }
+    this.#shouldClearHistory = false;
+    this.#vite = vite;
+    this.#serverRenderer = serverRenderer;
+    this.#shouldEncryptHistory = config.encryptHistory ?? false;
+    this.#cachedVersion = this.config.assetsVersion ? String(this.config.assetsVersion) : void 0;
+  }
+  #sharedStateProviders;
+  #cachedRequestInfo;
+  /**
+   * Optional server-side renderer for SSR functionality
+   */
+  #serverRenderer;
+  /**
+   * Vite instance for asset management and manifest handling
+   */
+  #vite;
+  /**
+   * Flag to control whether the next navigation should clear browser history
+   */
+  #shouldClearHistory;
+  /**
+   * Flag to control whether browser history should be encrypted
+   */
+  #shouldEncryptHistory;
+  /**
+   * Cached version string/number for asset versioning
+   */
+  #cachedVersion;
+  /**
+   * Defer prop evaluation until client-side rendering
+   *
+   * @example
+   * ```js
+   * {
+   *   expensiveData: inertia.defer(() => computeExpensiveData())
+   * }
+   * ```
+   */
+  defer = defer;
+  /**
+   * Always include prop in both server and client renders
+   *
+   * @example
+   * ```js
+   * {
+   *   currentUser: inertia.always(() => getCurrentUser())
+   * }
+   * ```
+   */
+  always = always;
+  /**
+   * Merge prop with existing client-side data
+   *
+   * @example
+   * ```js
+   * {
+   *   posts: inertia.merge(() => getPosts())
+   * }
+   * ```
+   */
+  merge = merge;
+  /**
+   * Include prop only when specifically requested
+   *
+   * @example
+   * ```js
+   * {
+   *   optionalData: inertia.optional(() => getOptionalData())
+   * }
+   * ```
+   */
+  optional = optional;
+  /**
+   * Deep merge prop with existing client-side data
+   *
+   * @example
+   * ```js
+   * {
+   *   settings: inertia.deepMerge(() => getSettings())
+   * }
+   * ```
+   */
+  deepMerge = deepMerge;
+  /**
+   * Resolve the root view template
+   *
+   * Handles both static strings and dynamic functions for the root view.
+   *
+   * @example
+   * ```js
+   * const viewName = this.#resolveRootView()
+   * this.ctx.view.render(viewName, { page: pageObject })
+   * ```
+   */
+  #resolveRootView() {
+    return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
+  }
+  /**
+   * Constructs and serializes the page props for a given component
+   *
+   * Handles both full page loads and partial requests with prop filtering.
+   * Merges shared state providers with page-specific props, and handles
+   * prop cherry-picking for partial reloads based on the `only` and `except` parameters.
+   *
+   * @param component - The component name being rendered
+   * @param requestInfo - Information about the current request
+   * @param pageProps - Raw page props to be processed
+   *
+   * @example
+   * ```js
+   * const result = await this.#buildPageProps('Dashboard', requestInfo, {
+   *   user: { name: 'John' },
+   *   posts: defer(() => getPosts())
+   * })
+   * ```
+   */
+  async #buildPageProps(component, requestInfo, pageProps) {
+    let finalProps;
+    if (this.#sharedStateProviders) {
+      const sharedState = await Promise.all(
+        this.#sharedStateProviders.map((provider) => {
+          return typeof provider === "function" ? provider() : provider;
+        })
+      ).then((resolvedSharedState) => {
+        return resolvedSharedState.reduce((result, state) => {
+          return { ...result, ...state };
+        }, {});
+      });
+      finalProps = { ...sharedState, ...pageProps };
+    } else {
+      finalProps = { ...pageProps };
+    }
+    if (requestInfo.partialComponent === component) {
+      const only = requestInfo.onlyProps;
+      const except = requestInfo.exceptProps ?? [];
+      const cherryPickProps = Object.keys(finalProps).filter((propName) => {
+        if (only) {
+          return only.includes(propName) && !except.includes(propName);
+        }
+        return !except.includes(propName);
+      });
+      debug_default("building props for a partial reload %O", requestInfo);
+      debug_default("cherry picking props %s", cherryPickProps);
+      return buildPartialRequestProps(finalProps, cherryPickProps, this.ctx.containerResolver);
+    }
+    debug_default("building props for a standard visit %O", requestInfo);
+    return buildStandardVisitProps(finalProps, this.ctx.containerResolver);
+  }
+  /**
+   * Handle Inertia AJAX request by setting appropriate headers
+   *
+   * Sets the `X-Inertia` header to 'true' indicating this is an Inertia response,
+   * then returns the page object which will be serialized as JSON.
+   *
+   * @param pageObject - The page object to return
+   *
+   * @example
+   * ```js
+   * const pageObj = await this.page('Dashboard', props)
+   * return this.#handleInertiaRequest(pageObj)
+   * ```
+   */
+  #handleInertiaRequest(pageObject) {
+    this.ctx.response.header(InertiaHeaders.Inertia, "true");
+    return pageObject;
+  }
+  /**
+   * Render page with server-side rendering
+   *
+   * @param pageObject - The page object to render
+   * @param viewProps - Additional props to pass to the root view template
+   * @returns Promise resolving to the rendered HTML string
+   */
+  async #renderWithSSR(pageObject, viewProps) {
+    if (!this.#serverRenderer) {
+      throw new Error("Cannot server render pages without a server renderer");
+    }
+    debug_default("server-side rendering %O", pageObject);
+    const { head, body } = await this.#serverRenderer.render(pageObject);
+    return this.ctx.view.render(this.#resolveRootView(), {
+      page: { ssrHead: head, ssrBody: body, ...pageObject },
+      ...viewProps
+    });
+  }
+  /**
+   * Render page with client-side rendering only
+   *
+   * @param pageObject - The page object to render
+   * @param viewProps - Additional props to pass to the root view template
+   * @returns Promise resolving to the rendered HTML string
+   */
+  async #renderClientSide(pageObject, viewProps) {
+    debug_default("rendering shell for SPA %O", pageObject);
+    return this.ctx.view.render(this.#resolveRootView(), { page: pageObject, ...viewProps });
+  }
+  /**
+   * Extract Inertia-specific information from request headers
+   *
+   * Parses various Inertia headers to determine request type and props filtering.
+   *
+   * @param reCompute - Whether to recompute the request info instead of using cached version
+   * @returns The request information object containing Inertia-specific data
+   *
+   * @example
+   * ```js
+   * const info = inertia.requestInfo()
+   * if (info.isInertiaRequest) {
+   *   // Handle as Inertia request
+   * }
+   * ```
+   */
+  requestInfo(reCompute) {
+    if (reCompute) {
+      this.#cachedRequestInfo = void 0;
+    }
+    this.#cachedRequestInfo = this.#cachedRequestInfo ?? {
+      version: this.ctx.request.header(InertiaHeaders.Version),
+      isInertiaRequest: !!this.ctx.request.header(InertiaHeaders.Inertia),
+      isPartialRequest: !!this.ctx.request.header(InertiaHeaders.PartialComponent),
+      partialComponent: this.ctx.request.header(InertiaHeaders.PartialComponent),
+      onlyProps: this.ctx.request.header(InertiaHeaders.PartialOnly)?.split(","),
+      exceptProps: this.ctx.request.header(InertiaHeaders.PartialExcept)?.split(","),
+      resetProps: this.ctx.request.header(InertiaHeaders.Reset)?.split(","),
+      errorBag: this.ctx.request.header(InertiaHeaders.ErrorBag)
+    };
+    return this.#cachedRequestInfo;
+  }
+  /**
+   * Compute and cache the assets version
+   *
+   * Uses Vite manifest hash when available, otherwise defaults to '1'.
+   *
+   * @returns The computed version string for asset versioning
+   */
+  getVersion() {
+    if (this.#cachedVersion) {
+      return this.#cachedVersion;
+    }
+    if (this.#vite?.hasManifestFile) {
+      this.#cachedVersion = createHash("md5").update(JSON.stringify(this.#vite.manifest())).digest("hex");
+    } else {
+      this.#cachedVersion = "1";
+    }
+    return this.#cachedVersion;
+  }
+  /**
+   * Determine if server-side rendering is enabled for a specific component
+   *
+   * Checks global SSR settings and component-specific configuration.
+   *
+   * @param component - The component name to check
+   * @returns Promise resolving to true if SSR is enabled for the component
+   *
+   * @example
+   * ```js
+   * const shouldSSR = await inertia.ssrEnabled('UserProfile')
+   * if (shouldSSR) {
+   *   // Render on server
+   * }
+   * ```
+   */
+  async ssrEnabled(component) {
+    if (!this.config.ssr.enabled) {
+      return false;
+    }
+    if (typeof this.config.ssr.pages === "function") {
+      return this.config.ssr.pages(this.ctx, component);
+    }
+    if (this.config.ssr.pages) {
+      return this.config.ssr.pages?.includes(component);
+    }
+    return true;
+  }
+  /**
+   * Share props across all pages
+   *
+   * Merges the provided props with existing shared state, making them available
+   * to all pages rendered by this Inertia instance. Shared props are included
+   * in every page render alongside page-specific props.
+   *
+   * @param sharedState - Props to share across all pages
+   * @returns The Inertia instance for method chaining
+   *
+   * @example
+   * ```js
+   * // Share user data across all pages
+   * inertia.share({
+   *   user: getCurrentUser(),
+   *   flash: getFlashMessages()
+   * })
+   *
+   * // Chain multiple shares
+   * inertia
+   *   .share({ currentUser: user })
+   *   .share({ permissions: userPermissions })
+   * ```
+   */
+  share(sharedState) {
+    if (!this.#sharedStateProviders) {
+      this.#sharedStateProviders = [];
+    }
+    this.#sharedStateProviders.push(sharedState);
+    return this;
+  }
+  /**
+   * Build a page object with processed props and metadata
+   *
+   * Creates the complete page object that will be sent to the client or used for SSR.
+   *
+   * @param page - The page component name
+   * @param pageProps - Props to pass to the page component
+   * @returns Promise resolving to the complete page object
+   *
+   * @example
+   * ```js
+   * const pageObject = await inertia.page('Dashboard', {
+   *   user: { name: 'John' },
+   *   posts: defer(() => getPosts())
+   * })
+   * ```
+   */
+  async page(page, pageProps) {
+    const requestInfo = this.requestInfo();
+    const { props, mergeProps, deferredProps, deepMergeProps } = await this.#buildPageProps(
+      page,
+      requestInfo,
+      pageProps
+    );
+    return {
+      component: page,
+      url: this.ctx.request.url(true),
+      version: this.getVersion(),
+      clearHistory: this.#shouldClearHistory,
+      encryptHistory: this.#shouldEncryptHistory,
+      props,
+      deferredProps,
+      mergeProps,
+      deepMergeProps
+    };
+  }
+  /**
+   * Render a page using Inertia
+   *
+   * This method handles three distinct rendering scenarios:
+   * 1. Inertia requests - Returns JSON page object for client-side navigation
+   * 2. Initial page loads with SSR - Returns HTML with server-rendered content
+   * 3. Initial page loads without SSR - Returns HTML for client-side hydration
+   *
+   * @param page - The page component name to render
+   * @param pageProps - Props to pass to the page component
+   * @param viewProps - Additional props to pass to the root view template
+   * @returns Promise resolving to PageObject for Inertia requests, HTML string for initial page loads
+   *
+   * @example
+   * ```js
+   * // For Inertia requests, returns PageObject
+   * const result = await inertia.render('Profile', {
+   *   user: getCurrentUser(),
+   *   posts: defer(() => getUserPosts())
+   * })
+   *
+   * // For initial page loads, returns HTML string
+   * const html = await inertia.render('Home', { welcome: 'Hello World' })
+   * ```
+   */
+  async render(page, pageProps, viewProps) {
+    const requestInfo = this.requestInfo();
+    const pageObject = await this.page(page, pageProps);
+    const isInertiaRequest = requestInfo.isInertiaRequest;
+    if (isInertiaRequest) {
+      return this.#handleInertiaRequest(pageObject);
+    }
+    const shouldUseSSR = await this.ssrEnabled(page);
+    if (shouldUseSSR) {
+      return this.#renderWithSSR(pageObject, viewProps);
+    }
+    return this.#renderClientSide(pageObject, viewProps);
+  }
+  /**
+   * Clear the browser history on the next navigation
+   *
+   * Instructs the client to clear the browser history stack when navigating.
+   *
+   * @example
+   * ```js
+   * inertia.clearHistory()
+   * return inertia.render('Dashboard', props)
+   * ```
+   */
+  clearHistory() {
+    this.#shouldClearHistory = true;
+  }
+  /**
+   * Control whether browser history should be encrypted
+   *
+   * Enables or disables encryption of sensitive data in browser history.
+   *
+   * @param encrypt - Whether to encrypt history (defaults to true)
+   *
+   * @example
+   * ```js
+   * // Enable encryption for sensitive pages
+   * inertia.encryptHistory(true)
+   *
+   * // Disable encryption for public pages
+   * inertia.encryptHistory(false)
+   * ```
+   */
+  encryptHistory(encrypt = true) {
+    this.#shouldEncryptHistory = encrypt;
+  }
+  /**
+   * Redirect to a different location
+   *
+   * Sets the appropriate headers to redirect the client to a new URL.
+   * Uses a 409 status code which Inertia.js interprets as a redirect instruction.
+   *
+   * @param url - The URL to redirect to
+   *
+   * @example
+   * ```js
+   * // Redirect after login
+   * inertia.location('/dashboard')
+   *
+   * // Redirect with full URL
+   * inertia.location('https://example.com/external')
+   * ```
+   */
+  location(url) {
+    this.ctx.response.header(InertiaHeaders.Location, url);
+    this.ctx.response.status(409);
+  }
+};
+
+// src/server_renderer.ts
+import { pathToFileURL } from "url";
+var ServerRenderer = class {
+  /**
+   * Shared module runner instance for Vite's runtime API.
+   * Used in development mode to execute SSR entry points.
+   */
+  #runtime;
+  /**
+   * Inertia configuration object containing SSR settings
+   */
+  #config;
+  /**
+   * Vite instance for development mode rendering and asset management
+   */
+  #vite;
+  /**
+   * Creates a new ServerRenderer instance.
+   *
+   * @param config - Inertia configuration object containing SSR settings
+   * @param vite - Vite instance for development mode rendering and asset management
+   *
+   * @example
+   * ```js
+   * const renderer = new ServerRenderer(config, vite)
+   * ```
+   */
+  constructor(config, vite) {
+    this.#config = config;
+    this.#vite = vite;
+  }
+  /**
+   * Renders an Inertia page on the server.
+   *
+   * In development mode, uses Vite's Runtime API to execute the SSR entrypoint.
+   * In production mode, imports and uses the pre-built SSR bundle.
+   *
+   * @param pageObject - The Inertia page object containing component, props, and metadata
+   * @returns Promise resolving to an object with rendered head and body HTML
+   *
+   * @example
+   * ```js
+   * const pageObject = {
+   *   component: 'Home',
+   *   props: { user: { name: 'John' } },
+   *   url: '/dashboard',
+   *   version: '1.0.0'
+   * }
+   *
+   * const { head, body } = await renderer.render(pageObject)
+   * ```
+   */
+  async render(pageObject) {
+    let render;
+    const devServer = this.#vite.getDevServer();
+    if (devServer) {
+      debug_default("creating SSR bundle using dev-server");
+      this.#runtime ??= await this.#vite.createModuleRunner();
+      this.#runtime.clearCache();
+      render = await this.#runtime.import(this.#config.ssr.entrypoint);
+    } else {
+      debug_default("creating SSR bundle using production build");
+      render = await import(pathToFileURL(this.#config.ssr.bundle).href);
+    }
+    const result = await render.default(pageObject);
+    debug_default("SSR bundle %o", result);
+    return { head: result.head, body: result.body };
+  }
+};
+
+// src/inertia_manager.ts
+var InertiaManager = class {
+  /**
+   * Optional Vite instance for asset management
+   */
+  #vite;
+  /**
+   * Inertia configuration object
+   */
+  #config;
+  #serverRenderer;
+  /**
+   * Creates a new InertiaManager instance
+   *
+   * @param config - Inertia configuration object
+   * @param vite - Optional Vite instance for development mode and SSR
+   *
+   * @example
+   * ```js
+   * const manager = new InertiaManager({
+   *   rootView: 'app',
+   *   ssr: { enabled: true }
+   * }, vite)
+   * ```
+   */
+  constructor(config, vite) {
+    this.#config = config;
+    this.#vite = vite;
+    this.#serverRenderer = this.#vite ? new ServerRenderer(this.#config, this.#vite) : void 0;
+  }
+  /**
+   * Creates a new Inertia instance for a specific HTTP request
+   *
+   * @param ctx - HTTP context for the current request
+   * @returns A new Inertia instance configured for the given request
+   *
+   * @example
+   * ```js
+   * const inertia = manager.createForRequest(ctx)
+   * await inertia.render('Home', { user: ctx.auth.user })
+   * ```
+   */
+  createForRequest(ctx) {
+    return new Inertia(ctx, this.#config, this.#vite, this.#serverRenderer);
+  }
+};
+
+export {
+  symbols_exports,
+  Inertia,
+  ServerRenderer,
+  InertiaManager
+};