From ff68d5e90a75a6b5eaf5583d92181c044f597419 Mon Sep 17 00:00:00 2001 From: chungyo Date: Wed, 9 Sep 2026 10:18:55 +0900 Subject: [PATCH] fix: settle openAsync results when reopening the same overlay --- .changeset/quiet-overlays-resolve.md | 5 + .../provider/content-overlay-controller.tsx | 43 ++- packages/src/context/provider/index.tsx | 15 +- packages/src/context/reducer.ts | 13 +- packages/src/event-reuse.test.tsx | 310 ++++++++++++++++++ packages/src/event.ts | 41 +-- 6 files changed, 388 insertions(+), 39 deletions(-) create mode 100644 .changeset/quiet-overlays-resolve.md create mode 100644 packages/src/event-reuse.test.tsx diff --git a/.changeset/quiet-overlays-resolve.md b/.changeset/quiet-overlays-resolve.md new file mode 100644 index 0000000..f33eb85 --- /dev/null +++ b/.changeset/quiet-overlays-resolve.md @@ -0,0 +1,5 @@ +--- +'overlay-kit': patch +--- + +Fix `openAsync` promises remaining pending when reopening a closed overlay with the same ID, while preserving the overlay's component state. diff --git a/packages/src/context/provider/content-overlay-controller.tsx b/packages/src/context/provider/content-overlay-controller.tsx index 1d202bf..e0de8dd 100644 --- a/packages/src/context/provider/content-overlay-controller.tsx +++ b/packages/src/context/provider/content-overlay-controller.tsx @@ -16,28 +16,53 @@ export type OverlayAsyncControllerProps = Omit; export type OverlayAsyncControllerComponent = FC>; +export type OverlayAsyncResult = { + resolve: (value: unknown) => void; + reject: (reason?: unknown) => void; +}; + type ContentOverlayControllerProps = { isOpen: boolean; overlayId: string; overlayDispatch: ActionDispatch<[action: OverlayReducerAction]>; controller: OverlayControllerComponent; + isAsyncController?: boolean; + asyncResult?: OverlayAsyncResult; }; export const ContentOverlayController = memo( - ({ isOpen, overlayId, overlayDispatch, controller: Controller }: ContentOverlayControllerProps) => { + ({ + isOpen, + overlayId, + overlayDispatch, + controller: Controller, + isAsyncController, + asyncResult, + }: ContentOverlayControllerProps) => { useEffect(() => { requestAnimationFrame(() => { overlayDispatch({ type: 'OPEN', overlayId }); }); }, [overlayDispatch, overlayId]); - return ( - overlayDispatch({ type: 'CLOSE', overlayId })} - unmount={() => overlayDispatch({ type: 'REMOVE', overlayId })} - /> - ); + const props = { + isOpen, + overlayId, + close: (value?: unknown) => { + asyncResult?.resolve(value); + overlayDispatch({ type: 'CLOSE', overlayId, asyncResult }); + }, + unmount: () => overlayDispatch({ type: 'REMOVE', overlayId }), + ...(isAsyncController + ? { + reject: (reason?: unknown) => { + asyncResult?.reject(reason); + overlayDispatch({ type: 'CLOSE', overlayId, asyncResult }); + }, + } + : {}), + }; + + return ; } ); diff --git a/packages/src/context/provider/index.tsx b/packages/src/context/provider/index.tsx index 0e6e38f..d376cd1 100644 --- a/packages/src/context/provider/index.tsx +++ b/packages/src/context/provider/index.tsx @@ -18,7 +18,7 @@ export function createOverlayProvider() { }); const prevOverlayState = useRef(overlayState); - const open: OverlayEvent['open'] = useCallback(({ controller, overlayId, componentKey }) => { + const open: OverlayEvent['open'] = useCallback(({ controller, overlayId, componentKey, asyncResult }) => { overlayDispatch({ type: 'ADD', overlay: { @@ -27,6 +27,8 @@ export function createOverlayProvider() { isOpen: false, isMounted: false, controller: controller, + isAsyncController: asyncResult != null, + asyncResult, }, }); }, []); @@ -75,7 +77,14 @@ export function createOverlayProvider() { {children} {overlayState.overlayOrderList.map((item) => { - const { id: currentOverlayId, componentKey, isOpen, controller: Controller } = overlayState.overlayData[item]; + const { + id: currentOverlayId, + componentKey, + isOpen, + controller: Controller, + isAsyncController, + asyncResult, + } = overlayState.overlayData[item]; return ( ); })} diff --git a/packages/src/context/reducer.ts b/packages/src/context/reducer.ts index 3c111ab..27a68e6 100644 --- a/packages/src/context/reducer.ts +++ b/packages/src/context/reducer.ts @@ -1,4 +1,4 @@ -import { type OverlayControllerComponent } from './provider/content-overlay-controller'; +import { type OverlayAsyncResult, type OverlayControllerComponent } from './provider/content-overlay-controller'; type OverlayId = string; type OverlayItem = { @@ -14,6 +14,8 @@ type OverlayItem = { isOpen: boolean; isMounted: boolean; controller: OverlayControllerComponent; + isAsyncController?: boolean; + asyncResult?: OverlayAsyncResult; }; export type OverlayData = { current: OverlayId | null; @@ -24,7 +26,7 @@ export type OverlayData = { export type OverlayReducerAction = | { type: 'ADD'; overlay: OverlayItem } | { type: 'OPEN'; overlayId: string } - | { type: 'CLOSE'; overlayId: string } + | { type: 'CLOSE'; overlayId: string; asyncResult?: OverlayAsyncResult } | { type: 'REMOVE'; overlayId: string } | { type: 'CLOSE_ALL' } | { type: 'REMOVE_ALL' }; @@ -77,7 +79,7 @@ export function overlayReducer(state: OverlayData, action: OverlayReducerAction) current: action.overlay.id, overlayData: { ...state.overlayData, - [action.overlay.id]: { ...overlay, isOpen: true }, + [action.overlay.id]: { ...overlay, isOpen: true, asyncResult: action.overlay.asyncResult }, }, }; } @@ -123,6 +125,11 @@ export function overlayReducer(state: OverlayData, action: OverlayReducerAction) case 'CLOSE': { const overlay = state.overlayData[action.overlayId]; + // A callback retained from an earlier openAsync call must not close the reopened overlay. + if ('asyncResult' in action && overlay?.asyncResult !== action.asyncResult) { + return state; + } + // ignore if the overlay don't exist or already closed if (overlay == null || !overlay.isOpen) { return state; diff --git a/packages/src/event-reuse.test.tsx b/packages/src/event-reuse.test.tsx new file mode 100644 index 0000000..47143ec --- /dev/null +++ b/packages/src/event-reuse.test.tsx @@ -0,0 +1,310 @@ +import { act, render, screen, waitFor, within } from '@testing-library/react'; +import userEvent from '@testing-library/user-event'; +import React, { StrictMode, useState } from 'react'; +import { describe, expect, it } from 'vitest'; +import { + type OverlayAsyncControllerProps, + type OverlayControllerProps, +} from './context/provider/content-overlay-controller'; +import { experimental_createOverlayContext } from './utils/create-overlay-context'; + +describe('reopening an overlay', () => { + it('preserves the synchronous controller props when choosing which controls to render', async () => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + + function Controller(props: OverlayControllerProps) { + return ( + props.isOpen && ( + + ) + ); + } + + render(); + act(() => overlay.open(Controller)); + await user.click(await screen.findByRole('button', { name: 'Sync controls' })); + expect(screen.queryByRole('button')).not.toBeInTheDocument(); + }); + + it.each(['close', 'reject'] as const)( + 'settles each openAsync call through %s while preserving state', + async (method) => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: unknown[] = []; + + function Controller({ isOpen, close, reject }: OverlayAsyncControllerProps) { + const [value, setValue] = useState('first'); + + return ( + isOpen && ( + <> + setValue(event.target.value)} /> + + + ) + ); + } + + render( + + + + ); + + const open = () => { + act(() => { + overlay.openAsync(Controller, { overlayId: 'reused' }).then( + (value) => results.push({ status: 'resolved', value }), + (reason) => results.push({ status: 'rejected', reason }) + ); + }); + }; + + open(); + await user.click(await screen.findByRole('button', { name: 'Finish' })); + expect(results).toEqual([ + method === 'close' ? { status: 'resolved', value: 'first' } : { status: 'rejected', reason: 'first' }, + ]); + + open(); + const input = await screen.findByRole('textbox', { name: 'value' }); + await user.clear(input); + await user.type(input, 'second'); + await user.click(screen.getByRole('button', { name: 'Finish' })); + + await waitFor(() => { + expect(results).toEqual( + method === 'close' + ? [ + { status: 'resolved', value: 'first' }, + { status: 'resolved', value: 'second' }, + ] + : [ + { status: 'rejected', reason: 'first' }, + { status: 'rejected', reason: 'second' }, + ] + ); + }); + + open(); + expect(await screen.findByRole('textbox', { name: 'value' })).toHaveValue('second'); + await user.click(screen.getByRole('button', { name: 'Finish' })); + expect(results).toHaveLength(3); + } + ); + + it.each(['close', 'reject'] as const)( + 'does not let a previous %s callback close the next invocation', + async (method) => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: string[] = []; + let previousFinish: (value: string) => void; + + function Controller({ isOpen, close, reject }: OverlayAsyncControllerProps) { + return ( + isOpen && ( + + ) + ); + } + + render(); + act(() => { + overlay.openAsync(Controller, { overlayId: 'reused' }).then((value) => results.push(value)); + }); + await user.click(await screen.findByRole('button', { name: 'Finish' })); + act(() => { + overlay.openAsync(Controller, { overlayId: 'reused' }).then((value) => results.push(value)); + }); + await screen.findByRole('button', { name: 'Finish' }); + + act(() => previousFinish('stale')); + + expect(screen.getByRole('button', { name: 'Finish' })).toBeVisible(); + expect(results).toEqual(['finished']); + await user.click(screen.getByRole('button', { name: 'Finish' })); + await waitFor(() => expect(results).toEqual(['finished', 'finished'])); + } + ); + + it('retains the original controller when a different controller reopens the same ID', async () => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: string[] = []; + + render(); + act(() => { + overlay + .openAsync( + ({ isOpen, close }) => isOpen && , + { + overlayId: 'reused', + } + ) + .then((value) => results.push(value)); + }); + await user.click(await screen.findByRole('button', { name: 'Original' })); + act(() => { + overlay + .openAsync(() => , { overlayId: 'reused' }) + .then((value) => results.push(value)); + }); + + expect(screen.queryByRole('button', { name: 'Replacement' })).not.toBeInTheDocument(); + await user.click(await screen.findByRole('button', { name: 'Original' })); + await waitFor(() => expect(results).toEqual(['original', 'original'])); + }); + + it('settles openAsync after reopening an overlay first opened with open', async () => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: void[] = []; + + render(); + act(() => { + overlay.open( + (props) => + props.isOpen && ( + + ), + { overlayId: 'reused' } + ); + }); + await user.click(await screen.findByRole('button', { name: 'Finish' })); + act(() => { + overlay.openAsync(() => null, { overlayId: 'reused' }).then((value) => results.push(value)); + }); + await user.click(await screen.findByRole('button', { name: 'Finish' })); + await waitFor(() => expect(results).toEqual([undefined])); + }); + + it.each(['close', 'reject'] as const)( + 'keeps an open call using %s between openAsync calls independent of their results', + async (method) => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: string[] = []; + + function Controller({ isOpen, close, reject }: OverlayAsyncControllerProps) { + return isOpen && ; + } + + render(); + act(() => { + overlay.openAsync(Controller, { overlayId: 'reused' }).then( + (value) => results.push(`resolved:${value}`), + (reason) => results.push(`rejected:${reason}`) + ); + }); + await screen.findByRole('button', { name: 'Finish' }); + act(() => overlay.close('reused')); + act(() => overlay.open(() => null, { overlayId: 'reused' })); + await user.click(await screen.findByRole('button', { name: 'Finish' })); + + expect(results).toEqual([]); + expect(screen.queryByRole('button', { name: 'Finish' })).not.toBeInTheDocument(); + + act(() => { + overlay.openAsync(Controller, { overlayId: 'reused' }).then( + (value) => results.push(`resolved:${value}`), + (reason) => results.push(`rejected:${reason}`) + ); + }); + await user.click(await screen.findByRole('button', { name: 'Finish' })); + await waitFor(() => expect(results).toEqual([method === 'close' ? 'resolved:finished' : 'rejected:finished'])); + } + ); + + it('resets state and settles a new invocation after unmount', async () => { + const { overlay, OverlayProvider } = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: string[] = []; + + function Controller({ isOpen, close }: OverlayAsyncControllerProps) { + const [value, setValue] = useState('initial'); + + return ( + isOpen && ( + <> + setValue(event.target.value)} /> + + + ) + ); + } + + const open = () => { + act(() => { + overlay.openAsync(Controller, { overlayId: 'reused' }).then((value) => results.push(value)); + }); + }; + + render(); + open(); + const input = await screen.findByRole('textbox', { name: 'value' }); + await user.clear(input); + await user.type(input, 'changed'); + await user.click(screen.getByRole('button', { name: 'Finish' })); + act(() => overlay.unmount('reused')); + + open(); + expect(await screen.findByRole('textbox', { name: 'value' })).toHaveValue('initial'); + await user.click(screen.getByRole('button', { name: 'Finish' })); + await waitFor(() => expect(results).toEqual(['changed', 'initial'])); + }); + + it('keeps results separate for different IDs and contexts using the same controller', async () => { + const first = experimental_createOverlayContext(); + const second = experimental_createOverlayContext(); + const user = userEvent.setup(); + const results: string[] = []; + + function Controller({ isOpen, overlayId, close }: OverlayAsyncControllerProps) { + return isOpen && ; + } + + const firstView = render(); + const secondView = render(); + const open = () => { + act(() => { + first.overlay.openAsync(Controller, { overlayId: 'shared' }).then((value) => results.push(`first:${value}`)); + first.overlay.openAsync(Controller, { overlayId: 'other' }).then((value) => results.push(`first:${value}`)); + second.overlay.openAsync(Controller, { overlayId: 'shared' }).then((value) => results.push(`second:${value}`)); + }); + }; + + open(); + await user.click(await within(firstView.container).findByRole('button', { name: 'shared' })); + await user.click(await within(secondView.container).findByRole('button', { name: 'shared' })); + await user.click(await within(firstView.container).findByRole('button', { name: 'other' })); + expect(results).toEqual(['first:shared', 'second:shared', 'first:other']); + + open(); + await user.click(await within(secondView.container).findByRole('button', { name: 'shared' })); + await waitFor(() => expect(results).toEqual(['first:shared', 'second:shared', 'first:other', 'second:shared'])); + expect(within(firstView.container).getByRole('button', { name: 'shared' })).toBeVisible(); + expect(within(firstView.container).getByRole('button', { name: 'other' })).toBeVisible(); + await user.click(within(firstView.container).getByRole('button', { name: 'other' })); + await user.click(within(firstView.container).getByRole('button', { name: 'shared' })); + await waitFor(() => + expect(results).toEqual([ + 'first:shared', + 'second:shared', + 'first:other', + 'second:shared', + 'first:other', + 'first:shared', + ]) + ); + }); +}); diff --git a/packages/src/event.ts b/packages/src/event.ts index 6955cda..4e81b47 100644 --- a/packages/src/event.ts +++ b/packages/src/event.ts @@ -1,13 +1,20 @@ import { + type OverlayAsyncResult, type OverlayAsyncControllerProps, type OverlayAsyncControllerComponent, type OverlayControllerComponent, + type OverlayControllerProps, } from './context/provider/content-overlay-controller'; import { createUseExternalEvents } from './utils'; import { randomId } from './utils/random-id'; export type OverlayEvent = { - open: (args: { controller: OverlayControllerComponent; overlayId: string; componentKey: string }) => void; + open: (args: { + controller: OverlayControllerComponent; + overlayId: string; + componentKey: string; + asyncResult?: OverlayAsyncResult; + }) => void; close: (overlayId: string) => void; unmount: (overlayId: string) => void; closeAll: () => void; @@ -31,30 +38,14 @@ export function createOverlay(overlayId: string) { }; const openAsync = async (controller: OverlayAsyncControllerComponent, options?: OpenOverlayOptions) => { - return new Promise((_resolve, _reject) => { - open((overlayProps, ...deprecatedLegacyContext) => { - /** - * @description close the overlay with resolve - */ - const close = (param: T) => { - _resolve(param); - overlayProps.close(); - }; - - /** - * @description close the overlay with reject - */ - const reject = (reason?: unknown) => { - _reject(reason); - overlayProps.close(); - }; - - /** - * @description Passing overridden methods - */ - const props: OverlayAsyncControllerProps = { ...overlayProps, close, reject }; - return controller(props, ...deprecatedLegacyContext); - }, options); + return new Promise((resolve, reject) => { + createEvent('open')({ + controller: (props, ...deprecatedLegacyContext) => + controller(props as OverlayControllerProps & OverlayAsyncControllerProps, ...deprecatedLegacyContext), + overlayId: options?.overlayId ?? randomId(), + componentKey: randomId(), + asyncResult: { resolve: (value) => resolve(value as T), reject }, + }); }); };