@deftui/addons 0.1.7 → 0.2.1

package/dist/form.d.mts

@@ -1,8 +1,14 @@
 import { RHFField } from "./react-hook-form/field.mjs";
 import { RHFForm } from "./react-hook-form/form.mjs";
+import { RHFCombobox } from "./react-hook-form/widgets/combobox.mjs";
+import { RHFSelect } from "./react-hook-form/widgets/select.mjs";
 export declare const RHF: {
   /** A Base UI form with a default grid layout; submission stays controlled by the caller. */
   Form: typeof RHFForm;
   /** Wraps `useController` with label, description, error, and control-prop forwarding. */
   Field: typeof RHFField;
+  /** One-liner component for Select, used under {@link RHF.Field}. */
+  Select: typeof RHFSelect;
+  /** One-liner component for Combobox, used under {@link RHF.Field}. */
+  Combobox: typeof RHFCombobox;
 };

package/dist/form.mjs

@@ -1,10 +1,16 @@
 import { RHFField } from "./react-hook-form/field.mjs";
 import { RHFForm } from "./react-hook-form/form.mjs";
+import { RHFCombobox } from "./react-hook-form/widgets/combobox.mjs";
+import { RHFSelect } from "./react-hook-form/widgets/select.mjs";
 // src/react-hook-form/index.ts
 const RHF = {
 	/** A Base UI form with a default grid layout; submission stays controlled by the caller. */
 	Form: RHFForm,
 	/** Wraps `useController` with label, description, error, and control-prop forwarding. */
-	Field: RHFField
+	Field: RHFField,
+	/** One-liner component for Select, used under {@link RHF.Field}. */
+	Select: RHFSelect,
+	/** One-liner component for Combobox, used under {@link RHF.Field}. */
+	Combobox: RHFCombobox
 };
 export { RHF };

package/dist/{modal-manager/host.mjs → modal-registry/provider.mjs}

@@ -1,17 +1,24 @@
-"use client";
 import { Component, Suspense, memo, useLayoutEffect } from "react";
