npm - @adonisjs/inertia - Versions diffs - 4.0.0-next.0 → 4.0.0-next.10 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (89) hide show

package/README.md +8 -5
package/build/bin/test.d.ts +1 -0
package/build/chunk-4EZ2J6OA.js +7 -0
package/build/chunk-5QRJHXXQ.js +91 -0
package/build/chunk-DISC5OYC.js +46 -0
package/build/chunk-MLKGABMK.js +9 -0
package/build/chunk-YQ72YL64.js +813 -0
package/build/factories/inertia_factory.d.ts +137 -0
package/build/factories/main.d.ts +1 -0
package/build/factories/main.js +175 -0
package/build/index.d.ts +7 -19
package/build/index.js +21 -307
package/build/providers/inertia_provider.d.ts +86 -13
package/build/providers/inertia_provider.js +48 -18
package/build/src/client/helpers.d.ts +27 -0
package/build/src/client/helpers.js +30 -0
package/build/src/client/react/context.d.ts +24 -0
package/build/src/client/react/index.d.ts +3 -0
package/build/src/client/react/index.js +72 -0
package/build/src/client/react/link.d.ts +64 -0
package/build/src/client/react/router.d.ts +33 -0
package/build/src/client/vite.d.ts +65 -0
package/build/src/{plugins → client}/vite.js +6 -2
package/build/src/debug.d.ts +22 -0
package/build/src/define_config.d.ts +30 -0
package/build/src/headers.d.ts +61 -0
package/build/src/index_pages.d.ts +32 -0
package/build/src/inertia.d.ts +261 -0
package/build/src/inertia_manager.d.ts +47 -0
package/build/src/inertia_middleware.d.ts +76 -86
package/build/src/inertia_middleware.js +110 -3
package/build/src/plugins/edge/plugin.d.ts +30 -6
package/build/src/plugins/edge/plugin.js +13 -9
package/build/src/plugins/edge/tags.d.ts +47 -0
package/build/src/plugins/edge/utils.d.ts +26 -0
package/build/src/plugins/japa/api_client.d.ts +136 -22
package/build/src/plugins/japa/api_client.js +36 -48
package/build/src/props.d.ts +276 -0
package/build/src/server_renderer.d.ts +54 -0
package/build/src/symbols.d.ts +25 -0
package/build/src/types.d.ts +400 -4
package/build/tests/helpers.d.ts +35 -0
package/build/tests/index_pages.spec.d.ts +1 -0
package/build/tests/inertia.spec.d.ts +1 -0
package/build/tests/inertia_page.spec.d.ts +1 -0
package/build/tests/middleware.spec.d.ts +1 -0
package/build/tests/plugins/api_client.spec.d.ts +1 -0
package/build/tests/plugins/edge.plugin.spec.d.ts +1 -0
package/build/tests/provider.spec.d.ts +1 -0
package/build/tests/types/react.spec.d.ts +65 -0
package/build/tests/types/shared_props.spec.d.ts +1 -0
package/build/tests/types/to_component_props.spec.d.ts +1 -0
package/build/tests/types/to_page_props.spec.d.ts +1 -0
package/package.json +99 -71
package/build/app.css.stub +0 -13
package/build/chunk-AWCR2NAY.js +0 -412
package/build/config.stub +0 -33
package/build/react/app.tsx.stub +0 -38
package/build/react/errors/not_found.tsx.stub +0 -14
package/build/react/errors/server_error.tsx.stub +0 -14
package/build/react/home.tsx.stub +0 -349
package/build/react/root.edge.stub +0 -76
package/build/react/ssr.tsx.stub +0 -17
package/build/react/tsconfig.json.stub +0 -15
package/build/solid/app.tsx.stub +0 -38
package/build/solid/errors/not_found.tsx.stub +0 -14
package/build/solid/errors/server_error.tsx.stub +0 -14
package/build/solid/home.tsx.stub +0 -358
package/build/solid/root.edge.stub +0 -73
package/build/solid/ssr.tsx.stub +0 -19
package/build/solid/tsconfig.json.stub +0 -16
package/build/src/helpers.d.ts +0 -12
package/build/src/helpers.js +0 -14
package/build/src/plugins/vite.d.ts +0 -26
package/build/svelte/app.ts.stub +0 -32
package/build/svelte/errors/not_found.svelte.stub +0 -10
package/build/svelte/errors/server_error.svelte.stub +0 -14
package/build/svelte/home.svelte.stub +0 -339
package/build/svelte/root.edge.stub +0 -75
package/build/svelte/ssr.ts.stub +0 -19
package/build/svelte/tsconfig.json.stub +0 -14
package/build/types-DVqEHBD1.d.ts +0 -240
package/build/vue/app.ts.stub +0 -41
package/build/vue/errors/not_found.vue.stub +0 -10
package/build/vue/errors/server_error.vue.stub +0 -14
package/build/vue/home.vue.stub +0 -343
package/build/vue/root.edge.stub +0 -75
package/build/vue/ssr.ts.stub +0 -22
package/build/vue/tsconfig.json.stub +0 -16

