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

package/build/inertia_manager-Di3J3hSG.js

@@ -0,0 +1,403 @@
+import { t as InertiaHeaders } from "./headers-DafWEpBh.js";
+import { t as debug_default } from "./debug-CBMTuPUm.js";
+import "node:module";
+import { createHash } from "node:crypto";
+import { serialize } from "@adonisjs/core/transformers";
+import { pathToFileURL } from "node:url";
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var symbols_exports = /* @__PURE__ */ __export({
+	ALWAYS_PROP: () => ALWAYS_PROP,
+	DEEP_MERGE: () => DEEP_MERGE,
+	DEFERRED_PROP: () => DEFERRED_PROP,
+	OPTIONAL_PROP: () => OPTIONAL_PROP,
+	TO_BE_MERGED: () => TO_BE_MERGED
+});
+const ALWAYS_PROP = Symbol.for("ALWAYS_PROP");
+const OPTIONAL_PROP = Symbol.for("OPTIONAL_PROP");
+const TO_BE_MERGED = Symbol.for("TO_BE_MERGED");
+const DEFERRED_PROP = Symbol.for("DEFERRED_PROP");
+const DEEP_MERGE = Symbol.for("DEEP_MERGE");
+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: {}
+	};
+}
+var Inertia = class {
+	#sharedStateProviders;
+	#cachedRequestInfo;
+	#serverRenderer;
+	#vite;
+	#shouldClearHistory;
+	#shouldEncryptHistory;
+	#cachedVersion;
+	defer = defer;
+	always = always;
+	merge = merge;
+	optional = optional;
+	deepMerge = deepMerge;
+	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;
+	}
+	#resolveRootView() {
+		return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
+	}
+	async #buildPageProps(component, requestInfo, pageProps) {
+		let finalProps;
+		if (this.#sharedStateProviders) finalProps = {
+			...await Promise.all(this.#sharedStateProviders.map((provider) => {
+				return typeof provider === "function" ? provider() : provider;
+			})).then((resolvedSharedState) => {
+				return resolvedSharedState.reduce((result, state) => {
+					return {
+						...result,
+						...state
+					};
+				}, {});
+			}),
+			...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);
+	}
+	#handleInertiaRequest(pageObject) {
+		this.ctx.response.header(InertiaHeaders.Inertia, "true");
+		return pageObject;
+	}
+	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
+		});
+	}
+	async #renderClientSide(pageObject, viewProps) {
+		debug_default("rendering shell for SPA %O", pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: pageObject,
+			...viewProps
+		});
+	}
+	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;
+	}
+	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;
+	}
+	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(sharedState) {
+		if (!this.#sharedStateProviders) this.#sharedStateProviders = [];
+		this.#sharedStateProviders.push(sharedState);
+		return this;
+	}
+	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
+		};
+	}
+	async render(page, pageProps, viewProps) {
+		const requestInfo = this.requestInfo();
+		const pageObject = await this.page(page, pageProps);
+		if (requestInfo.isInertiaRequest) return this.#handleInertiaRequest(pageObject);
+		if (await this.ssrEnabled(page)) return this.#renderWithSSR(pageObject, viewProps);
+		return this.#renderClientSide(pageObject, viewProps);
+	}
+	clearHistory() {
+		this.#shouldClearHistory = true;
+	}
+	encryptHistory(encrypt = true) {
+		this.#shouldEncryptHistory = encrypt;
+	}
+	location(url) {
+		this.ctx.response.header(InertiaHeaders.Location, url);
+		this.ctx.response.status(409);
+	}
+};
+var ServerRenderer = class {
+	#runtime;
+	#config;
+	#vite;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+	}
+	async render(pageObject) {
+		let render;
+		if (this.#vite.getDevServer()) {
+			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
+		};
+	}
+};
+var InertiaManager = class {
+	#vite;
+	#config;
+	#serverRenderer;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+		this.#serverRenderer = this.#vite ? new ServerRenderer(this.#config, this.#vite) : void 0;
+	}
+	createForRequest(ctx) {
+		return new Inertia(ctx, this.#config, this.#vite, this.#serverRenderer);
+	}
+};
+export { symbols_exports as i, ServerRenderer as n, Inertia as r, InertiaManager as t };

package/build/providers/inertia_provider.js

