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

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

@@ -1,23 +1,24 @@
 import React from 'react';
-import type { UserRegistry } from '@tuyau/core/types';
-import { Link as InertiaLink } from '@inertiajs/react';
+import type { UserRegistry, InferRoutes } from '@tuyau/core/types';
 import { AreAllOptional } from '@poppinss/utils/types';
+import { Link as InertiaLink } from '@inertiajs/react';
+type Routes = InferRoutes<UserRegistry>;
 /**
  * Get parameter tuple type for a route
  */
-type ExtractParamsTuple<Route extends keyof UserRegistry> = UserRegistry[Route]['types']['paramsTuple'];
+type ExtractParamsTuple<Route extends keyof Routes> = Routes[Route]['types']['paramsTuple'];
 /**
  * Get parameter object type for a route
  */
-type ExtractParamsObject<Route extends keyof UserRegistry> = UserRegistry[Route]['types']['params'];
+type ExtractParamsObject<Route extends keyof Routes> = Routes[Route]['types']['params'];
 /**
  * Get params format for a route
  */
-type RouteParamsFormats<Route extends keyof UserRegistry> = ExtractParamsObject<Route> extends Record<string, never> ? never : ExtractParamsTuple<Route> | ExtractParamsObject<Route>;
+type RouteParamsFormats<Route extends keyof Routes> = ExtractParamsObject<Route> extends Record<string, never> ? never : ExtractParamsTuple<Route> | ExtractParamsObject<Route>;
 /**
  * Parameters required for route navigation with proper type safety.
  */