-import { jsx } from "react/jsx-runtime";
-// src/modal-manager/host.tsx
-function ModalRenderer({ view, onPresent }) {
-	useLayoutEffect(() => onPresent(view.id, view.component), [
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/modal-registry/provider.tsx
+function ModalRenderer({ view, onPresent, onError }) {
+	useLayoutEffect(() => onPresent(view.id, view.definition), [
 		onPresent,
 		view.id,
-		view.component
+		view.definition
 	]);
-	const Content = view.component;
-	return /* @__PURE__ */ jsx(Content, {
-		...view.props,
-		modal: view.modal
+	const outlet = view.children.length > 0 ? view.children.map((child) => /* @__PURE__ */ jsx(ModalEntry, {
+		view: child,
+		onPresent,
+		onError
+	}, child.id)) : null;
+	const { root: Root, component: Content } = view.definition;
+	return /* @__PURE__ */ jsxs(Root, {
+		...view.rootProps,
+		children: [/* @__PURE__ */ jsx(Content, {
+			...view.props,
+			modal: view.modal
+		}), outlet]
 	});
 }
 var ModalErrorBoundary = class extends Component {
@@ -26,7 +33,7 @@ var ModalErrorBoundary = class extends Component {
 		return this.state.failed ? null : this.props.children;
 	}
 };
-/** Unchanged instances do not rerender when another instance opens or closes. */
+/** Unchanged calls keep their component instance when a sibling opens or closes. */
 const ModalEntry = memo(function ModalEntry({ view, onPresent, onError }) {
 	return /* @__PURE__ */ jsx(ModalErrorBoundary, {
 		onError: (error) => onError(view.id, error),
@@ -34,7 +41,8 @@ const ModalEntry = memo(function ModalEntry({ view, onPresent, onError }) {
 			fallback: null,
 			children: /* @__PURE__ */ jsx(ModalRenderer, {
 				view,
-				onPresent
+				onPresent,
+				onError
 			})
 		})
 	});

package/dist/modal-registry/registry.d.mts

@@ -0,0 +1,16 @@
+import { ModalRegistry, ModalRegistryOptions } from "./types.mjs";
+/**
+ * Create one registry for the application and define modal modules locally.
+ * Definitions are callable components, so modal modules remain Fast Refresh-compatible.
+ *
+ * @example
+ * export const registry = createModalRegistry({ hot: import.meta.hot, key: "modals" });
+ *
+ * export const EditDialog = registry.define(Dialog, EditDialogContent);
+ * function EditDialogContent({ id }: Modal<{ id: string }>) {
+ *   return <Dialog.Content>{id}</Dialog.Content>;
+ * }
+ *
+ * const handle = EditDialog.show({ id: "123" });
+ */
+export declare function createModalRegistry(options?: ModalRegistryOptions): ModalRegistry;

package/dist/modal-registry/registry.mjs

@@ -0,0 +1,263 @@
+import { ModalEntry } from "./provider.mjs";
+import { useEffect, useSyncExternalStore } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+// src/modal-registry/registry.tsx
+const EMPTY = [];
+/**
+* Create one registry for the application and define modal modules locally.
+* Definitions are callable components, so modal modules remain Fast Refresh-compatible.
+*
+* @example
+* export const registry = createModalRegistry({ hot: import.meta.hot, key: "modals" });
+*
+* export const EditDialog = registry.define(Dialog, EditDialogContent);
+* function EditDialogContent({ id }: Modal<{ id: string }>) {
+*   return <Dialog.Content>{id}</Dialog.Content>;
+* }
+*
+* const handle = EditDialog.show({ id: "123" });
+*/
+function createModalRegistry(options) {
+	const cache = options?.hot ? options.hot.data.__deftuiModalRegistries ??= /* @__PURE__ */ new Map() : void 0;
+	const cached = options && cache?.get(options.key);
+	if (cached) return cached;
+	let nextId = 0;
+	let snapshot = EMPTY;
+	let providerAttached = false;
+	const hotDefinitions = options?.hot ? options.hot.data.__deftuiModalDefinitions ??= /* @__PURE__ */ new Map() : void 0;
+	const roots = /* @__PURE__ */ new Set();
+	const instances = /* @__PURE__ */ new Map();
+	const callIds = /* @__PURE__ */ new WeakMap();
+	const listeners = /* @__PURE__ */ new Set();
+	function subscribe(listener) {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	}
+	function getSnapshot() {
+		return snapshot;
+	}
+	function getServerSnapshot() {
+		return EMPTY;
+	}
+	function createRootProps(instance) {
+		return {
+			open: instance.phase !== "closing",
+			onOpenChange: (open) => {
+				if (!open) instance.call.dismiss();
+			},
+			onOpenChangeComplete: (open) => {
+				if (!open && instance.phase === "closing") removeInstance(instance);
+			}
+		};
+	}
+	function publish() {
+		function build(instance) {
+			const children = [...instance.children].map(build);
+			const open = instance.phase !== "closing";
+			const existing = instance.view;
+			if (existing && existing.definition === instance.definition && existing.props === instance.props && existing.rootProps.open === open && sameViews(existing.children, children)) return existing;
+			return instance.view = {
+				id: instance.id,
+				definition: instance.definition,
+				props: instance.props,
+				modal: instance.modal,
+				rootProps: createRootProps(instance),
+				children
+			};
+		}
+		const next = [...roots].map(build);
+		if (sameViews(snapshot, next)) return;
+		snapshot = next;
+		listeners.forEach((listener) => listener());
+	}
+	function sameViews(left, right) {
+		return left.length === right.length && left.every((view, index) => view === right[index]);
+	}
+	function removeInstance(instance) {
+		if (!instances.delete(instance.id)) return;
+		roots.delete(instance);
+		callIds.delete(instance.call);
+		if (instance.parentId !== null) {
+			const parent = instances.get(instance.parentId);
+			parent?.children.delete(instance);
+			if (parent) closeWhenReady(parent);
+		}
+		publish();
+	}
+	function settleTree(instance, result) {
+		if (instance.phase === "active") {
+			instance.phase = "waiting";
+			instance.resolveResult(result);
+		}
+		for (const child of instance.children) settleTree(child, { status: "dismissed" });
+	}
+	function closeWhenReady(instance) {
+		if (instance.phase !== "waiting" || instance.children.size > 0) return;
+		if (!instance.presented) {
+			removeInstance(instance);
+			return;
+		}
+		instance.phase = "closing";
+	}
+	function requestCloseTree(instance) {
+		if (instance.phase === "closing") return;
+		for (const child of instance.children) requestCloseTree(child);
+		closeWhenReady(instance);
+	}
+	function finish(instance, result) {
+		if (instance.phase !== "active") return;
+		settleTree(instance, result);
+		requestCloseTree(instance);
+		publish();
+	}
+	function onPresent(id, definition) {
+		const instance = instances.get(id);
+		if (!instance || instance.definition !== definition) return;
+		instance.presented = true;
+	}
+	function discardInstance(instance, rejection) {
+		for (const child of instance.children) discardInstance(child);
+		instance.children.clear();
+		instances.delete(instance.id);
+		roots.delete(instance);
+		callIds.delete(instance.call);
+		if (instance.parentId !== null) instances.get(instance.parentId)?.children.delete(instance);
+		if (instance.phase !== "active") return;
+		instance.phase = "waiting";
+		if (rejection) instance.rejectResult(rejection.error);
+		else instance.resolveResult({ status: "dismissed" });
+	}
+	function onError(id, error) {
+		const instance = instances.get(id);
+		if (!instance) return;
+		const { parentId } = instance;
+		discardInstance(instance, { error });
+		const parent = parentId === null ? void 0 : instances.get(parentId);
+		if (parent) closeWhenReady(parent);
+		publish();
+	}
+	function clearInstances() {
+		const remaining = [...instances.values()];
+		instances.clear();
+		roots.clear();
+		publish();
+		for (const instance of remaining) {
+			instance.children.clear();
+			if (instance.phase !== "active") continue;
+			instance.phase = "waiting";
+			instance.resolveResult({ status: "dismissed" });
+		}
+	}
+	function attachProvider() {
+		if (providerAttached) throw new Error("A modal registry can only have one mounted Provider.");
+		providerAttached = true;
+		return () => {
+			providerAttached = false;
+			queueMicrotask(() => {
+				if (!providerAttached) clearInstances();
+			});
+		};
+	}
+	function Provider({ children }) {
+		const views = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+		useEffect(attachProvider, []);
+		return /* @__PURE__ */ jsxs(Fragment$1, { children: [children, views.map((view) => /* @__PURE__ */ jsx(ModalEntry, {
+			view,
+			onPresent,
+			onError
+		}, view.id))] });
+	}
+	function define(root, component) {
+		function ModalRoot() {
+			return null;
+		}
+		const definitionRecord = {
+			root,
+			component
+		};
+		const definition = Object.assign(ModalRoot, { show: ((props, showOptions) => open(definitionRecord, props, showOptions)) });
+		const hotName = options?.hot ? component.displayName ?? component.name : void 0;
+		if (hotDefinitions && hotName) {
+			const hotKey = `${options?.key}:${hotName}`;
+			const previous = hotDefinitions.get(hotKey);
+			if (previous) for (const instance of instances.values()) {
+				if (instance.definition !== previous || instance.phase !== "active") continue;
+				instance.definition = definitionRecord;
+				instance.presented = false;
+			}
+			hotDefinitions.set(hotKey, definitionRecord);
+			publish();
+		}
+		return definition;
+	}
+	function open(definition, props = {}, options) {
+		let parentId = null;
+		if (options?.parent) {
+			const id = callIds.get(options.parent);
+			if (id === void 0) throw new Error("The parent modal call belongs to another registry or is no longer active.");
+			const parent = instances.get(id);
+			if (!parent || parent.phase !== "active") throw new Error("A child call cannot be opened from a settled parent.");
+			parentId = id;
+		}
+		const id = nextId++;
+		let resolveResult;
+		let rejectResult;
+		const result = new Promise((resolve, reject) => {
+			resolveResult = resolve;
+			rejectResult = reject;
+		});
+		let instance;
+		const call = Object.assign(result, {
+			type: "modal-call",
+			update: (patch) => {
+				if (instance.phase !== "active") return;
+				instance.props = {
+					...instance.props,
+					...patch
+				};
+				publish();
+			},
+			resolve: (value) => finish(instance, {
+				status: "resolved",
+				value
+			}),
+			dismiss: () => finish(instance, { status: "dismissed" })
+		});
+		instance = {
+			id,
+			definition,
+			parentId,
+			children: /* @__PURE__ */ new Set(),
+			props,
+			phase: "active",
+			presented: false,
+			resolveResult,
+			rejectResult,
+			call,
+			modal: {
+				call,
+				resolve: call.resolve,
+				dismiss: call.dismiss
+			}
+		};
+		instances.set(id, instance);
+		if (parentId === null) roots.add(instance);
+		else instances.get(parentId)?.children.add(instance);
+		callIds.set(call, id);
+		publish();
+		return call;
+	}
+	function dismissAll() {
+		for (const instance of [...roots].reverse()) finish(instance, { status: "dismissed" });
+	}
+	const registry = {
+		Provider,
+		define,
+		dismissAll
+	};
+	if (cache && options) cache.set(options.key, registry);
+	return registry;
+}
+export { createModalRegistry };

package/dist/modal-registry/types.d.mts

@@ -0,0 +1,75 @@
+import { ComponentType, FunctionComponent, ReactNode } from "react";
+/** Props the registry injects into a Base UI Dialog, AlertDialog, Drawer, or Sheet root. */
+export interface ModalRootProps {
+  open: boolean;
+  onOpenChange: (open: boolean, details?: unknown) => void;
+  onOpenChangeComplete: (open: boolean) => void;
+}
+/** A Base UI root component controlled by the registry. */
+export type ModalRootComponent = ComponentType<ModalRootProps & {
+  children?: ReactNode;
+}>;
+/** Per-call controls exposed to the modal component. */
+export interface ModalController<Props extends object = {}, Output = void> {
+  /** The current call, suitable for `show(..., { parent: modal.call })`. */
+  readonly call: ModalCall<Props, Output>;
+  /** Resolve the result and start closing. The first result or dismissal wins. */
+  resolve: (value: Output) => void;
+  /** Dismiss normally, without rejecting the returned promise. */
+  dismiss: () => void;
+}
+/** Props for a modal component. */
+export type Modal<Props extends object = {}, Output = void> = Props & {
+  modal: ModalController<Props, Output>;
+};
+export type ModalResult<Output> = {
+  status: "resolved";
+  value: Output;
+} | {
+  status: "dismissed";
+};
+/** A call handle usable as another call's `parent`. */
+export type ModalHandle = {
+  readonly type: "modal-call";
+};
+export interface ModalCall<Props, Output> extends Promise<ModalResult<Output>>, ModalHandle {
+  /** Shallow-merge new props into this call while it is still active. */
+  update: (patch: Partial<Props>) => void;
+  /** Resolve this call and start closing. */
+  resolve: (value: Output) => void;
+  /** Dismiss this call and its child calls. */
+  dismiss: () => void;
+}
+/** A callable definition doubles as a Fast Refresh-compatible component handle. */
+export type ModalDefinition<Props extends object = {}, Output = void> = FunctionComponent<{}> & {
+  /** Open this definition through its owning registry. */
+  readonly show: ModalShow<Props, Output>;
+};
+export interface ModalShowOptions {
+  /** Render this call inside the parent call's root. */
+  parent?: ModalHandle;
+}
+type ModalArguments<Props> = {} extends Props ? [props?: Props] : [props: Props];
+interface ModalShow<Props, Output> {
+  (...args: ModalArguments<Props>): ModalCall<Props, Output>;
+  (props: Props, options: ModalShowOptions): ModalCall<Props, Output>;
+}
+export interface ModalRegistry {
+  /** Mount once around the application. Unmounting dismisses pending calls. */
+  Provider: ComponentType<{
+    children?: ReactNode;
+  }>;
+  /** Register a modal component. The registry controls the root and injects child calls through its children. */
+  define<Props extends object, Output = void>(root: ModalRootComponent, component: ComponentType<Modal<Props, Output>>): ModalDefinition<Props, Output>;
+  /** Dismiss every active call, waiting for children to exit before their parents. */
+  dismissAll: () => void;
+}
+export interface ModalRegistryOptions {
+  /** The registration module's `import.meta.hot`. */
+  hot?: {
+    data: Record<string, unknown>;
+  };
+  /** Stable across updates and unique among registries in the same module. */
+  key: string;
+}
+export {};

package/dist/modal.d.mts

@@ -1,3 +1,3 @@
-import { ModalController, ModalInput, ModalManager, ModalManagerOptions, ModalProps, ModalRegistry, ModalResult, ModalRootProps, ModalValue } from "./modal-manager/types.mjs";
-import { createModalManager } from "./modal-manager/manager.mjs";
-export { type ModalController, type ModalInput, type ModalManager, type ModalManagerOptions, type ModalProps, type ModalRegistry, type ModalResult, type ModalRootProps, type ModalValue, createModalManager };
+import { Modal, ModalCall, ModalController, ModalDefinition, ModalHandle, ModalRegistry, ModalRegistryOptions, ModalResult, ModalRootComponent, ModalRootProps, ModalShowOptions } from "./modal-registry/types.mjs";
+import { createModalRegistry } from "./modal-registry/registry.mjs";
+export { type Modal, type ModalCall, type ModalController, type ModalDefinition, type ModalHandle, type ModalRegistry, type ModalRegistryOptions, type ModalResult, type ModalRootComponent, type ModalRootProps, type ModalShowOptions, createModalRegistry };

package/dist/modal.mjs

@@ -1 +1 @@
-export { createModalManager } from "./modal-manager/manager.mjs";
+export { createModalRegistry } from "./modal-registry/registry.mjs";

package/dist/react-hook-form/widgets/combobox.d.mts

@@ -0,0 +1,9 @@
+import { Options } from "./types.mjs";
+import { Combobox } from "@deftui/react";
+import { ComponentProps } from "react";
+type Props<V extends string> = {
+  options: Options<V>;
+  emptyLabel?: string;
+} & Omit<ComponentProps<typeof Combobox>, "items" | "children"> & Pick<ComponentProps<typeof Combobox.Input>, "size" | "placeholder" | "showClear" | "className">;
+export declare function RHFCombobox<V extends string>(props: Props<V>): import("react").JSX.Element;
+export {};

package/dist/react-hook-form/widgets/combobox.mjs

@@ -0,0 +1,21 @@
+import { Combobox } from "@deftui/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/react-hook-form/widgets/combobox.tsx
+function RHFCombobox(props) {
+	const { options, size, placeholder, showClear, className, emptyLabel, ...rootProps } = props;
+	return /* @__PURE__ */ jsxs(Combobox, {
+		...rootProps,
+		items: options,
+		children: [/* @__PURE__ */ jsx(Combobox.Input, {
+			size,
+			placeholder,
+			showClear,
+			className
+		}), /* @__PURE__ */ jsxs(Combobox.Content, { children: [/* @__PURE__ */ jsx(Combobox.Empty, { children: emptyLabel }), /* @__PURE__ */ jsx(Combobox.List, { children: options.map((option) => /* @__PURE__ */ jsx(Combobox.Item, {
+			value: option.value,
+			disabled: option.disabled,
+			children: option.label
+		}, option.value)) })] })]
+	});
+}
+export { RHFCombobox };

package/dist/react-hook-form/widgets/select.d.mts

@@ -0,0 +1,8 @@
+import { Options } from "./types.mjs";
+import { Select } from "@deftui/react";
+import { ComponentProps } from "react";
+type Props<V extends string> = {
+  options: Options<V>;
+} & Omit<ComponentProps<typeof Select>, "items" | "children"> & Pick<ComponentProps<typeof Select.Trigger>, "size" | "className"> & Pick<ComponentProps<typeof Select.Value>, "placeholder" | "className">;
+export declare function RHFSelect<V extends string>(props: Props<V>): import("react").JSX.Element;
+export {};

package/dist/react-hook-form/widgets/select.mjs

@@ -0,0 +1,20 @@
+import { Select } from "@deftui/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/react-hook-form/widgets/select.tsx
+function RHFSelect(props) {
+	const { options, size, placeholder, className, ...rootProps } = props;
+	return /* @__PURE__ */ jsxs(Select, {
+		...rootProps,
+		items: options,
+		children: [/* @__PURE__ */ jsx(Select.Trigger, {
+			size,
+			className,
+			children: /* @__PURE__ */ jsx(Select.Value, { placeholder })
+		}), /* @__PURE__ */ jsx(Select.Content, { children: options.map((option) => /* @__PURE__ */ jsx(Select.Item, {
+			value: option.value,
+			disabled: option.disabled,
+			children: option.label
+		}, option.value)) })]
+	});
+}
+export { RHFSelect };

package/dist/react-hook-form/widgets/types.d.mts

@@ -0,0 +1,5 @@
+export type Options<V extends string> = readonly {
+  label: string;
+  value: V;
+  disabled?: boolean;
+}[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftui/addons",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/KiriRainCat/deftui.git",
@@ -40,7 +40,7 @@
     "fix": "vp check --fix"
   },
   "devDependencies": {
-    "@deftui/react": "^0.1.7",
+    "@deftui/react": "^0.2.1",
     "@tanstack/react-router": "^1.170.46",
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
@@ -49,7 +49,7 @@
     "vite-plus": "catalog:"
   },
   "peerDependencies": {
-    "@deftui/react": "^0.1.7",
+    "@deftui/react": "^0.2.1",
     "@tanstack/react-router": "^1.170.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/dist/modal-manager/manager.d.mts

@@ -1,15 +0,0 @@
-import { ModalManager, ModalManagerOptions, ModalProps, ModalRegistry } from "./types.mjs";
-import { ComponentType } from "react";
-/**
- * Create once outside rendering; accepts regular, memo, and lazy components.
- *
- * Call `open` on the client, outside rendering. The Host renders nothing during SSR.
- *
- * Pass the caller's `hot` and a stable `key` to retain instances and promises during HMR.
- * Reload the page when the manager implementation changes.
- *
- * @example
- * export const modals = createModalManager({ edit: EditModal }, { hot: import.meta.hot, key: "modals" });
- * if (import.meta.hot) import.meta.hot.accept();
- */
-export declare function createModalManager<Registry extends ModalRegistry>(registry: Registry & { [Key in keyof Registry]: Registry[Key] extends ComponentType<infer Props> ? (Props extends ModalProps<never> ? unknown : never) : never; }, options?: ModalManagerOptions): ModalManager<Registry>;

package/dist/modal-manager/manager.mjs

@@ -1,177 +0,0 @@
-"use client";
-import { ModalEntry } from "./host.mjs";
-import { useEffect, useSyncExternalStore } from "react";
-import { jsx } from "react/jsx-runtime";
-// src/modal-manager/manager.tsx
-const EMPTY = [];
-/**
-* Create once outside rendering; accepts regular, memo, and lazy components.
-*
-* Call `open` on the client, outside rendering. The Host renders nothing during SSR.
-*
-* Pass the caller's `hot` and a stable `key` to retain instances and promises during HMR.
-* Reload the page when the manager implementation changes.
-*
-* @example
-* export const modals = createModalManager({ edit: EditModal }, { hot: import.meta.hot, key: "modals" });
-* if (import.meta.hot) import.meta.hot.accept();
-*/
-function createModalManager(registry, options) {
-	const cache = options?.hot ? options.hot.data.__deftuiModalManagers ??= /* @__PURE__ */ new Map() : void 0;
-	const cached = options && cache?.get(options.key);
-	if (cached) {
-		cached.setRegistry(registry);
-		return cached;
-	}
-	let definitions = registry;
-	let snapshot = EMPTY;
-	let nextId = 0;
-	let hostAttached = false;
-	const instances = /* @__PURE__ */ new Map();
-	const listeners = /* @__PURE__ */ new Set();
-	function publish() {
-		snapshot = Array.from(instances.values(), (instance) => instance.view);
-		listeners.forEach((listener) => listener());
-	}
-	function subscribe(listener) {
-		listeners.add(listener);
-		return () => {
-			listeners.delete(listener);
-		};
-	}
-	function getSnapshot() {
-		return snapshot;
-	}
-	function getServerSnapshot() {
-		return EMPTY;
-	}
-	function remove(id) {
-		if (instances.delete(id)) publish();
-	}
-	function finish(instance, result) {
-		if (instance.settled) return;
-		instance.settled = true;
-		if (instance.presented) {
-			instance.view = {
-				...instance.view,
-				modal: {
-					...instance.view.modal,
-					rootProps: {
-						...instance.view.modal.rootProps,
-						open: false
-					}
-				}
-			};
-			publish();
-		} else remove(instance.view.id);
-		instance.resolve(result);
-	}
-	function onPresent(id, component) {
-		const instance = instances.get(id);
-		if (instance?.view.component === component) instance.presented = true;
-	}
-	function onError(id, error) {
-		const instance = instances.get(id);
-		if (!instance) return;
-		remove(id);
-		if (!instance.settled) {
-			instance.settled = true;
-			instance.reject(error);
-		}
-	}
-	function attachHost() {
-		if (hostAttached) throw new Error("A modal manager can only have one mounted Host.");
-		hostAttached = true;
-		return () => {
-			hostAttached = false;
-			queueMicrotask(() => {
-				if (hostAttached) return;
-				const remaining = Array.from(instances.values());
-				instances.clear();
-				publish();
-				for (const instance of remaining) {
-					if (instance.settled) continue;
-					instance.settled = true;
-					instance.resolve({ status: "dismissed" });
-				}
-			});
-		};
-	}
-	function Host() {
-		const views = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-		useEffect(attachHost, []);
-		return views.map((view) => /* @__PURE__ */ jsx(ModalEntry, {
-			view,
-			onPresent,
-			onError
-		}, view.id));
-	}
-	function open(key, props = {}) {
-		const definition = definitions[key];
-		if (!definition) throw new Error(`Unknown modal: ${key}`);
-		return new Promise((resolve, reject) => {
-			const id = nextId++;
-			const instance = {
-				key,
-				presented: false,
-				settled: false,
-				resolve,
-				reject,
-				view: {
-					id,
-					component: definition,
-					props,
-					modal: {
-						resolve: (value) => finish(instance, {
-							status: "resolved",
-							value
-						}),
-						dismiss: () => finish(instance, { status: "dismissed" }),
-						rootProps: {
-							open: true,
-							onOpenChange: (isOpen) => {
-								if (!isOpen) finish(instance, { status: "dismissed" });
-							},
-							onOpenChangeComplete: (isOpen) => {
-								if (!isOpen && instance.settled) remove(id);
-							}
-						}
-					}
-				}
-			};
-			instances.set(id, instance);
-			publish();
-		});
-	}
-	function dismissAll() {
-		for (const instance of instances.values()) finish(instance, { status: "dismissed" });
-	}
-	function setRegistry(nextRegistry) {
-		definitions = nextRegistry;
-		for (const instance of instances.values()) {
-			if (instance.settled) continue;
-			const definition = definitions[instance.key];
-			if (!definition) {
-				finish(instance, { status: "dismissed" });
-				continue;
-			}
-			const component = definition;
-			if (component === instance.view.component) continue;
-			instance.presented = false;
-			instance.view = {
-				...instance.view,
-				component
-			};
-		}
-		publish();
-	}
-	const manager = {
-		Host,
-		open,
-		dismissAll,
-		setRegistry
-	};
-	if (options) cache?.set(options.key, manager);
-	return manager;
-}
-export { createModalManager };

package/dist/modal-manager/types.d.mts

@@ -1,55 +0,0 @@
-import { ComponentType } from "react";
-/** Spread onto a controlled Dialog, AlertDialog, or Sheet root. */
-export interface ModalRootProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  onOpenChangeComplete: (open: boolean) => void;
-}
-export interface ModalController<Value> {
-  /** Spread all three props onto the Root; forward callbacks when overriding them. */
-  rootProps: ModalRootProps;
-  /** Resolve the result and start closing. The first resolution or dismissal wins. */
-  resolve: (value: Value) => void;
-  /** Dismiss normally, without rejecting the returned promise. */
-  dismiss: () => void;
-}
-/** Intersect with the business component's props. The manager supplies `modal`. */
-export interface ModalProps<Value = void> {
-  modal: ModalController<Value>;
-}
-export type ModalRegistry = Record<string, ComponentType<never>>;
-type ModalComponentProps<T extends ComponentType<never>> = T extends ComponentType<infer Props> ? Props : never;
-type ModalArguments<Props> = {} extends Props ? [props?: Props] : [props: Props];
-export type ModalInput<T extends ComponentType<never>> = Omit<ModalComponentProps<T>, "modal">;
-export type ModalValue<T extends ComponentType<never>> = ModalComponentProps<T> extends ModalProps<infer Value> ? Value : never;
-export type ModalResult<Value> = {
-  status: "resolved";
-  value: Value;
-} | {
-  status: "dismissed";
-};
-export interface ModalManagerOptions {
-  /** The registration module's `import.meta.hot`. No HMR callbacks are registered. */
-  hot?: {
-    data: Record<string, unknown>;
-  };
-  /** Stable across updates and unique among managers in the same module. */
-  key: string;
-}
-export interface ModalManager<Registry extends ModalRegistry> {
-  /** Mount once inside the required contexts. Unmounting dismisses pending calls. */
-  Host: ComponentType;
-  /**
-   * Each call creates an independent instance.
-   *
-   * Resolves when closing starts; unmounts after exit.
-   *
-   * Loading/rendering failures reject; normal dismissal resolves with `status: "dismissed"`.
-   */
-  open: <Key extends Extract<keyof Registry, string>>(key: Key, ...args: ModalArguments<ModalInput<Registry[Key]>>) => Promise<ModalResult<ModalValue<Registry[Key]>>>;
-  /** Dismiss all current instances, preserving their exit animations. */
-  dismissAll: () => void;
-  /** Replace definitions, retaining promises. Removed entries dismiss; new components may reset local state. */
-  setRegistry: (registry: Registry) => void;
-}
-export {};