Is it expected behavior that the Promise returned by openAsync never resolves when unmount is called?

[DongGukMon]

I’ve verified that calling close does resolve the Promise.
However, when isOpen isn’t managed inside the OverlayControllerComponent, a typical pattern would be to control the overlay by calling only unmount, without invoking close. In that scenario, I’m concerned that openAsync might never resolve, which could lead to unexpected behavior. Is it intentional that the Promise can be resolved only by calling close? If so, is the recommended best practice to always call close before invoking unmount?

If the current behavior isn’t intentional, I’d like to suggest two possible approaches:

Option 1.
Resolve the openAsync Promise when unmount is called.

Option 2.
Have the component mounted by openAsync resolve the Promise in a cleanup routine when it is unmounted.

[jungpaeng]

At the time openAsync was developed, proceeding with unmount without calling close was not the intended use.
However, since the current documentation does guide users to use unmount without close, I agree that the Promise should be resolved even when unmount is used.

I’ll consider how we might address this without introducing a breaking change to the library.
Separately, I have a question.

You mentioned a scenario where isOpen is not managed inside OverlayControllerComponent.
Could you provide an example code snippet to illustrate this case?

[DongGukMon]

Thank you for your considering.

And, here's the code snippet you requested.

overlay.open(({ unmount }) => {
  return (
    <Modal >
      <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center' }}>
        <p>MODAL CONTENT</p>
        <button onClick={unmount}>close modal</button>
      </div>
    </Modal>
  );
});

I understand that close only sets isOpen to false, and that the OverlayControllerComponent then uses the isOpen flag to decide when to call unmount. I inferred this from the example Modal implementation: when isOpen becomes false, the Modal runs its exit animation and, after the animation finishes (300 ms in the example), it calls unmount.

In scenarios where no animation is required—that is, when the close and unmount actions happen at the same moment—the isOpen flag becomes unnecessary. In such cases we can control the overlay by calling unmount directly, without using close and isOpen. That’s what I meant when I said “ scenario that isOpen is not managed inside OverlayControllerComponent.”

(While writing this, it occurred to me that if the Promise resolves the moment close is called, openAsync could resolve before the exiting animation finishes, triggering the next action too early, and that might throw the timing out of sync.—I don’t think it’s a particularly high-priority issue, though.)