package/build/src/plugins/edge/plugin.js CHANGED Viewed

@@ -1,10 +1,11 @@
+import {
+  debug_default
+} from "../../../chunk-4EZ2J6OA.js";
+import "../../../chunk-MLKGABMK.js";
 // src/plugins/edge/plugin.ts
 import { encode } from "html-entities";
-// src/debug.ts
-import { debuglog } from "util";
-var debug_default = debuglog("adonisjs:inertia");
 // src/plugins/edge/tags.ts
 import { EdgeError } from "edge-error";
@@ -40,10 +41,11 @@ var inertiaTag = {
       );
     });
     const attributes = parser.utils.stringify(parsed);
-    buffer.writeExpression(
-      `out += state.inertia(state.page, ${attributes})`,
+    buffer.outputExpression(
+      `state.inertia(state.page, ${attributes})`,
       filename,
-      loc.start.line
+      loc.start.line,
+      false
     );
   }
 };
@@ -52,7 +54,7 @@ var inertiaHeadTag = {
   tagName: "inertiaHead",
   seekable: false,
   compile(_, buffer, { filename, loc }) {
-    buffer.writeExpression(`out += state.inertiaHead(state.page)`, filename, loc.start.line);
+    buffer.outputExpression("state.inertiaHead(state.page)", filename, loc.start.line, false);
   }
 };
