feat: allow omitted void modal input

README.md

@@ -477,6 +477,7 @@ Type exports:
 - `ModalId`
 - `ModalInstanceId`
 - `ModalInstanceStatus`
+- `ModalOpenArgs`
 - `ModalManager`
 - `ModalOptions`
 - `ModalProviderProps`
@@ -510,7 +511,7 @@ Returns the modal manager from the nearest `ModalProvider`.
 
 **Returns:**
 
-- `open(modal, input): ModalHandle<TResult>`
+- `open(modal, ...args: ModalOpenArgs<TInput>): ModalHandle<TResult>`
 - `confirm(params): Promise<ConfirmModalResult>`
 - `dismiss(instanceId, reason?): void`
 - `closeAll(reason?): void`
@@ -524,13 +525,15 @@ Creates a typed modal definition.
 - `id?: string` — Optional stable modal definition id. A unique definition id is generated when omitted
 - `component: ModalComponent<TInput, TResult>` — React component that receives typed input and completion callbacks
 
+For a modal declared with `TInput = void` (or `undefined`), omit the input argument: `modal.open(infoModal)`. Modals with any other input type still require it.
+
 ### `createModalRegistry(definitions)`
 
 Creates a typed registry for opening modals by key. Bind it directly with `<ModalProvider registry={registry}>`.
 
 **Returns:**
 
-- `open(key, input): ModalHandle<TResult>`
+- `open(key, ...args: ModalOpenArgs<TInput>): ModalHandle<TResult>` — input is optional only when the registered modal uses `void` or `undefined`
 - `confirm(params): Promise<ConfirmModalResult>`
 - `dismiss(instanceId, reason?): void`
 - `closeAll(reason?): void`