@@ -1,82 +1,28 @@
-import {
-  InertiaManager
-} from "../chunk-YQ72YL64.js";
-import "../chunk-4EZ2J6OA.js";
-import "../chunk-DISC5OYC.js";
-import "../chunk-MLKGABMK.js";
-
-// providers/inertia_provider.ts
+import { t as InertiaManager } from "../inertia_manager-Di3J3hSG.js";
+import "../headers-DafWEpBh.js";
+import "../debug-CBMTuPUm.js";
 import { BriskRoute } from "@adonisjs/core/http";
 var InertiaProvider = class {
-  /**
-   * Creates a new InertiaProvider instance
-   *
-   * @param app - The AdonisJS application service instance
-   */
-  constructor(app) {
-    this.app = app;
-  }
-  /**
-   * Registers the Inertia Edge.js plugin when Edge.js is available
-   *
-   * This method conditionally registers the Edge plugin that provides
-   * @inertia and @inertiaHead tags for rendering Inertia pages.
-   *
-   * @example
-   * ```edge
-   * {{-- Templates can then use --}}
-   * @inertia(page)
-   * @inertiaHead(page)
-   * ```
-   */
-  async registerEdgePlugin() {
-    const edgeExports = await import("edge.js");
-    const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
-    edgeExports.default.use(edgePluginInertia());
-  }
-  /**
-   * Registers the InertiaManager as a singleton in the IoC container
-   *
-   * This method sets up the core Inertia manager with the application's
-   * configuration and Vite integration. The manager handles page rendering,
-   * asset management, and SSR functionality.
-   *
-   * @example
-   * ```js
-   * // The manager is automatically available for injection:
-   * const inertiaManager = await app.container.make(InertiaManager)
-   * ```
-   */
-  async register() {
-    this.app.container.singleton(InertiaManager, async (resolver) => {
-      const config = this.app.config.get("inertia", {});
-      const vite = await resolver.make("vite");
-      return new InertiaManager(config, vite);
-    });
-  }
-  /**
-   * Boot the provider by registering Edge plugin and route macros
-   *
-   * This method completes the Inertia setup by registering the Edge plugin
-   * and adding the renderInertia macro to BriskRoute for convenient route definitions.
-   *
-   * @example
-   * ```js
-   * // Routes can now use the renderInertia macro
-   * router.get('/dashboard', []).renderInertia('Dashboard', {
-   *   user: getCurrentUser()
-   * })
-   * ```
-   */
-  async boot() {
-    await this.registerEdgePlugin();
-    BriskRoute.macro("renderInertia", function(template, props, viewProps) {
-      return this.setHandler(({ inertia }) => {
-        return inertia.render(template, props, viewProps);
-      });
-    });
-  }
-};
-export {
-  InertiaProvider as default
+	constructor(app) {
+		this.app = app;
+	}
+	async registerEdgePlugin() {
+		const edgeExports = await import("edge.js");
+		const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
+		edgeExports.default.use(edgePluginInertia());
+	}
+	async register() {
+		this.app.container.singleton(InertiaManager, async (resolver) => {
+			return new InertiaManager(this.app.config.get("inertia", {}), await resolver.make("vite"));
+		});
+	}
+	async boot() {
+		await this.registerEdgePlugin();
+		BriskRoute.macro("renderInertia", function(template, props, viewProps) {
+			return this.setHandler(({ inertia }) => {
+				return inertia.render(template, props, viewProps);
+			});
+		});
+	}
 };
+export { InertiaProvider as default };

package/build/src/client/helpers.js

@@ -1,30 +1,13 @@
-import "../../chunk-MLKGABMK.js";
-
-// src/client/helpers.ts
 async function resolvePageComponent(path, pages, layout) {
-  for (const p of Array.isArray(path) ? path : [path]) {
-    const page = pages[p];
-    if (typeof page === "undefined") {
-      continue;
-    }
-    const resolvedPage = await (typeof page === "function" ? page() : page);
-    if (!resolvedPage) {
-      throw new Error(
-        `Invalid page exported from "${path}". Make sure to default export a function`
-      );
-    }
-    if ("default" in resolvedPage === false) {
-      throw new Error(
-        `Invalid page exported from "${path}". Make sure to default export a function`
-      );
-    }
-    if (layout && !resolvedPage.default.layout) {
-      resolvedPage.default.layout = layout;
-    }
-    return resolvedPage;
-  }
-  throw new Error(`Page not found: "${path}"`);
+	for (const p of Array.isArray(path) ? path : [path]) {
+		const page = pages[p];
+		if (typeof page === "undefined") continue;
+		const resolvedPage = await (typeof page === "function" ? page() : page);
+		if (!resolvedPage) throw new Error(`Invalid page exported from "${path}". Make sure to default export a function`);
+		if ("default" in resolvedPage === false) throw new Error(`Invalid page exported from "${path}". Make sure to default export a function`);
+		if (layout && !resolvedPage.default.layout) resolvedPage.default.layout = layout;
+		return resolvedPage;
+	}
+	throw new Error(`Page not found: "${path}"`);
 }