@@ -63,7 +65,9 @@ var edgePluginInertia = () => {
     edge.global(
       "inertia",
       (page = {}, attributes = {}) => {
-        if (page.ssrBody) return page.ssrBody;
+        if (page.ssrBody) {
+          return page.ssrBody;
+        }
         const className = attributes?.class ? ` class="${attributes.class}"` : "";
         const id = attributes?.id ? ` id="${attributes.id}"` : ' id="app"';
         const tag = attributes?.as || "div";

package/build/src/plugins/edge/tags.d.ts ADDED Viewed

@@ -0,0 +1,47 @@
+import { type TagContract } from 'edge.js/types';
+/**
+ * Edge tag that generates the root element for Inertia.js applications
+ *
+ * The @inertia tag creates a container element with encoded page data that Inertia.js
+ * uses to hydrate the client-side application. Supports customization through attributes.
+ *
+ * @example
+ * ```edge
+ * {{-- Basic usage with default div element and id="app" --}}
+ * @inertia()
+ *
+ * {{-- Custom element and attributes --}}
+ * @inertia({ as: 'main', id: 'app-root', class: 'min-h-screen' })
+ *
+ * {{-- Results in: --}}
+ * {{-- <main id="app-root" class="min-h-screen" data-page="{...encoded page data...}"></main> --}}
+ * ```
+ *
+ * Supported attributes:
+ * - `as`: HTML tag name for the root element (defaults to 'div')
+ * - `id`: Element ID (defaults to 'app')
+ * - `class`: CSS class names for the element
+ */
+export declare const inertiaTag: TagContract;
+/**
+ * Edge tag that renders server-side rendered head content for Inertia.js
+ *
+ * The @inertiaHead tag outputs head tags (title, meta, etc.) that were generated
+ * during server-side rendering. Only relevant when SSR is enabled.
+ *
+ * @example
+ * ```edge
+ * <!DOCTYPE html>
+ * <html>
+ * <head>
+ *   <meta charset="utf-8">
+ *   <meta name="viewport" content="width=device-width, initial-scale=1">
+ *   @inertiaHead()
+ * </head>
+ * <body>
+ *   @inertia()
+ * </body>
+ * </html>
+ * ```
+ */
+export declare const inertiaHeadTag: TagContract;

package/build/src/plugins/edge/utils.d.ts ADDED Viewed

@@ -0,0 +1,26 @@
+/**
+ * Validates that an AST expression is one of the allowed expression types
+ *
+ * This utility function is used during Edge template compilation to ensure
+ * that only specific expression types are allowed in certain contexts.
+ *
+ * @param expression - The AST expression to validate
+ * @param expressions - Array of allowed expression type names
+ * @param errorCallback - Function to call when validation fails
+ *
+ * @example
+ * ```js
+ * // Ensure expression is either a literal or identifier
+ * isSubsetOf(astNode, ['Literal', 'Identifier'], () => {
+ *   throw new Error('Invalid expression type')
+ * })
+ *
+ * // Allow only object expressions
+ * isSubsetOf(astNode, ['ObjectExpression'], () => {
+ *   throw new EdgeError('Expected object expression')
+ * })
+ * ```
+ */
+export declare function isSubsetOf(expression: {
+    type: string;
+}, expressions: string[], errorCallback: () => void): void;

package/build/src/plugins/japa/api_client.d.ts CHANGED Viewed

@@ -1,43 +1,157 @@
-import { PluginFn } from '@japa/runner/types';
-import { ApplicationService } from '@adonisjs/core/types';
-import { c as PageProps } from '../../../types-DVqEHBD1.js';
-import '@adonisjs/core/http';
-import '@tuyau/utils/types';
+import type { PluginFn } from '@japa/runner/types';
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { PageProps, InertiaPages } from '../../types.js';
 declare module '@japa/api-client' {
+    /**
+     * Extended ApiRequest interface with Inertia.js specific methods
+     *
+     * Adds methods to configure requests for testing Inertia applications,
+     * including setting required headers and configuring partial reloads.
+     */
     interface ApiRequest {
         /**
-         * Set `X-Inertia` header on the request
+         * Set `X-Inertia` header on the request to mark it as an Inertia request
+         *
+         * This method configures the request to be treated as an Inertia AJAX request
+         * by setting the required headers that Inertia.js uses for identification.
+         *
+         * @returns The ApiRequest instance for method chaining
+         *
+         * @example
+         * ```js
+         * const response = await client
+         *   .get('/dashboard')
+         *   .withInertia()
+         * ```
          */
-        withInertia(): this;
+        withInertia(this: ApiRequest): this;
         /**
-         * Set `X-Inertia-Partial-Data` and `X-Inertia-Partial-Component` headers on the request
+         * Set headers for partial data requests (partial reloads)
+         *
+         * Configures the request to only fetch specific props from a component,
+         * simulating Inertia's partial reload functionality in tests.
+         *
+         * @param component - The component name to partially reload
+         * @param props - Array of prop names to include in the partial request
+         * @returns The ApiRequest instance for method chaining
+         *
+         * @example
+         * ```js
+         * const response = await client
+         *   .get('/users')
+         *   .withInertiaPartialReload('Users/Index', ['users', 'pagination'])
+         * ```
          */
-        withInertiaPartialReload(component: string, data: string[]): this;
+        withInertiaPartialReload<K extends keyof InertiaPages>(this: ApiRequest, component: K, props: (keyof InertiaPages[K])[]): this;
     }
+    /**
+     * Extended ApiResponse interface with Inertia.js specific properties and assertions
+     *
+     * Provides getters for accessing Inertia response data and assertion methods
+     * for validating Inertia responses in tests.
+     */
     interface ApiResponse {
         /**
-         * The inertia component
+         * The name of the Inertia component returned in the response
+         *
+         * @example
+         * ```js
+         * console.log(response.inertiaComponent) // 'Users/Index'
+         * ```
          */
-        inertiaComponent?: string;
+        inertiaComponent?: keyof InertiaPages;
         /**
-         * The inertia response props
+         * The props data returned in the Inertia response
+         *
+         * @example
+         * ```js
+         * console.log(response.inertiaProps.users) // [{ id: 1, name: 'John' }]
+         * ```
          */
         inertiaProps: Record<string, any>;
         /**
-         * Assert component name of inertia response
+         * Assert that the response contains the expected Inertia component
+         *
+         * @param component - Expected component name
+         * @returns The ApiResponse instance for method chaining
+         *
+         * @throws AssertionError when component names don't match
+         *
+         * @example
+         * ```js
+         * response.assertInertiaComponent('Users/Index')
+         * ```
          */
-        assertInertiaComponent(component: string): this;
+        assertInertiaComponent(this: ApiResponse, component: string): this;
         /**
-         * Assert props to be exactly the same as the given props
+         * Assert that the response props exactly match the provided props
+         *
+         * @param props - Expected props object to match exactly
+         * @returns The ApiResponse instance for method chaining
+         *
+         * @throws AssertionError when props don't match exactly
+         *
+         * @example
+         * ```js
+         * response.assertInertiaProps({
+         *   users: [{ id: 1, name: 'John' }],
+         *   total: 1
+         * })
+         * ```
          */
-        assertInertiaProps(props: PageProps): this;
+        assertInertiaProps(this: ApiResponse, props: PageProps): this;
         /**
-         * Assert inertia props contains a subset of the given props
+         * Assert that the response props contain a subset of the provided props
+         *
+         * @param props - Expected subset of props to be present
+         * @returns The ApiResponse instance for method chaining
+         *
+         * @throws AssertionError when expected props are not found
+         *
+         * @example
+         * ```js
+         * response.assertInertiaPropsContains({
+         *   user: { name: 'John' }
+         * })
+         * ```
          */
-        assertInertiaPropsContains(props: PageProps): this;
+        assertInertiaPropsContains(this: ApiResponse, props: PageProps): this;
     }
 }
-declare function inertiaApiClient(app: ApplicationService): PluginFn;
-export { inertiaApiClient };
+/**
+ * Japa plugin that extends the API client with Inertia.js testing capabilities
+ *
+ * This plugin adds methods to ApiRequest and ApiResponse classes to support
+ * testing Inertia applications, including partial reloads and response assertions.
+ *
+ * @param app - The AdonisJS application service instance
+ * @returns Japa plugin function
+ *
+ * @example
+ * ```js
+ * // Configure in tests/bootstrap.ts
+ * import { inertiaApiClient } from '@adonisjs/inertia/plugins/japa/api_client'
+ *
+ * export const plugins: Config['plugins'] = [
+ *   assert(),
+ *   apiClient(app),
+ *   inertiaApiClient(app)
+ * ]
+ * ```
+ *
+ * @example
+ * ```js
+ * // Use in tests
+ * test('renders dashboard page', async ({ client }) => {
+ *   const response = await client
+ *     .get('/dashboard')
+ *     .withInertia()
+ *
+ *   response.assertInertiaComponent('Dashboard')
+ *   response.assertInertiaPropsContains({
+ *     user: { name: 'John' }
+ *   })
+ * })
+ * ```
+ */
+export declare function inertiaApiClient(app: ApplicationService): PluginFn;

package/build/src/plugins/japa/api_client.js CHANGED Viewed

@@ -1,37 +1,38 @@
+import {
+  InertiaHeaders
+} from "../../../chunk-DISC5OYC.js";
+import "../../../chunk-MLKGABMK.js";
 // src/plugins/japa/api_client.ts
-import { configProvider } from "@adonisjs/core";
-import { RuntimeException } from "@poppinss/utils";
 import { ApiRequest, ApiResponse } from "@japa/api-client";
 function ensureIsInertiaResponse() {
   if (!this.header("x-inertia")) {
     throw new Error(
-      "Response is not an Inertia response. Make sure to call `withInertia()` on the request"
+      'Not an Inertia response. Make sure to use "withInertia()" method when making the request'
+    );
+  }
+}
+function ensureHasAssert(assertLib) {
+  if (!assertLib) {
+    throw new Error(
+      "Response assertions are not available. Make sure to install the @japa/assert plugin"
     );
   }
 }
 function inertiaApiClient(app) {
   return async () => {
-    const inertiaConfigProvider = app.config.get("inertia");
-    const config = await configProvider.resolve(app, inertiaConfigProvider);
-    if (!config) {
-      throw new RuntimeException(
-        'Invalid "config/inertia.ts" file. Make sure you are using the "defineConfig" method'
-      );
-    }
+    const inertiaConfig = app.config.get("inertia");
     ApiRequest.macro("withInertia", function() {
-      this.header("x-inertia", "true");
-      this.header("x-inertia-version", config.versionCache.getVersion().toString());
+      this.header(InertiaHeaders.Inertia, "true");
+      this.header(InertiaHeaders.Version, String(inertiaConfig.assetsVersion ?? "1"));
+      return this;
+    });
+    ApiRequest.macro("withInertiaPartialReload", function(component, data) {
+      this.withInertia();
+      this.header(InertiaHeaders.PartialComponent, component);
+      this.header(InertiaHeaders.PartialOnly, data.join(","));
       return this;
     });
-    ApiRequest.macro(
-      "withInertiaPartialReload",
-      function(component, data) {
-        this.withInertia();
-        this.header("X-Inertia-Partial-Data", data.join(","));
-        this.header("X-Inertia-Partial-Component", component);
-        return this;
-      }
-    );
     ApiResponse.getter("inertiaComponent", function() {
       ensureIsInertiaResponse.call(this);
       return this.body().component;
@@ -42,35 +43,22 @@ function inertiaApiClient(app) {
     });
     ApiResponse.macro("assertInertiaComponent", function(component) {
       ensureIsInertiaResponse.call(this);
-      this.assert.deepEqual(this.body().component, component);
+      ensureHasAssert(this.assert);
+      this.assert.equal(this.body().component, component);
+      return this;
+    });
+    ApiResponse.macro("assertInertiaProps", function(props) {
+      ensureIsInertiaResponse.call(this);
+      ensureHasAssert(this.assert);
+      this.assert.deepEqual(this.body().props, props);
+      return this;
+    });
+    ApiResponse.macro("assertInertiaPropsContains", function(props) {
+      ensureIsInertiaResponse.call(this);
+      ensureHasAssert(this.assert);
+      this.assert.containSubset(this.body().props, props);
       return this;
     });
-    ApiResponse.macro(
-      "assertInertiaProps",
-      function(props) {
-        if (!this.assert) {
-          throw new Error(
-            "Response assertions are not available. Make sure to install the @japa/assert plugin"
-          );
-        }
-        ensureIsInertiaResponse.call(this);
-        this.assert.deepEqual(this.body().props, props);
-        return this;
-      }
-    );
-    ApiResponse.macro(
-      "assertInertiaPropsContains",
-      function(props) {
-        if (!this.assert) {
-          throw new Error(
-            "Response assertions are not available. Make sure to install the @japa/assert plugin"
-          );
-        }
-        ensureIsInertiaResponse.call(this);
-        this.assert.containsSubset(this.body().props, props);
-        return this;
-      }
-    );
   };
 }
 export {

package/build/src/props.d.ts ADDED Viewed

@@ -0,0 +1,276 @@
+import { type AsyncOrSync } from '@adonisjs/core/types/common';
+import { type DeferProp, type PageProps, type AlwaysProp, type OptionalProp, type MergeableProp, type ComponentProps, type UnPackedPageProps } from './types.ts';
+import { type ContainerResolver } from '@adonisjs/core/container';
+/**
+ * Creates a deferred prop that is never included in standard visits but must be shared with
+ * the client during standard visits. Can be explicitly requested and supports merging.
+ *
+ * Deferred props are useful for expensive computations that should only be loaded when
+ * specifically requested by the client.
+ *
+ * @param fn - Function that computes the prop value when requested
+ * @returns A deferred prop object with compute and merge capabilities
+ *
+ * @example
+ * ```javascript
+ * // Create a deferred prop for expensive user statistics
+ * const userStats = defer(() => {
+ *   return calculateExpensiveUserStats(userId)
+ * })
+ *
+ * // Use in page props
+ * return inertia.render('dashboard', {
+ *   user: user,
+ *   stats: userStats // Only loaded when explicitly requested
+ * })
+ * ```
+ */
+export declare function defer<T extends UnPackedPageProps>(fn: () => AsyncOrSync<T>, group?: string): DeferProp<T>;
+/**
+ * Creates an optional prop that is never included in standard visits and can only be
+ * explicitly requested by the client. Unlike deferred props, optional props are not
+ * shared with the client during standard visits.
+ *
+ * Optional props are ideal for data that is rarely needed and should only be loaded
+ * on demand to optimize performance.
+ *
+ * @param fn - Function that computes the prop value when requested
+ * @returns An optional prop object that computes values lazily
+ *
+ * @example
+ * ```javascript
+ * // Create an optional prop for detailed audit logs
+ * const auditLogs = optional(() => {
+ *   return fetchDetailedAuditLogs(resourceId)
+ * })
+ *
+ * // Use in page props
+ * return inertia.render('resource/show', {
+ *   resource: resource,
+ *   auditLogs: auditLogs // Only loaded when explicitly requested
+ * })
+ * ```
+ */
+export declare function optional<T extends UnPackedPageProps>(fn: () => AsyncOrSync<T>): OptionalProp<T>;
+/**
+ * Creates a prop that is always included in responses and cannot be removed during
+ * cherry-picking. This ensures the prop is always available to the frontend component.
+ *
+ * Always props are useful for critical data that the frontend component must have
+ * to function properly, regardless of what props are specifically requested.
+ *
+ * @param value - The value to always include in the response
+ * @returns An always prop object that cannot be cherry-picked away
+ *
+ * @example
+ * ```javascript
+ * // Create an always prop for critical user permissions
+ * const userPermissions = always(user.permissions)
+ *
+ * // Use in page props
+ * return inertia.render('admin/dashboard', {
+ *   users: users,
+ *   permissions: userPermissions // Always included, never filtered out
+ * })
+ * ```
+ */
+export declare function always<T extends UnPackedPageProps>(value: T): AlwaysProp<T>;
+/**
+ * Creates a prop that should be merged with existing props on the page rather than
+ * replaced. This is useful for incremental updates where you want to combine new
+ * data with existing data on the client side.
+ *
+ * Mergeable props enable efficient partial updates by allowing the client to
+ * merge new prop values with existing ones instead of replacing them entirely.
+ *
+ * @param value - The value to be merged with existing props
+ * @returns A mergeable prop object marked for merging behavior
+ *
+ * @example
+ * ```javascript
+ * // Create a mergeable prop for incremental notifications
+ * const newNotifications = merge([
+ *   { id: 1, message: 'New message received' },
+ *   { id: 2, message: 'Task completed' }
+ * ])
+ *
+ * // Use in page props - will merge with existing notifications
+ * return inertia.render('dashboard', {
+ *   user: user,
+ *   notifications: newNotifications // Merges with existing notifications array
+ * })
+ * ```
+ */
+export declare function merge<T extends UnPackedPageProps | DeferProp<UnPackedPageProps>>(value: T): MergeableProp<T>;
+/**
+ * Creates a prop that should be deeply merged with existing props on the page.
+ *
+ * Unlike shallow merge, deep merge recursively merges nested objects and arrays,
+ * allowing for more granular updates to complex data structures.
+ *
+ * @param value - The value to be deeply merged with existing props
+ * @returns A mergeable prop object marked for deep merging behavior
+ *
+ * @example
+ * ```javascript
+ * // Create a deep mergeable prop for nested user settings
+ * const updatedSettings = deepMerge({
+ *   notifications: {
+ *     email: true,
+ *     push: false
+ *   },
+ *   privacy: {
+ *     profile: 'public'
+ *   }
+ * })
+ *
+ * // Use in page props - will deeply merge with existing settings
+ * return inertia.render('settings', {
+ *   user: user,
+ *   settings: updatedSettings // Deep merges with existing settings object
+ * })
+ * ```
+ */
+export declare function deepMerge<T extends UnPackedPageProps | DeferProp<UnPackedPageProps>>(value: T): MergeableProp<T>;
+/**
+ * Type guard that checks if a prop value is a deferred prop.
+ *
+ * Deferred props contain the DEFERRED_PROP symbol and have compute/merge capabilities.
+ * This function is useful for runtime type checking and conditional prop handling.
+ *
+ * @param propValue - The object to check for deferred prop characteristics
+ * @returns True if the prop value is a deferred prop
+ *
+ * @example
+ * ```js
+ * const prop = defer(() => ({ data: 'value' }))
+ *
+ * if (isDeferredProp(prop)) {
+ *   // prop is now typed as DeferProp<T>
+ *   const result = prop.compute()
+ * }
+ * ```
+ */
+export declare function isDeferredProp<T extends UnPackedPageProps>(propValue: Object): propValue is DeferProp<T>;
+/**
+ * Type guard that checks if a prop value is a mergeable prop.
+ *
+ * Mergeable props contain the TO_BE_MERGED symbol and should be merged with
+ * existing props rather than replaced during updates.
+ *
+ * @param propValue - The object to check for mergeable prop characteristics
+ * @returns True if the prop value is a mergeable prop
+ *
+ * @example
+ * ```js
+ * const prop = merge({ items: [1, 2, 3] })
+ *
+ * if (isMergeableProp(prop)) {
+ *   // prop is now typed as MergeableProp<T>
+ *   const value = prop.value
+ * }
+ * ```
+ */
+export declare function isMergeableProp<T extends UnPackedPageProps | DeferProp<UnPackedPageProps>>(propValue: Object): propValue is MergeableProp<T>;
+/**
+ * Type guard that checks if a prop value is an always prop.
+ *
+ * Always props contain the ALWAYS_PROP symbol and are always included in
+ * responses, regardless of cherry-picking or selective prop requests.
+ *
+ * @param propValue - The object to check for always prop characteristics
+ * @returns True if the prop value is an always prop
+ *
+ * @example
+ * ```js
+ * const prop = always({ userId: 123, permissions: ['read', 'write'] })
+ *
+ * if (isAlwaysProp(prop)) {
+ *   // prop is now typed as AlwaysProp<T>
+ *   const value = prop.value
+ * }
+ * ```
+ */
+export declare function isAlwaysProp<T extends UnPackedPageProps>(propValue: Object): propValue is AlwaysProp<T>;
+/**
+ * Type guard that checks if a prop value is an optional prop.
+ *
+ * Optional props contain the OPTIONAL_PROP symbol and are only included
+ * when explicitly requested by the client, never in standard visits.
+ *
+ * @param propValue - The object to check for optional prop characteristics
+ * @returns True if the prop value is an optional prop
+ *
+ * @example
+ * ```js
+ * const prop = optional(() => ({ detailedData: 'expensive computation' }))
+ *
+ * if (isOptionalProp(prop)) {
+ *   // prop is now typed as OptionalProp<T>
+ *   const result = prop.compute()
+ * }
+ * ```
+ */
+export declare function isOptionalProp<T extends UnPackedPageProps>(propValue: Object): propValue is OptionalProp<T>;
+/**
+ * Builds props for standard (non-partial) Inertia visits.
+ *
+ * This function processes page props and categorizes them based on their type:
+ * - Deferred props: Skipped but communicated to client
+ * - Optional props: Skipped entirely
+ * - Always props: Always included
+ * - Mergeable props: Included and marked for merging
+ * - Regular props: Included normally
+ *
+ * @param pageProps - The page props to process
+ * @param containerResolver - Container resolver for dependency injection
+ * @returns Promise resolving to object containing processed props, deferred props list, and merge props list
+ *
+ * @example
+ * ```js
+ * const result = await buildStandardVisitProps({
+ *   user: { name: 'John' },
+ *   posts: defer(() => getPosts()),
+ *   settings: merge({ theme: 'dark' })
+ * })
+ * // Returns: { props: { user: {...} }, deferredProps: { default: ['posts'] }, mergeProps: ['settings'] }
+ * ```
+ */
+export declare function buildStandardVisitProps(pageProps: PageProps, containerResolver: ContainerResolver<any>): Promise<{
+    props: ComponentProps;
+    mergeProps: string[];
+    deepMergeProps: string[];
+    deferredProps: {
+        [group: string]: string[];
+    };
+}>;
+/**
+ * Builds props for partial (cherry-picked) Inertia requests.
+ *
+ * This function processes page props for partial requests where only specific
+ * props are requested. It handles:
+ * - Always props: Always included regardless of cherry picking
+ * - Cherry-picked props: Only included if in the cherryPickProps list
+ * - Mergeable props: Included and marked for merging
+ * - Regular props: Included if cherry-picked
+ *
+ * @param pageProps - The page props to process
+ * @param cherryPickProps - Array of prop names to include
+ * @param containerResolver - Container resolver for dependency injection
+ * @returns Promise resolving to object containing processed props and merge props list
+ *
+ * @example
+ * ```js
+ * const result = await buildPartialRequestProps(
+ *   { user: { name: 'John' }, posts: defer(() => getPosts()), stats: optional(() => getStats()) },
+ *   ['posts', 'stats']
+ * )
+ * // Returns: { props: { posts: [...], stats: [...] }, mergeProps: [], deferredProps: {} }
+ * ```
+ */
+export declare function buildPartialRequestProps(pageProps: PageProps, cherryPickProps: string[], containerResolver: ContainerResolver<any>): Promise<{
+    props: ComponentProps;
+    mergeProps: string[];
+    deepMergeProps: string[];
+    deferredProps: {};
+}>;