@lerx/promise-modal 0.12.2 → 0.12.3

package/dist/index.mjs

@@ -2,13 +2,13 @@ import { jsx, jsxs } from 'react/jsx-runtime';
 import { createContext, useContext, useMemo, forwardRef, memo, useRef, useState, useLayoutEffect, useCallback, Fragment, useEffect, useImperativeHandle } from 'react';
 import { convertMsFromDuration } from '@winglet/common-utils/convert';
 import { useMemorize, useSnapshot, useReference, useOnMountLayout, useHandle, useVersion, useOnMount, useOnUnmount } from '@winglet/react-utils/hook';
+import { map } from '@winglet/common-utils/array';
 import { polynomialHash } from '@winglet/common-utils/hash';
 import { getRandomString, counterFactory } from '@winglet/common-utils/lib';
 import { styleManagerFactory, destroyScope } from '@winglet/style-utils/style-manager';
 import { compressCss, cxLite } from '@winglet/style-utils/util';
 import { isPlainObject, isString, isFunction } from '@winglet/common-utils/filter';
 import { createPortal } from 'react-dom';
-import { map } from '@winglet/common-utils/array';
 import { withErrorBoundary } from '@winglet/react-utils/hoc';
 import { renderComponent } from '@winglet/react-utils/render';
 