@@ -540,7 +543,7 @@ Creates a typed registry for opening modals by key. Bind it directly with `<Moda
 
 Props passed to custom modal components.
 
-- `input: TInput` — Input supplied to `modal.open()`
+- `input: ModalOpenArgs<TInput>[0]` — Input supplied to `modal.open()`; `undefined` when a `void` input is omitted
 - `instanceId: string` — Runtime modal instance id
 - `close(result: TResult): void` — Resolve the modal promise and begin closing the instance
 - `dismiss(reason?): void` — Reject with `ModalDismissError` and begin closing the instance

scripts/benchmark-lifecycle.mjs

@@ -124,7 +124,7 @@ function unmountProvider({ container, root }) {
 }
 
 function openHandled(manager) {
-  const handle = manager.open(benchmarkModal, undefined);
+  const handle = manager.open(benchmarkModal);
 
   void handle.catch(() => undefined);
 
@@ -276,7 +276,7 @@ scenarios.push(
     name: "typed registry route, open, and render",
     run: ({ registry }) => {
       flushSync(() => {
-        const handle = registry.open("benchmark", undefined);
+        const handle = registry.open("benchmark");
         void handle.catch(() => undefined);
       });
     },

scripts/package-consumer.typecheck.ts

@@ -31,14 +31,37 @@ const renameModal = createModal<RenameInput, RenameResult>({
   component: RenameModal,
 });
 const registry = createModalRegistry({ rename: renameModal });
+
+declare const manager: ModalManager;
+
 const handle: ModalHandle<RenameResult> = registry.open("rename", {
   currentName: "Quarterly report",
 });
 
 // @ts-expect-error The packed declarations must reject invalid modal input.
 registry.open("rename", { reportName: "Quarterly report" });
 
-declare const manager: ModalManager;
+// @ts-expect-error A modal with required input cannot be opened without it.
+manager.open(renameModal);
+// @ts-expect-error A registry entry with required input cannot be opened without it.
+registry.open("rename");
+
+type EmptyModalValue = ReturnType<VoidFunction>;
+
+function InfoModal(
+  _: ModalComponentProps<EmptyModalValue, EmptyModalValue>,
+): ReactNode {
+  return null;
+}
+
+const infoModal = createModal<EmptyModalValue, EmptyModalValue>({
+  component: InfoModal,
+});
+const infoRegistry = createModalRegistry({ info: infoModal });
+const directInfoHandle: ModalHandle<EmptyModalValue> = manager.open(infoModal);
+const registryInfoHandle: ModalHandle<EmptyModalValue> =
+  infoRegistry.open("info");
+
 const confirmation: Promise<ConfirmModalResult> = manager.confirm({
   title: "Continue?",
 });
@@ -54,5 +77,7 @@ const providerProps: ComponentProps<typeof ModalProvider> = {
 };
 
 void confirmation;
+void directInfoHandle;
 void handle;
+void registryInfoHandle;
 void providerProps;

src/hooks/useModalManager/useModalManager.types.ts

@@ -3,6 +3,7 @@ import type {
   ModalDefinition,
   ModalDismissReason,
   ModalInstanceId,
+  ModalOpenArgs,
 } from "../../types";
 
 export interface ModalHandle<TResult> extends Promise<TResult> {
@@ -13,7 +14,7 @@ export interface ModalHandle<TResult> extends Promise<TResult> {
 export interface ModalManager {
   open: <TInput, TResult>(
     modal: ModalDefinition<TInput, TResult>,
-    input: TInput,
+    ...args: ModalOpenArgs<TInput>
   ) => ModalHandle<TResult>;
   confirm: (params: ConfirmModalParams) => Promise<ConfirmModalResult>;
   dismiss: (instanceId: ModalInstanceId, reason?: ModalDismissReason) => void;

src/index.ts

@@ -35,4 +35,5 @@ export type {
   ModalId,
   ModalInstanceId,
   ModalInstanceStatus,
+  ModalOpenArgs,
 } from "./types";

src/lifecycle/__tests__/modalLifecycle.test.ts

@@ -326,7 +326,7 @@ describe("modal lifecycle", () => {
           "Reject with Error",
         ),
     };
-    const preserved = lifecycle.open(errorModal, undefined);
+    const preserved = lifecycle.open(errorModal);
     const preservedOutcome = preserved.catch((error: unknown) => error);
     const [preservedInstance] = lifecycle.getSnapshot().instances;
 

src/lifecycle/modalLifecycle.ts

@@ -5,6 +5,7 @@ import type {
   ModalDefinition,
   ModalDismissReason,
   ModalInstanceId,
+  ModalOpenArgs,
 } from "../types";
 import type {
   CreateModalLifecycleOptions,
@@ -139,8 +140,9 @@ export function createModalLifecycle(
     getServerSnapshot: () => serverSnapshot,
     open: <TInput, TResult>(
       modal: ModalDefinition<TInput, TResult>,
-      input: TInput,
+      ...args: ModalOpenArgs<TInput>
     ): ModalLifecycleHandle<TResult> => {
+      const input = args[0];
       const instanceId = `modal-${String(nextInstanceIndex)}`;
       nextInstanceIndex += 1;
 

src/lifecycle/modalLifecycle.types.ts

@@ -5,6 +5,7 @@ import type {
   ModalId,
   ModalInstanceId,
   ModalInstanceStatus,
+  ModalOpenArgs,
 } from "../types";
 
 export interface ModalLifecycleInstance {
@@ -35,7 +36,7 @@ export interface ModalLifecycle extends ModalLifecycleObservation {
   dismiss: (instanceId: ModalInstanceId, reason?: ModalDismissReason) => void;
   open: <TInput, TResult>(
     modal: ModalDefinition<TInput, TResult>,
-    input: TInput,
+    ...args: ModalOpenArgs<TInput>
   ) => ModalLifecycleHandle<TResult>;
   setCloseDelayMs: (closeDelayMs: number) => void;
 }

src/provider/ModalProvider.stories.fixtures.tsx

@@ -81,11 +81,9 @@ export function DismissRejectDemo(): ReactElement {
   };
 
   const handleReject = (): void => {
-    void modal
-      .open(rejectWithStringModal, undefined)
-      .catch((error: unknown) => {
-        setState(describeRejection(error));
-      });
+    void modal.open(rejectWithStringModal).catch((error: unknown) => {
+      setState(describeRejection(error));
+    });
   };
 
   return (

src/provider/__tests__/ModalProvider.fixtures.tsx

@@ -280,17 +280,15 @@ export function RejectExample(): ReactNode {
   const modal = useModalManager();
 
   const handleOpenStringReject = (): void => {
-    void modal
-      .open(rejectWithStringModal, undefined)
-      .catch((error: unknown) => {
-        if (isInstanceOf(error, ModalRejectError)) {
-          document.body.dataset.rejectValue = String(error.value);
-        }
-      });
+    void modal.open(rejectWithStringModal).catch((error: unknown) => {
+      if (isInstanceOf(error, ModalRejectError)) {
+        document.body.dataset.rejectValue = String(error.value);
+      }
+    });
   };
 
   const handleOpenErrorReject = (): void => {
-    void modal.open(rejectWithErrorModal, undefined).catch((error: unknown) => {
+    void modal.open(rejectWithErrorModal).catch((error: unknown) => {
       if (isError(error)) {
         document.body.dataset.rejectMessage = error.message;
       }

src/registry/createModal.ts

@@ -17,6 +17,6 @@ export function createModal<TInput, TResult>(
 
   return {
     ...definition,
-    open: (manager, input) => manager.open(definition, input),
+    open: (manager, ...args) => manager.open(definition, ...args),
   };
 }

src/registry/createModal.types.ts

@@ -1,5 +1,10 @@
 import type { ModalHandle, ModalManager } from "../hooks";
-import type { ModalComponent, ModalDefinition, ModalId } from "../types";
+import type {
+  ModalComponent,
+  ModalDefinition,
+  ModalId,
+  ModalOpenArgs,
+} from "../types";
 
 export interface ModalOptions<TInput, TResult> {
   id?: ModalId;
@@ -10,5 +15,8 @@ export interface RegisteredModalDefinition<
   TInput,
   TResult,
 > extends ModalDefinition<TInput, TResult> {
-  open(manager: ModalManager, input: TInput): ModalHandle<TResult>;
+  open(
+    manager: ModalManager,
+    ...args: ModalOpenArgs<TInput>
+  ): ModalHandle<TResult>;
 }

src/registry/createModalRegistry.ts

@@ -10,7 +10,11 @@ import {
   MODAL_REGISTRY_UNKNOWN_KEY_ERROR,
 } from "./createModalRegistry.constants";
 import type { ModalHandle, ModalManager } from "../hooks";
-import type { ModalDismissReason, ModalInstanceId } from "../types";
+import type {
+  ModalDismissReason,
+  ModalInstanceId,
+  ModalOpenArgs,
+} from "../types";
 import type {
   ModalRegistry,
   ModalRegistryDefinitions,
@@ -58,9 +62,9 @@ export function createModalRegistry<
 
   function open<TKey extends keyof TDefinitions & string>(
     key: TKey,
-    input: ModalRegistryInput<TDefinitions[TKey]>,
+    ...args: ModalOpenArgs<ModalRegistryInput<TDefinitions[TKey]>>
   ): ReturnType<TDefinitions[TKey]["open"]>;
-  function open(key: string, input: unknown): ModalHandle<unknown> {
+  function open(key: string, input?: unknown): ModalHandle<unknown> {
     assertTrue(
       hasProperty(definitions, key),
       () => `${MODAL_REGISTRY_UNKNOWN_KEY_ERROR}: ${key}`,

src/registry/createModalRegistry.types.ts

@@ -1,7 +1,11 @@
 import type { ModalHandle, ModalManager } from "../hooks";
+import type { ModalOpenArgs } from "../types";
 
 export interface ModalRegistryEntry<TInput, TResult> {
-  open(manager: ModalManager, input: TInput): ModalHandle<TResult>;
+  open(
+    manager: ModalManager,
+    ...args: ModalOpenArgs<TInput>
+  ): ModalHandle<TResult>;
 }
 
 export type ModalRegistryDefinitions = Readonly<
@@ -33,6 +37,6 @@ export interface ModalRegistry<
   dismiss: ModalManager["dismiss"];
   open: <TKey extends keyof TDefinitions & string>(
     key: TKey,
-    input: ModalRegistryInput<TDefinitions[TKey]>,
+    ...args: ModalOpenArgs<ModalRegistryInput<TDefinitions[TKey]>>
   ) => ReturnType<TDefinitions[TKey]["open"]>;
 }

src/types/index.ts

@@ -6,4 +6,5 @@ export type {
   ModalId,
   ModalInstanceId,
   ModalInstanceStatus,
+  ModalOpenArgs,
 } from "./modal";

src/types/modal.ts

@@ -5,8 +5,14 @@ export type ModalInstanceId = string;
 export type ModalDismissReason = "dismiss" | "close-all" | "provider-unmount";
 export type ModalInstanceStatus = "open" | "closing";
 
+type InputlessModalValue = ReturnType<VoidFunction>;
+
+export type ModalOpenArgs<TInput> = [TInput] extends [InputlessModalValue]
+  ? [input?: TInput]
+  : [input: TInput];
+
 export interface ModalComponentProps<TInput, TResult> {
-  input: TInput;
+  input: ModalOpenArgs<TInput>[0];
   instanceId: ModalInstanceId;
   close: (result: TResult) => void;
   dismiss: (reason?: ModalDismissReason) => void;