-export {
-  resolvePageComponent
-};
+export { resolvePageComponent };

package/build/src/client/react/context.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { Tuyau } from '@tuyau/core/client';
-import type { AdonisRegistry } from '@tuyau/core/types';
+import type { TuyauRegistry } from '@tuyau/core/types';
 /**
  * Provider component that makes the Tuyau client available to child components.
  *
@@ -8,7 +8,7 @@ import type { AdonisRegistry } from '@tuyau/core/types';
  * application that needs access to type-safe routing functionality.
  *
  */
-export declare function TuyauProvider<R extends AdonisRegistry>(props: {
+export declare function TuyauProvider<R extends TuyauRegistry>(props: {
     children: React.ReactNode;
     client: Tuyau<R>;
 }): React.JSX.Element;
@@ -21,4 +21,4 @@ export declare function TuyauProvider<R extends AdonisRegistry>(props: {
  * @returns The Tuyau client instance with full type safety
  * @throws Error if used outside of a TuyauProvider
  */
-export declare function useTuyau(): Tuyau<any>;
+export declare function useTuyau(): Tuyau<any, any>;

package/build/src/client/react/index.js

@@ -1,72 +1,29 @@
-import "../../../chunk-MLKGABMK.js";
-
-// src/client/react/context.tsx
 import React from "react";
-var TuyauContext = React.createContext(null);
+import { Link as Link$1, router } from "@inertiajs/react";
+const TuyauContext = React.createContext(null);
 function TuyauProvider(props) {
-  return /* @__PURE__ */ React.createElement(TuyauContext.Provider, { value: props.client }, props.children);
+	return <TuyauContext.Provider value={props.client}>{props.children}</TuyauContext.Provider>;
 }
 function useTuyau() {
-  const context = React.useContext(TuyauContext);
-  if (!context) throw new Error("You must wrap your app in a TuyauProvider");
-  return context;
+	const context = React.useContext(TuyauContext);
+	if (!context) throw new Error("You must wrap your app in a TuyauProvider");
+	return context;
 }
-
-// src/client/react/router.ts
-import { router as InertiaRouter } from "@inertiajs/react";
 function useRouter() {
-  const tuyau = useTuyau();
-  return {
-    /**
-     * Navigate to a route with type-safe parameters and options.
-     *
-     * Automatically resolves the route URL and HTTP method based on the
-     * route definition, then performs the navigation using Inertia's router.
-     *
-     * @param props - Route navigation parameters including route name and params
-     * @param options - Optional Inertia visit options for controlling navigation behavior
-     *
-     * @example
-     * ```tsx
-     * // Navigate to a simple route
-     * router.visit({ route: 'dashboard' })
-     *
-     * // Navigate with parameters
-     * router.visit({ route: 'user.edit', params: { id: userId } })
-     * ```
-     */
-    visit: (props, options) => {
-      const routeInfo = tuyau.getRoute(props.route, { params: props.params });
-      const url = routeInfo.url;
-      return InertiaRouter.visit(url, {
-        ...options,
-        method: routeInfo.methods[0].toLowerCase()
-      });
-    }
-  };
+	const tuyau = useTuyau();
+	return { visit: (props, options) => {
+		const routeInfo = tuyau.getRoute(props.route, { params: props.params });
+		const url = routeInfo.url;
+		return router.visit(url, {
+			...options,
+			method: routeInfo.methods[0].toLowerCase()
+		});
+	} };
 }
-
-// src/client/react/link.tsx
-import React2 from "react";
-import { Link as InertiaLink } from "@inertiajs/react";
 function LinkInner(props, ref) {
-  const { route, params, ...linkProps } = props;
-  const tuyau = useTuyau();
-  const routeInfo = tuyau.getRoute(props.route, { params });
-  return /* @__PURE__ */ React2.createElement(
-    InertiaLink,
-    {
-      ...linkProps,
-      href: routeInfo.url,
-      method: routeInfo.methods[0].toLowerCase(),
-      ref
-    }
-  );
+	const { route, params, ...linkProps } = props;
+	const routeInfo = useTuyau().getRoute(props.route, { params });
+	return <Link$1 {...linkProps} href={routeInfo.url} method={routeInfo.methods[0].toLowerCase()} ref={ref} />;
 }
-var Link = React2.forwardRef(LinkInner);
-export {
-  Link,
-  TuyauProvider,
-  useRouter,
-  useTuyau
-};
+const Link = React.forwardRef(LinkInner);
+export { Link, TuyauProvider, useRouter, useTuyau };