@@ -28,11 +28,38 @@ class ModalManager {
         return ModalManager.__anchor__ !== null;
     }
     static get prerender() {
-        return ModalManager.__prerenderList__;
+        return map(ModalManager.__prerenderList__, (entry) => entry.modal);
     }
     static set openHandler(handler) {
         ModalManager.__openHandler__ = handler;
+        const entries = ModalManager.__prerenderList__;
         ModalManager.__prerenderList__ = [];
+        for (const entry of entries)
+            try {
+                if (entry.dispatch)
+                    entry.dispatch();
+                else
+                    handler(entry.modal);
+            }
+            catch {
+            }
+    }
+    static bindPrerender(modal, dispatch) {
+        const list = ModalManager.__prerenderList__;
+        for (let index = 0; index < list.length; index++)
+            if (list[index].modal === modal) {
+                list[index].dispatch = dispatch;
+                return;
+            }
+    }
+    static cancelPrerender(modal) {
+        const list = ModalManager.__prerenderList__;
+        for (let index = 0; index < list.length; index++)
+            if (list[index].modal === modal) {
+                list.splice(index, 1);
+                return true;
+            }
+        return false;
     }
     static set refreshHandler(handler) {
         ModalManager.__refreshHandler__ = handler;
@@ -53,11 +80,10 @@ class ModalManager {
     static reset() {
         ModalManager.__anchor__ = null;
         ModalManager.__prerenderList__ = [];
-        ModalManager.__openHandler__ = ((modal) => {
-            ModalManager.__prerenderList__.push(modal);
-        });
+        ModalManager.__openHandler__ = ModalManager.__defaultOpenHandler__;
         ModalManager.__refreshHandler__ = undefined;
         destroyScope(ModalManager.__scope__);
+        ModalManager.__styleManager__ = styleManagerFactory(ModalManager.__scope__);
     }
     static open(modal) {
         return ModalManager.__openHandler__(modal);
@@ -69,14 +95,17 @@ ModalManager.__hash__ = polynomialHash(ModalManager.__scope__);
 ModalManager.__styleManager__ = styleManagerFactory(ModalManager.__scope__);
 ModalManager.__styleSheetDefinition__ = new Map();
 ModalManager.__prerenderList__ = [];
-ModalManager.__openHandler__ = ((modal) => {
-    ModalManager.__prerenderList__.push(modal);
-});
+ModalManager.__defaultOpenHandler__ = (modal) => {
+    ModalManager.__prerenderList__.push({ modal });
+    return undefined;
+};
+ModalManager.__openHandler__ = ModalManager.__defaultOpenHandler__;
 
-const closeModal = (modalNode, refresh = true) => {
-    if (modalNode.visible === false)
-        return;
-    modalNode.onClose();
+const DEFAULT_Z_INDEX = 1000;
+const DEFAULT_ANIMATION_DURATION = '300ms';
+const DEFAULT_BACKDROP_COLOR = 'rgba(0, 0, 0, 0.5)';
+
+const hideModal = (modalNode, refresh = true) => {
     modalNode.onHide();
     if (refresh)
         ModalManager.refresh();
@@ -85,85 +114,108 @@ const closeModal = (modalNode, refresh = true) => {
     return setTimeout(() => modalNode.onDestroy(), modalNode.duration);
 };
 
-const subscribeAbortSignal = (modalNode, signal) => {
-    if (signal === undefined)
-        return null;
-    const handleAbort = () => closeModal(modalNode);
-    signal.addEventListener('abort', handleAbort, { once: true });
-    return () => signal.removeEventListener('abort', handleAbort);
+const closeModal = (modalNode, refresh = true) => {
+    if (modalNode.visible === false)
+        return;
+    modalNode.onClose();
+    return hideModal(modalNode, refresh);
 };
 
-const alertHandler = (args) => {
-    const modalNode = ModalManager.open({
-        ...args,
-        type: 'alert',
-    });
-    const unsubscribe = subscribeAbortSignal(modalNode, args.signal);
+const dispatchModal = (modal, { signal, mapResult, cancelResult }) => {
+    let modalNode;
+    let cancel = () => { };
     const promiseHandler = new Promise((resolve, reject) => {
+        let cleanupAbort = null;
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanupAbort?.();
+            cleanupAbort = null;
+            resolve(mapResult(result));
+        };
+        modal.handleResolve = settle;
+        cancel = () => {
+            if (ModalManager.cancelPrerender(modal))
+                settle(cancelResult());
+        };
+        const wire = (node) => {
+            modalNode = node;
+            if (signal === undefined)
+                return;
+            cleanupAbort?.();
+            if (signal.aborted) {
+                closeModal(node);
+                return;
+            }
+            const handleAbort = () => closeModal(node);
+            signal.addEventListener('abort', handleAbort, { once: true });
+            cleanupAbort = () => signal.removeEventListener('abort', handleAbort);
+        };
         try {
-            modalNode.handleResolve = () => {
-                unsubscribe?.();
-                resolve();
-            };
-            if (args.signal?.aborted)
-                closeModal(modalNode);
+            if (signal?.aborted) {
+                settle(cancelResult());
+                return;
+            }
+            const node = ModalManager.open(modal);
+            if (node)
+                wire(node);
+            else {
+                if (signal) {
+                    const handleAbort = () => {
+                        ModalManager.cancelPrerender(modal);
+                        settle(cancelResult());
+                    };
+                    signal.addEventListener('abort', handleAbort, { once: true });
+                    cleanupAbort = () => signal.removeEventListener('abort', handleAbort);
+                }
+                ModalManager.bindPrerender(modal, () => {
+                    try {
+                        const flushed = ModalManager.open(modal);
+                        if (flushed)
+                            wire(flushed);
+                    }
+                    catch (error) {
+                        settled = true;
+                        cleanupAbort?.();
+                        cleanupAbort = null;
+                        reject(error);
+                    }
+                });
+            }
         }
         catch (error) {
-            closeModal(modalNode);
-            unsubscribe?.();
+            cleanupAbort?.();
             reject(error);
         }
     });
-    return { modalNode, promiseHandler };
+    return {
+        get modalNode() {
+            return modalNode;
+        },
+        promiseHandler,
+        cancel,
+    };
 };
 
-const confirmHandler = (args) => {
-    const modalNode = ModalManager.open({
-        ...args,
-        type: 'confirm',
-    });
-    const unsubscribe = subscribeAbortSignal(modalNode, args.signal);
-    const promiseHandler = new Promise((resolve, reject) => {
-        try {
-            modalNode.handleResolve = (result) => {
-                unsubscribe?.();
-                resolve(result ?? false);
-            };
-            if (args.signal?.aborted)
-                closeModal(modalNode);
-        }
-        catch (error) {
-            closeModal(modalNode);
-            unsubscribe?.();
-            reject(error);
-        }
-    });
-    return { modalNode, promiseHandler };
-};
+const alertHandler = (args) => dispatchModal({ ...args, type: 'alert' }, {
+    signal: args.signal,
+    mapResult: () => undefined,
+    cancelResult: () => null,
+});
 
-const promptHandler = (args) => {
-    const modalNode = ModalManager.open({
-        ...args,
-        type: 'prompt',
-    });
-    const unsubscribe = subscribeAbortSignal(modalNode, args.signal);
-    const promiseHandler = new Promise((resolve, reject) => {
-        try {
-            modalNode.handleResolve = (result) => {
-                unsubscribe?.();
-                resolve(result);
-            };
-            if (args.signal?.aborted)
-                closeModal(modalNode);
-        }
-        catch (error) {
-            closeModal(modalNode);
-            unsubscribe?.();
-            reject(error);
-        }
-    });
-    return { modalNode, promiseHandler };
-};
+const confirmHandler = (args) => dispatchModal({ ...args, type: 'confirm' }, {
+    signal: args.signal,
+    mapResult: (result) => result ?? false,
+    cancelResult: () => null,
+});
+
+const promptHandler = (args) => dispatchModal({ ...args, type: 'prompt' }, {
+    signal: args.signal,
+    mapResult: (result) => result ?? null,
+    cancelResult: () => args.returnOnCancel ? (args.defaultValue ?? null) : null,
+});
 
 const alert = (args) => alertHandler(args).promiseHandler;
 const confirm = (args) => confirmHandler(args).promiseHandler;
@@ -342,10 +394,6 @@ const nodeFactory = (modal) => {
     throw new Error(`Unknown modal: ${modal.type}`, { modal });
 };
 
-const DEFAULT_Z_INDEX = 1000;
-const DEFAULT_ANIMATION_DURATION = '300ms';
-const DEFAULT_BACKDROP_COLOR = 'rgba(0, 0, 0, 0.5)';
-
 const FallbackTitle = ({ children }) => {
     return jsx("h2", { style: { margin: 'unset' }, children: children });
 };
@@ -478,24 +526,12 @@ const ModalManagerContextProvider = memo(({ usePathname, children, }) => {
     const initiator = useRef(pathname);
     const modalIdSequence = useRef(0);
     const options = useConfigurationOptions();
-    const duration = useMemo(() => convertMsFromDuration(options.duration), [options]);
+    const optionsRef = useReference(options);
     useOnMountLayout(() => {
-        const { manualDestroy, closeOnBackdropClick } = options;
-        for (const data of ModalManager.prerender) {
-            const modal = nodeFactory({
-                duration,
-                manualDestroy,
-                closeOnBackdropClick,
-                ...data,
-                id: modalIdSequence.current++,
-                initiator: initiator.current,
-            });
-            modalDictionary.current.set(modal.id, modal);
-            setModalIds((ids) => [...ids, modal.id]);
-        }
         ModalManager.openHandler = (data) => {
+            const { duration, manualDestroy, closeOnBackdropClick } = optionsRef.current;
             const modalNode = nodeFactory({
-                duration,
+                duration: convertMsFromDuration(duration),
                 manualDestroy,
                 closeOnBackdropClick,
                 ...data,
@@ -530,43 +566,33 @@ const ModalManagerContextProvider = memo(({ usePathname, children, }) => {
         }
         initiator.current = pathname;
     }, [pathname]);
-    const getModalNodeRef = useRef((modalId) => modalDictionary.current.get(modalId));
+    const getModalNodeRef = useRef((modalId) => modalId !== undefined ? modalDictionary.current.get(modalId) : undefined);
     const onDestroyRef = useRef((modalId) => {
-        const modal = modalDictionary.current.get(modalId);
+        const modal = getModalNodeRef.current(modalId);
         if (!modal)
             return;
         modal.onDestroy();
         ModalManager.refresh();
     });
-    const hideModalRef = useRef((modalId) => {
-        const modal = modalDictionary.current.get(modalId);
-        if (!modal)
-            return;
-        modal.onHide();
-        ModalManager.refresh();
-        if (modal.manualDestroy === false)
-            setTimeout(() => modal.onDestroy(), modal.duration);
-    });
     const onChangeRef = useRef((modalId, value) => {
-        const modal = modalDictionary.current.get(modalId);
+        const modal = getModalNodeRef.current(modalId);
         if (!modal)
             return;
         if (modal.type === 'prompt')
             modal.onChange(value);
     });
     const onConfirmRef = useRef((modalId) => {
-        const modal = modalDictionary.current.get(modalId);
+        const modal = getModalNodeRef.current(modalId);
         if (!modal)
             return;
         modal.onConfirm();
-        hideModalRef.current(modalId);
+        hideModal(modal);
     });
     const onCloseRef = useRef((modalId) => {
-        const modal = modalDictionary.current.get(modalId);
+        const modal = getModalNodeRef.current(modalId);
         if (!modal)
             return;
-        modal.onClose();
-        hideModalRef.current(modalId);
+        closeModal(modal);
     });
     const getModalRef = useRef((modalId) => ({
         modal: getModalNodeRef.current(modalId),
@@ -603,21 +629,26 @@ const useUserDefinedContext = () => {
 const usePathname = () => {
     const [pathname, setPathname] = useState(window.location.pathname);
     useLayoutEffect(() => {
+        const handleChange = () => setPathname(window.location.pathname);
+        const navigation = window.navigation;
+        if (navigation) {
+            navigation.addEventListener('currententrychange', handleChange);
+            window.addEventListener('popstate', handleChange);
+            return () => {
+                navigation.removeEventListener('currententrychange', handleChange);
+                window.removeEventListener('popstate', handleChange);
+            };
+        }
         let requestId;
         const checkPathname = () => {
-            if (requestId)
-                cancelAnimationFrame(requestId);
-            if (pathname !== window.location.pathname) {
+            if (pathname !== window.location.pathname)
                 setPathname(window.location.pathname);
-            }
-            else {
+            else
                 requestId = requestAnimationFrame(checkPathname);
-            }
         };
         requestId = requestAnimationFrame(checkPathname);
         return () => {
-            if (requestId)
-                cancelAnimationFrame(requestId);
+            cancelAnimationFrame(requestId);
         };
     }, [pathname]);
     return { pathname };
@@ -723,7 +754,7 @@ const PromptInner = memo(({ modal, handlers }) => {
     const handleConfirm = useCallback(() => {
         requestAnimationFrame(onConfirm);
     }, [onConfirm]);
-    const disabled = useMemo(() => (value ? !!checkDisabled?.(value) : false), [checkDisabled, value]);
+    const disabled = useMemo(() => (checkDisabled ? !!checkDisabled(value) : false), [checkDisabled, value]);
     const { TitleComponent, SubtitleComponent, ContentComponent, FooterComponent, } = useConfigurationContext();
     return (jsxs(Fragment, { children: [title &&
                 (isString(title) ? (jsx(TitleComponent, { context: userDefinedContext, children: title })) : (title)), subtitle &&
@@ -796,6 +827,7 @@ const style$1 = `
   z-index: var(--z-index);
   pointer-events: none;
   overflow: hidden;
+}
 `;
 ModalManager.defineStyleSheet('presenter', style$1);
 
@@ -854,8 +886,10 @@ const AnchorInner = () => {
     }, [update]);
     const options = useConfigurationOptions();
     const dimmed = useActiveModalCount(validateDimmable, version);
-    if (!dimmed)
-        reset();
+    useEffect(() => {
+        if (!dimmed)
+            reset();
+    }, [dimmed]);
     const anchorStyle = useMemo(() => ({
         '--z-index': options.zIndex,
         '--transition-duration': options.duration,
@@ -896,12 +930,12 @@ const BootstrapProvider = memo(forwardRef(({ usePathname: useExternalPathname, F
         initialize: handleInitialize,
     }), [handleInitialize]);
     useOnMount(() => {
-        if (handleRef !== null)
-            return;
-        handleInitialize();
+        if (handleRef === null)
+            handleInitialize();
         return () => {
-            if (anchorRef.current)
-                anchorRef.current.remove();
+            if (anchorRef.current === null)
+                return;
+            anchorRef.current.remove();
             handleReset();
         };
     });
@@ -922,13 +956,15 @@ const BootstrapProvider = memo(forwardRef(({ usePathname: useExternalPathname, F
 
 const useBootstrap = ({ usePathname: useExternalPathname, ForegroundComponent, BackgroundComponent, TitleComponent, SubtitleComponent, ContentComponent, FooterComponent, options, context, mode = 'auto', } = {}) => {
     const usePathname$1 = useMemo(() => useExternalPathname || usePathname, [useExternalPathname]);
-    const { anchorRef, handleInitialize } = useInitialize();
+    const { anchorRef, handleInitialize, handleReset } = useInitialize();
     useOnMount(() => {
         if (mode === 'auto')
             handleInitialize();
         return () => {
-            if (anchorRef.current)
-                anchorRef.current.remove();
+            if (anchorRef.current === null)
+                return;
+            anchorRef.current.remove();
+            handleReset();
         };
     });
     const initialize = useCallback((element) => {
@@ -952,28 +988,33 @@ const useBootstrap = ({ usePathname: useExternalPathname, ForegroundComponent, B
 };
 
 const useModal = (configuration) => {
-    const modalNodesRef = useRef([]);
+    const modalResultsRef = useRef([]);
     const baseArgsRef = useRef(configuration);
     const alertRef = useRef((args) => {
-        const { modalNode, promiseHandler } = alertHandler(baseArgsRef.current ? { ...baseArgsRef.current, ...args } : args);
-        modalNodesRef.current.push(modalNode);
-        return promiseHandler;
+        const result = alertHandler(baseArgsRef.current ? { ...baseArgsRef.current, ...args } : args);
+        modalResultsRef.current.push(result);
+        return result.promiseHandler;
     });
     const confirmRef = useRef((args) => {
-        const { modalNode, promiseHandler } = confirmHandler(baseArgsRef.current ? { ...baseArgsRef.current, ...args } : args);
-        modalNodesRef.current.push(modalNode);
-        return promiseHandler;
+        const result = confirmHandler(baseArgsRef.current ? { ...baseArgsRef.current, ...args } : args);
+        modalResultsRef.current.push(result);
+        return result.promiseHandler;
     });
     const promptRef = useRef((args) => {
-        const { modalNode, promiseHandler } = promptHandler(baseArgsRef.current ? { ...baseArgsRef.current, ...args } : args);
-        modalNodesRef.current.push(modalNode);
-        return promiseHandler;
+        const result = promptHandler(baseArgsRef.current ? { ...baseArgsRef.current, ...args } : args);
+        modalResultsRef.current.push(result);
+        return result.promiseHandler;
     });
     useOnUnmount(() => {
-        for (const node of modalNodesRef.current)
-            closeModal(node, false);
+        for (const result of modalResultsRef.current) {
+            const modalNode = result.modalNode;
+            if (modalNode)
+                closeModal(modalNode, false);
+            else
+                result.cancel();
+        }
         ModalManager.refresh();
-        modalNodesRef.current = [];
+        modalResultsRef.current = [];
     });
     return {
         alert: alertRef.current,
@@ -1026,8 +1067,6 @@ const useModalAnimation = (visible, handler) => {
 
 const useModalDuration = (modalId) => {
     const globalDuration = useConfigurationDuration();
-    if (modalId === undefined)
-        return globalDuration;
     const { modal } = useModalManager(modalId);
     if (modal === undefined)
         return globalDuration;

package/dist/providers/ModalManagerContext/ModalManagerContext.d.ts

@@ -3,7 +3,7 @@ import type { ModalNode } from '../../core/index.js';
 import type { ModalActions, ModalHandlersWithId } from '../../types/index.js';
 export interface ModalManagerContextProps extends ModalHandlersWithId {
     modalIds: ModalNode['id'][];
-    getModal: Fn<[id: ModalNode['id']], ModalActions>;
-    getModalNode: Fn<[id: ModalNode['id']], ModalNode | undefined>;
+    getModal: Fn<[id: ModalNode['id'] | undefined], ModalActions>;
+    getModalNode: Fn<[id: ModalNode['id'] | undefined], ModalNode | undefined>;
 }
 export declare const ModalManagerContext: import("react").Context<ModalManagerContextProps>;

package/dist/providers/ModalManagerContext/useModalManagerContext.d.ts

@@ -1,3 +1,3 @@
 import type { ManagedModal } from '../../types/index.js';
 export declare const useModalManagerContext: () => import("./ModalManagerContext").ModalManagerContextProps;
-export declare const useModalManager: (id: ManagedModal["id"]) => import("../../types").ModalActions;
+export declare const useModalManager: (id?: ManagedModal["id"]) => import("../../types").ModalActions;

package/dist/types/base.d.ts

@@ -11,6 +11,11 @@ export interface BaseModal<T, B> {
     duration?: number;
     manualDestroy?: boolean;
     closeOnBackdropClick?: boolean;
+    /**
+     * @internal Promise settlement channel injected by the handle layer
+     * (dispatchModal). Travels with the modal data so prerendered modals keep
+     * their wiring; not part of the public props surface.
+     */
     handleResolve?: Fn<[result: T | null]>;
     ForegroundComponent?: ForegroundComponent;
     BackgroundComponent?: BackgroundComponent;

package/docs/claude/skills/promise-modal-skill/knowledge/api-reference.md

@@ -118,10 +118,10 @@ const userInfo = await prompt<{ name: string; age: number }>({
 |------|------|------|
 | `Input` | `(props: PromptInputProps<T>) => ReactNode` | Input component (required) |
 | `defaultValue` | `T` | Default input value |
-| `disabled` | `(value: T) => boolean` | Condition to disable confirm button |
-| `returnOnCancel` | `boolean` | Whether to return default value on cancel |
+| `disabled` | `(value: T | undefined) => boolean` | Condition to disable confirm button |
+| `returnOnCancel` | `boolean` | If true, cancel resolves with the current input value instead of null |
 
-**Return Value**: `Promise<T>`
+**Return Value**: `Promise<T | null>` — resolves null on cancel
 
 ---
 

package/docs/en/SPECIFICATION.md

@@ -311,7 +311,7 @@ Opens a prompt modal to collect user input.
 #### Signature
 
 ```typescript
-function prompt<T, B = any>(options: PromptProps<T, B>): Promise<T>;
+function prompt<T, B = any>(options: PromptProps<T, B>): Promise<T | null>;
 ```
 
 #### Parameters
@@ -322,8 +322,8 @@ All options from `alert`, plus:
 |--------|------|----------|-------------|
 | `Input` | `(props: PromptInputProps<T>) => ReactNode` | Yes | Input component |
 | `defaultValue` | `T` | No | Default value |
-| `disabled` | `(value: T) => boolean` | No | Disable confirm |
-| `returnOnCancel` | `boolean` | No | Return default on cancel |
+| `disabled` | `(value: T | undefined) => boolean` | No | Disable confirm |
+| `returnOnCancel` | `boolean` | No | Resolve current value on cancel (instead of null) |
 
 #### PromptInputProps
 

package/docs/ko/SPECIFICATION.md

@@ -311,7 +311,7 @@ if (shouldDelete) {
 #### 시그니처
 
 ```typescript
-function prompt<T, B = any>(options: PromptProps<T, B>): Promise<T>;
+function prompt<T, B = any>(options: PromptProps<T, B>): Promise<T | null>;
 ```
 
 #### 매개변수
@@ -322,8 +322,8 @@ function prompt<T, B = any>(options: PromptProps<T, B>): Promise<T>;
 |------|------|------|------|
 | `Input` | `(props: PromptInputProps<T>) => ReactNode` | 예 | 입력 컴포넌트 |
 | `defaultValue` | `T` | 아니오 | 기본값 |
-| `disabled` | `(value: T) => boolean` | 아니오 | 확인 버튼 비활성화 |
-| `returnOnCancel` | `boolean` | 아니오 | 취소 시 기본값 반환 |
+| `disabled` | `(value: T | undefined) => boolean` | 아니오 | 확인 버튼 비활성화 |
+| `returnOnCancel` | `boolean` | 아니오 | 취소 시 null 대신 현재 입력값 반환 |
 
 #### PromptInputProps
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lerx/promise-modal",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "description": "Universal React modal utility that can be used outside React components with promise-based results for alert, confirm, and prompt modals",
   "keywords": [
     "react",
@@ -29,7 +29,11 @@
     "name": "Vincent K. Kelvin",
     "email": "lunox273@gmail.com"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/index.mjs",
+    "./dist/index.cjs",
+    "**/style.ts"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -61,23 +65,30 @@
     "size-limit": "size-limit",
     "start": "yarn build && yarn storybook",
     "storybook": "storybook dev -p 6006",
-    "test": "vitest",
+    "test": "yarn run -T vitest",
+    "test:prod": "yarn run -T vitest run --config vitest.prod.config.ts",
     "version:major": "yarn version major",
     "version:minor": "yarn version minor",
     "version:patch": "yarn version patch"
   },
   "dependencies": {
-    "@winglet/common-utils": "^0.12.2",
+    "@winglet/common-utils": "^0.12.3",
     "@winglet/react-utils": "^0.12.2",
     "@winglet/style-utils": "^0.12.2"
   },
   "devDependencies": {
-    "@slats/claude-assets-sync": "^0.3.1",
+    "@slats/claude-assets-sync": "^0.3.4",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.1.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "antd": "^5.22.5",
     "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "react-dom": "^19.0.0",
+    "rollup": "^4.59.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.7.2"
   },
   "peerDependencies": {
     "react": ">=18 <20",

package/dist/helpers/subscribeAbortSignal.d.ts

@@ -1,2 +0,0 @@
-import type { ModalNode } from '../core/index.js';
-export declare const subscribeAbortSignal: (modalNode: ModalNode, signal: AbortSignal | undefined) => (() => void) | null;