-export type LinkParams<Route extends keyof UserRegistry> = {
+export type LinkParams<Route extends keyof Routes> = {
     route: Route;
 } & (RouteParamsFormats<Route> extends never ? {
     params?: never;
@@ -30,7 +31,7 @@ export type LinkParams<Route extends keyof UserRegistry> = {
  * Props for the Link component extending InertiaLink props
  * with route-specific type safety and parameter validation.
  */
-type LinkProps<Route extends keyof UserRegistry> = Omit<React.ComponentPropsWithoutRef<typeof InertiaLink>, 'href' | 'method'> & LinkParams<Route>;
+type LinkProps<Route extends keyof Routes> = Omit<React.ComponentPropsWithoutRef<typeof InertiaLink>, 'href' | 'method'> & LinkParams<Route>;
 /**
  * Internal Link component implementation with forward ref support.
  * Resolves route parameters and generates the appropriate URL and HTTP method
@@ -39,7 +40,7 @@ type LinkProps<Route extends keyof UserRegistry> = Omit<React.ComponentPropsWith
  * @param props - Link properties including route and parameters
  * @param ref - Forward ref for the underlying InertiaLink component
  */
-declare function LinkInner<Route extends keyof UserRegistry>(props: LinkProps<Route>, ref?: React.ForwardedRef<React.ElementRef<typeof InertiaLink>>): React.JSX.Element;
+declare function LinkInner<Route extends keyof Routes>(props: LinkProps<Route>, ref?: React.ForwardedRef<React.ElementRef<typeof InertiaLink>>): React.JSX.Element;
 /**
  * Type-safe Link component for Inertia.js navigation.
  *
@@ -58,7 +59,7 @@ declare function LinkInner<Route extends keyof UserRegistry>(props: LinkProps<Ro
  * </Link>
  * ```
  */
-export declare const Link: <Route extends keyof UserRegistry>(props: LinkProps<Route> & {
+export declare const Link: <Route extends keyof Routes>(props: LinkProps<Route> & {
     ref?: React.Ref<React.ElementRef<typeof InertiaLink>>;
 }) => ReturnType<typeof LinkInner>;
 export {};

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

@@ -1,4 +1,4 @@
-import type { UserRegistry } from '@tuyau/core/types';
+import type { UserRegistry, InferRoutes } from '@tuyau/core/types';
 import { router as InertiaRouter } from '@inertiajs/react';
 import type { LinkParams } from './link.tsx';
 /**
@@ -29,5 +29,5 @@ export declare function useRouter(): {
      * router.visit({ route: 'user.edit', params: { id: userId } })
      * ```
      */
-    visit: <Route extends keyof UserRegistry>(props: LinkParams<Route>, options?: Parameters<typeof InertiaRouter.visit>[1]) => any;
+    visit: <Route extends keyof InferRoutes<UserRegistry>>(props: LinkParams<Route>, options?: Parameters<typeof InertiaRouter.visit>[1]) => any;
 };

package/build/src/client/vite.js

@@ -1,31 +1,18 @@
-import "../../chunk-MLKGABMK.js";
-
-// src/client/vite.ts
 function inertia(options) {
-  return {
-    name: "vite-plugin-inertia",
-    config: (_, { command }) => {
-      if (command === "build") {
-        process.env.NODE_ENV = "production";
-      }
-      return {
-        builder: {},
-        build: { outDir: "build/public/assets" },
-        environments: {
-          ...options?.ssr?.enabled && {
-            ssr: {
-              build: {
-                ssr: true,
-                outDir: options.ssr.output || "build/ssr",
-                rollupOptions: { input: options.ssr.entrypoint }
-              }
-            }
-          }
-        }
-      };
-    }
-  };
+	return {
+		name: "vite-plugin-inertia",
+		config: (_, { command }) => {
+			if (command === "build") process.env.NODE_ENV = "production";
+			return {
+				builder: {},
+				build: { outDir: "build/public/assets" },
+				environments: { ...options?.ssr?.enabled && { ssr: { build: {
+					ssr: true,
+					outDir: options.ssr.output || "build/ssr",
+					rollupOptions: { input: options.ssr.entrypoint }
+				} } } }
+			};
+		}
+	};
 }
-export {
-  inertia as default
-};
+export { inertia as default };

package/build/src/inertia_middleware.js

@@ -1,113 +1,47 @@
-import {
-  InertiaManager
-} from "../chunk-YQ72YL64.js";
-import {
-  debug_default
-} from "../chunk-4EZ2J6OA.js";
-import {
-  InertiaHeaders
-} from "../chunk-DISC5OYC.js";
-import "../chunk-MLKGABMK.js";
-
-// src/inertia_middleware.ts
-var MUTATION_METHODS = ["PUT", "PATCH", "DELETE"];
+import { t as InertiaManager } from "../inertia_manager-Di3J3hSG.js";
+import { t as InertiaHeaders } from "../headers-DafWEpBh.js";
+import { t as debug_default } from "../debug-CBMTuPUm.js";
+const MUTATION_METHODS = [
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
 var BaseInertiaMiddleware = class {
-  /**
-   * Extract validation errors from the session and format them for Inertia
-   *
-   * Retrieves validation errors from the session flash messages and formats
-   * them according to Inertia's error bag conventions. Supports both simple
-   * error objects and error bags for multi-form scenarios.
-   *
-   * @param ctx - The HTTP context containing session data
-   * @returns Formatted validation errors, either as a simple object or error bags
-   *
-   * @example
-   * ```js
-   * const errors = middleware.getValidationErrors(ctx)
-   * // Returns: { email: 'Email is required', password: 'Password too short' }
-   * // Or with error bags: { login: { email: 'Email is required' } }
-   * ```
-   */
-  getValidationErrors(ctx) {
-    if (!ctx.session) {
-      return {};
-    }
-    const inputErrors = ctx.session.flashMessages.get("inputErrorsBag", {});
-    const errors = Object.entries(inputErrors).reduce(
-      (result, [field, messages]) => {
-        result[field] = Array.isArray(messages) ? messages[0] : messages;
-        return result;
-      },
-      {}
-    );
-    const errorBag = ctx.request.header(InertiaHeaders.ErrorBag);
-    if (errorBag) {
-      return { [errorBag]: errors };
-    }
-    return errors;
-  }
-  /**
-   * Initialize the Inertia instance for the current request
-   *
-   * This method creates an Inertia instance and attaches it to the
-   * HTTP context, making it available throughout the request lifecycle.
-   *
-   * @param ctx - The HTTP context object
-   *
-   * @example
-   * ```ts
-   * await middleware.init(ctx)
-   * ```
-   */
-  async init(ctx) {
-    debug_default("initiating inertia");
-    const inertiaContainer = await ctx.containerResolver.make(InertiaManager);
-    ctx.inertia = inertiaContainer.createForRequest(ctx);
-    if (this.share) {
-      ctx.inertia.share(() => this.share(ctx));
-    }
-  }
-  /**
-   * Clean up and finalize the Inertia response
-   *
-   * This method handles the final processing of Inertia requests including:
-   * - Setting appropriate response headers
-   * - Handling redirects for mutation methods (PUT/PATCH/DELETE)
-   * - Managing asset versioning conflicts
-   *
-   * @param ctx - The HTTP context object
-   *
-   * @example
-   * ```ts
-   * await middleware.dispose(ctx)
-   * ```
-   */
-  dispose(ctx) {
-    const requestInfo = ctx.inertia.requestInfo();
-    if (!requestInfo.isInertiaRequest) {
-      return;
-    }
-    debug_default("disposing as inertia request");
-    ctx.response.header("Vary", InertiaHeaders.Inertia);
-    const method = ctx.request.method();
-    if (ctx.response.getStatus() === 302 && MUTATION_METHODS.includes(method)) {
-      debug_default("upgrading response status from 302 to 303");
-      ctx.response.status(303);
-    }
-    const version = ctx.inertia.getVersion();
-    const clientVersion = requestInfo.version ?? "";
-    if (method === "GET" && clientVersion !== version) {
-      debug_default("version mis-match. Reloading page");
-      if (ctx.session) {
-        ctx.session.reflash();
-      }
-      ctx.response.removeHeader(InertiaHeaders.Inertia);
-      ctx.response.header(InertiaHeaders.Location, ctx.request.url(true));
-      ctx.response.status(409);
-    }
-  }
-};
-export {
-  BaseInertiaMiddleware as default
+	getValidationErrors(ctx) {
+		if (!ctx.session) return {};
+		const inputErrors = ctx.session.flashMessages.get("inputErrorsBag", {});
+		const errors = Object.entries(inputErrors).reduce((result, [field, messages]) => {
+			result[field] = Array.isArray(messages) ? messages[0] : messages;
+			return result;
+		}, {});
+		const errorBag = ctx.request.header(InertiaHeaders.ErrorBag);
+		if (errorBag) return { [errorBag]: errors };
+		return errors;
+	}
+	async init(ctx) {
+		debug_default("initiating inertia");
+		ctx.inertia = (await ctx.containerResolver.make(InertiaManager)).createForRequest(ctx);
+		if (this.share) ctx.inertia.share(() => this.share(ctx));
+	}
+	dispose(ctx) {
+		const requestInfo = ctx.inertia.requestInfo();
+		if (!requestInfo.isInertiaRequest) return;
+		debug_default("disposing as inertia request");
+		ctx.response.header("Vary", InertiaHeaders.Inertia);
+		const method = ctx.request.method();
+		if (ctx.response.getStatus() === 302 && MUTATION_METHODS.includes(method)) {
+			debug_default("upgrading response status from 302 to 303");
+			ctx.response.status(303);
+		}
+		const version = ctx.inertia.getVersion();
+		const clientVersion = requestInfo.version ?? "";
+		if (method === "GET" && clientVersion !== version) {
+			debug_default("version mis-match. Reloading page");
+			if (ctx.session) ctx.session.reflash();
+			ctx.response.removeHeader(InertiaHeaders.Inertia);
+			ctx.response.header(InertiaHeaders.Location, ctx.request.url(true));
+			ctx.response.status(409);
+		}
+	}
 };
+export { BaseInertiaMiddleware as default };

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

@@ -1,88 +1,56 @@
-import {
-  debug_default
-} from "../../../chunk-4EZ2J6OA.js";
-import "../../../chunk-MLKGABMK.js";
-
-// src/plugins/edge/plugin.ts
+import { t as debug_default } from "../../../debug-CBMTuPUm.js";
 import { encode } from "html-entities";
-
-// src/plugins/edge/tags.ts
 import { EdgeError } from "edge-error";
-
-// src/plugins/edge/utils.ts
 function isSubsetOf(expression, expressions, errorCallback) {
-  if (!expressions.includes(expression.type)) {
-    errorCallback();
-  }
+	if (!expressions.includes(expression.type)) errorCallback();
 }
-
-// src/plugins/edge/tags.ts
-var inertiaTag = {
-  block: false,
-  tagName: "inertia",
-  seekable: true,
-  compile(parser, buffer, { filename, loc, properties }) {
-    if (properties.jsArg.trim() === "") {
-      buffer.writeExpression(`out += state.inertia(state.page)`, filename, loc.start.line);
-      return;
-    }
-    properties.jsArg = `(${properties.jsArg})`;
-    const parsed = parser.utils.transformAst(
-      parser.utils.generateAST(properties.jsArg, loc, filename),
-      filename,
-      parser
-    );
-    isSubsetOf(parsed, ["ObjectExpression"], () => {
-      const { line, col } = parser.utils.getExpressionLoc(parsed);
-      throw new EdgeError(
-        `"${properties.jsArg}" is not a valid argument for @inertia`,
-        "E_UNALLOWED_EXPRESSION",
-        { line, col, filename }
-      );
-    });
-    const attributes = parser.utils.stringify(parsed);
-    buffer.outputExpression(
-      `state.inertia(state.page, ${attributes})`,
-      filename,
-      loc.start.line,
-      false
-    );
-  }
+const inertiaTag = {
+	block: false,
+	tagName: "inertia",
+	seekable: true,
+	compile(parser, buffer, { filename, loc, properties }) {
+		if (properties.jsArg.trim() === "") {
+			buffer.writeExpression(`out += state.inertia(state.page)`, filename, loc.start.line);
+			return;
+		}
+		properties.jsArg = `(${properties.jsArg})`;
+		const parsed = parser.utils.transformAst(parser.utils.generateAST(properties.jsArg, loc, filename), filename, parser);
+		isSubsetOf(parsed, ["ObjectExpression"], () => {
+			const { line, col } = parser.utils.getExpressionLoc(parsed);
+			throw new EdgeError(`"${properties.jsArg}" is not a valid argument for @inertia`, "E_UNALLOWED_EXPRESSION", {
+				line,
+				col,
+				filename
+			});
+		});
+		const attributes = parser.utils.stringify(parsed);
+		buffer.outputExpression(`state.inertia(state.page, ${attributes})`, filename, loc.start.line, false);
+	}
 };
-var inertiaHeadTag = {
-  block: false,
-  tagName: "inertiaHead",
-  seekable: false,
-  compile(_, buffer, { filename, loc }) {
-    buffer.outputExpression("state.inertiaHead(state.page)", filename, loc.start.line, false);
-  }
+const inertiaHeadTag = {
+	block: false,
+	tagName: "inertiaHead",
+	seekable: false,
+	compile(_, buffer, { filename, loc }) {
+		buffer.outputExpression("state.inertiaHead(state.page)", filename, loc.start.line, false);
+	}
 };
-
-// src/plugins/edge/plugin.ts
-var edgePluginInertia = () => {
-  return (edge) => {
-    debug_default("sharing globals and inertia tags with edge");
-    edge.global(
-      "inertia",
-      (page = {}, attributes = {}) => {
-        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";
-        const dataPage = encode(JSON.stringify(page));
-        return `<${tag}${id}${className} data-page="${dataPage}"></${tag}>`;
-      }
-    );
-    edge.global("inertiaHead", (page) => {
-      const { ssrHead = [] } = page || {};
-      return ssrHead.join("\n");
-    });
-    edge.registerTag(inertiaHeadTag);
-    edge.registerTag(inertiaTag);
-  };
-};
-export {
-  edgePluginInertia
+const edgePluginInertia = () => {
+	return (edge) => {
+		debug_default("sharing globals and inertia tags with edge");
+		edge.global("inertia", (page = {}, attributes = {}) => {
+			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";
+			return `<${tag}${id}${className} data-page="${encode(JSON.stringify(page))}"></${tag}>`;
+		});
+		edge.global("inertiaHead", (page) => {
+			const { ssrHead = [] } = page || {};
+			return ssrHead.join("\n");
+		});
+		edge.registerTag(inertiaHeadTag);
+		edge.registerTag(inertiaTag);
+	};
 };
+export { edgePluginInertia };

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

@@ -1,66 +1,51 @@
-import {
-  InertiaHeaders
-} from "../../../chunk-DISC5OYC.js";
-import "../../../chunk-MLKGABMK.js";
-
-// src/plugins/japa/api_client.ts
+import { t as InertiaHeaders } from "../../../headers-DafWEpBh.js";
 import { ApiRequest, ApiResponse } from "@japa/api-client";
 function ensureIsInertiaResponse() {
-  if (!this.header("x-inertia")) {
-    throw new Error(
-      'Not an Inertia response. Make sure to use "withInertia()" method when making the request'
-    );
-  }
+	if (!this.header("x-inertia")) throw new Error("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"
-    );
-  }
+	if (!assertLib) throw new Error("Response assertions are not available. Make sure to install the @japa/assert plugin");
 }
 function inertiaApiClient(app) {
-  return async () => {
-    const inertiaConfig = app.config.get("inertia");
-    ApiRequest.macro("withInertia", function() {
-      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;
-    });
-    ApiResponse.getter("inertiaComponent", function() {
-      ensureIsInertiaResponse.call(this);
-      return this.body().component;
-    });
-    ApiResponse.getter("inertiaProps", function() {
-      ensureIsInertiaResponse.call(this);
-      return this.body().props;
-    });
-    ApiResponse.macro("assertInertiaComponent", function(component) {
-      ensureIsInertiaResponse.call(this);
-      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;
-    });
-  };
+	return async () => {
+		const inertiaConfig = app.config.get("inertia");
+		ApiRequest.macro("withInertia", function() {
+			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;
+		});
+		ApiResponse.getter("inertiaComponent", function() {
+			ensureIsInertiaResponse.call(this);
+			return this.body().component;
+		});
+		ApiResponse.getter("inertiaProps", function() {
+			ensureIsInertiaResponse.call(this);
+			return this.body().props;
+		});
+		ApiResponse.macro("assertInertiaComponent", function(component) {
+			ensureIsInertiaResponse.call(this);
+			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;
+		});
+	};
 }
-export {
-  inertiaApiClient
-};
+export { inertiaApiClient };

package/build/src/types.d.ts

@@ -4,34 +4,27 @@ import type { JSONDataTypes } from '@adonisjs/core/types/transformers';
 import type { AsyncOrSync, DeepPartial, Prettify } from '@adonisjs/core/types/common';
 import { type DEEP_MERGE, type ALWAYS_PROP, type OPTIONAL_PROP, type TO_BE_MERGED, type DEFERRED_PROP } from './symbols.ts';
 /**
- * Representation of a resource item, collection and paginator that can be serialized
+ * Representation of a resource item, collection and paginator that can be resolved to
+ * get normalized objects
  *
- * @template T - The type that the serializable object resolves to
+ * @template T - The type that the resource resolves to
  */
-export type SerializableOf<T> = {
-    /**
-     * Serializes the object using the container resolver
-     *
-     * @param container - The container resolver instance
-     * @param depth - Current serialization depth
-     * @param maxDepth - Maximum allowed serialization depth
-     * @returns Promise that resolves to the serialized object
-     */
-    serialize(container: ContainerResolver<any>, depth: number, maxDepth?: number): Promise<T>;
+export type ResolvableOf<T> = {
+    resolve(container: ContainerResolver<any>, depth: number, maxDepth?: number): Promise<T>;
 };
 /**
  * Union type representing unpacked page prop values that can be either JSON data or serializable objects
  *
  * @template T - The JSON data type, defaults to JSONDataTypes
  */
-export type UnPackedPageProps<T extends JSONDataTypes = JSONDataTypes> = T | SerializableOf<T>;
+export type UnPackedPageProps<T extends JSONDataTypes = JSONDataTypes> = T | ResolvableOf<T>;
 /**
  * Utility type that extracts the resolved type from a SerializableOf wrapper
  * If the type is already unwrapped, returns it as-is
  *
  * @template T - The type to unwrap, potentially wrapped in SerializableOf
  */
-export type UnpackProp<T> = T extends SerializableOf<infer A> ? A : T;
+export type UnpackProp<T> = T extends ResolvableOf<infer A> ? A : T;
 /**
  * Information extracted from Inertia request headers
  * Contains metadata about the current request type and filtering preferences
@@ -117,13 +110,13 @@ type PagePropsLazyDataTypes<T extends JSONDataTypes> =
  * - Can be explicitly requested for
  * - Can be dropped during cherry-picking
  */
-DeferProp<T | SerializableOf<T>>
+DeferProp<T | ResolvableOf<T>>
 /**
  * - Never included on standard visit
  * - Can be explicitly requested for
  * - Can be dropped during cherry-picking
  */
- | OptionalProp<T | SerializableOf<T>>;
+ | OptionalProp<T | ResolvableOf<T>>;
 /**
  * Eager props are always included during standard Inertia visits, but
  * can be removed via cherry-picking when only specific props are requested
@@ -140,17 +133,17 @@ T
  * - Always included on standard visit.
  * - Can be dropped during cherry-picking
  */
- | SerializableOf<T>
+ | ResolvableOf<T>
 /**
  * - Always included on standard visit.
  * - Can be dropped during cherry-picking
  */
- | (() => AsyncOrSync<T | SerializableOf<T>>)
+ | (() => AsyncOrSync<T | ResolvableOf<T>>)
 /**
  * - Always included on standard visit
  * - Cannot be dropped during cherry-picking
  */
- | AlwaysProp<T | SerializableOf<T>>;
+ | AlwaysProp<T | ResolvableOf<T>>;
 /**
  * Following is the list of acceptable Page props data types
  * Combines both eager and lazy prop data types for comprehensive prop handling
@@ -175,7 +168,7 @@ export type ComponentProps = Record<string, JSONDataTypes>;
  * @template Props - The page props object type to analyze
  */
 export type GetOptionalProps<Props> = {
-    [K in keyof Props]: Props[K] extends OptionalProp<any> ? K : Props[K] extends DeferProp<any> ? K : [undefined] extends Props[K] ? K : Props[K] extends MergeableProp<infer A> ? A extends DeferProp<any> ? K : never : never;
+    [K in keyof Props]: Props[K] extends OptionalProp<any> ? K : Props[K] extends DeferProp<any> ? K : [undefined] extends [Props[K]] ? K : Props[K] extends MergeableProp<infer A> ? A extends DeferProp<any> ? K : never : never;
 }[keyof Props];
 /**
  * Utility type to extract required prop keys from a props object
@@ -184,7 +177,7 @@ export type GetOptionalProps<Props> = {
  * @template Props - The page props object type to analyze
  */
 export type GetRequiredProps<Props> = {
-    [K in keyof Props]: Props[K] extends OptionalProp<any> ? never : Props[K] extends DeferProp<any> ? never : [undefined] extends Props[K] ? never : Props[K] extends MergeableProp<infer A> ? A extends DeferProp<any> ? never : K : K;
+    [K in keyof Props]: Props[K] extends OptionalProp<any> ? never : Props[K] extends DeferProp<any> ? never : [undefined] extends [Props[K]] ? never : Props[K] extends MergeableProp<infer A> ? A extends DeferProp<any> ? never : K : K;
 }[keyof Props];
 /**
  * Utility type to simplify value of a required prop by unwrapping branded types

package/build/src/types.js

@@ -0,0 +1 @@
+export {};