fix(dialog): stack dialogs by open order to fix transfer freeze

This commit is contained in:
zipg authored and GitHub committed 2026-09-30 14:56:38 +08:00
1 parent 89964dafe4
commit 535417a763
4 files changed
+241 -4

No files matched your search

@@ -1,13 +1,14 @@
<script setup lang="ts">
import type { DialogContentEmits, DialogContentProps } from "reka-ui";
import type { HTMLAttributes } from "vue";
import { ref, type HTMLAttributes } from "vue";
import { reactiveOmit } from "@vueuse/core";
import { XIcon } from "@lucide/vue";
import { DialogClose, DialogContent, DialogDescription, DialogPortal, VisuallyHidden, useForwardPropsEmits } from "reka-ui";
import { cn } from "@/lib/common/utils";
import { Button } from "@/components/ui/button";
import DialogOverlay from "./DialogOverlay.vue";
import { useDialogLayerOrder } from "./useDialogLayerOrder";
defineOptions({
inheritAttrs: false,
@@ -31,12 +32,15 @@ const emits = defineEmits<DialogContentEmits>();
const delegatedProps = reactiveOmit(props, "class", "overlayClass", "portalClass");
const forwarded = useForwardPropsEmits(delegatedProps, emits);
const positioner = ref<HTMLElement | null>(null);
useDialogLayerOrder(positioner);
</script>
<template>
<DialogPortal>
<DialogOverlay :class="props.overlayClass" />
<div data-slot="dialog-positioner" :class="cn('fixed inset-0 z-50 grid place-items-center p-4 pointer-events-none', props.portalClass)">
<div ref="positioner" data-slot="dialog-positioner" :class="cn('fixed inset-0 z-50 grid place-items-center p-4 pointer-events-none', props.portalClass)">
<DialogContent
data-slot="dialog-content"
v-bind="{ ...$attrs, ...forwarded }"
@@ -1,11 +1,12 @@
<script setup lang="ts">
import type { DialogContentEmits, DialogContentProps } from "reka-ui";
import type { HTMLAttributes } from "vue";
import { ref, type HTMLAttributes } from "vue";
import { reactiveOmit } from "@vueuse/core";
import { XIcon } from "@lucide/vue";
import { DialogClose, DialogContent, DialogDescription, DialogPortal, VisuallyHidden, useForwardPropsEmits } from "reka-ui";
import DialogOverlay from "./DialogOverlay.vue";
import { useDialogLayerOrder } from "./useDialogLayerOrder";
import { cn } from "@/lib/common/utils";
defineOptions({
@@ -21,12 +22,15 @@ const emits = defineEmits<DialogContentEmits>();
const delegatedProps = reactiveOmit(props, "class", "showOverlay", "showCloseButton");
const forwarded = useForwardPropsEmits(delegatedProps, emits);
const positioner = ref<HTMLElement | null>(null);
useDialogLayerOrder(positioner);
</script>
<template>
<DialogPortal>
<DialogOverlay v-if="props.showOverlay" />
<div data-slot="dialog-positioner" class="fixed inset-0 z-50 grid place-items-center p-4 pointer-events-none">
<div ref="positioner" data-slot="dialog-positioner" class="fixed inset-0 z-50 grid place-items-center p-4 pointer-events-none">
<DialogContent
data-slot="dialog-content"
:class="cn('relative z-50 grid max-h-[calc(var(--dbx-viewport-height)-6rem)] w-full max-w-lg my-8 gap-4 rounded-lg border border-border bg-popover text-popover-foreground p-4 shadow-lg duration-200 md:w-full pointer-events-auto', props.class)"
@@ -0,0 +1,190 @@
// @vitest-environment happy-dom
import { createApp, defineComponent, h, nextTick, reactive, type Component } from "vue";
import { createI18n } from "vue-i18n";
import { afterEach, describe, expect, it } from "vitest";
import { Dialog, DialogContent, DialogScrollContent, DialogTitle } from "@/components/ui/dialog";
const mountedApps: Array<{ unmount: () => void; host: HTMLElement }> = [];
afterEach(() => {
for (const { unmount, host } of mountedApps.splice(0)) {
unmount();
host.remove();
}
document.body.innerHTML = "";
});
async function flush() {
for (let turn = 0; turn < 5; turn += 1) {
await nextTick();
await new Promise((resolve) => setTimeout(resolve));
await nextTick();
}
}
type Layer = { index: number; slot: string; label: string; element: Element };
/** Dialog layers teleport into `body`, so paint order is their order among the body children. */
function dialogLayers(): Layer[] {
return Array.from(document.body.children)
.map((element, index) => ({
index,
element,
slot: element.getAttribute("data-slot") || "",
label: (element.textContent || "")
.replace(/\s+/g, " ")
.trim()
.replace(/Close$/, ""),
}))
.filter((layer) => layer.slot === "dialog-overlay" || layer.slot === "dialog-positioner");
}
function layer(slot: string, label?: string): Layer {
const match = dialogLayers().find((candidate) => candidate.slot === slot && (!label || candidate.label.includes(label)));
expect(match, `no ${slot} painted for ${label ?? ""}`).toBeDefined();
return match!;
}
function overlayBefore(target: Layer): Layer | undefined {
return dialogLayers().find((candidate) => candidate.slot === "dialog-overlay" && candidate.index === target.index - 1);
}
function labeledDialog(options: { open: () => boolean; setOpen: (open: boolean) => void; label: string; content: Component }) {
const { open, setOpen, label, content } = options;
return h(
Dialog,
{ open: open(), "onUpdate:open": setOpen },
{
default: () =>
h(
content,
{},
{
default: () => [h(DialogTitle, null, { default: () => label })],
},
),
},
);
}
/** Two sibling dialogs, like the transfer form and its "start transfer" confirmation. */
function mountSiblingDialogs(content: Component = DialogContent) {
const host = document.createElement("div");
document.body.append(host);
const state = reactive({ transferOpen: false, confirmOpen: false });
const app = createApp(
defineComponent({
setup() {
const transfer = () =>
labeledDialog({
open: () => state.transferOpen,
setOpen: (open) => {
state.transferOpen = open;
},
label: "transfer form",
content,
});
const confirm = () =>
labeledDialog({
open: () => state.confirmOpen,
setOpen: (open) => {
state.confirmOpen = open;
},
label: "confirm transfer",
content,
});
return () => h("div", [transfer(), confirm()]);
},
}),
);
app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
app.mount(host);
mountedApps.push({ unmount: () => app.unmount(), host });
return state;
}
describe("dialog layer order", () => {
it.each([
["DialogContent", DialogContent],
["DialogScrollContent", DialogScrollContent],
])("paints a %s that opens later above layers left behind by earlier dialogs", async (_name, content) => {
const state = mountSiblingDialogs(content);
state.transferOpen = true;
await flush();
state.confirmOpen = true;
await flush();
// The transfer form and its confirmation paint in open order to begin with.
const transfer = layer("dialog-positioner", "transfer form");
const confirm = layer("dialog-positioner", "confirm transfer");
expect(confirm.index).toBeGreaterThan(transfer.index);
expect(overlayBefore(confirm)).toBeDefined();
// A dialog that gets remounted (leaving the tracked-transfer dialog and returning to the form)
// ends up after the dialog it is supposed to sit below; Reka UI then keeps handing pointer
// events to the confirmation dialog while the form's backdrop covers it.
const transferOverlay = transfer.element.previousElementSibling!;
document.body.append(transferOverlay, transfer.element);
await flush();
expect(layer("dialog-positioner", "transfer form").index).toBeGreaterThan(layer("dialog-positioner", "confirm transfer").index);
// Reopening the confirmation must bring its layer back above the form.
state.confirmOpen = false;
await flush();
state.confirmOpen = true;
await flush();
const reopened = layer("dialog-positioner", "confirm transfer");
expect(reopened.index).toBeGreaterThan(layer("dialog-positioner", "transfer form").index);
expect(document.body.lastElementChild).toBe(reopened.element);
expect(overlayBefore(reopened)).toBeDefined();
});
it("paints a nested dialog above the dialog that opened it", async () => {
const host = document.createElement("div");
document.body.append(host);
const state = reactive({ formOpen: true, confirmOpen: false });
const app = createApp(
defineComponent({
setup() {
return () =>
labeledDialog({
open: () => state.formOpen,
setOpen: (open) => {
state.formOpen = open;
},
label: "transfer form",
content: defineComponent({
setup() {
return () =>
h(DialogContent, null, {
default: () => [
h(DialogTitle, null, { default: () => "transfer form" }),
labeledDialog({
open: () => state.confirmOpen,
setOpen: (open) => {
state.confirmOpen = open;
},
label: "confirm transfer",
content: DialogContent,
}),
],
});
},
}),
});
},
}),
);
app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
app.mount(host);
mountedApps.push({ unmount: () => app.unmount(), host });
await flush();
state.confirmOpen = true;
await flush();
expect(layer("dialog-positioner", "confirm transfer").index).toBeGreaterThan(layer("dialog-positioner", "transfer form").index);
});
});
@@ -0,0 +1,39 @@
import { injectDialogRootContext } from "reka-ui";
import { watch, type Ref } from "vue";
/**
* Keeps a dialog layer painted above every dialog that was opened before it.
*
* `DialogPortal` only teleports its children, it does not gate them on the open state,
* so the `fixed inset-0 z-50` wrapper lands in the target as soon as the dialog
* *component* mounts. Because all dialog layers share the same z-index, the browser
* paints them in mount order. A dialog mounted earlier therefore covered one that opens
* later: Reka UI's dismissable-layer stack still handed pointer events to the later
* dialog, so that dialog stayed invisible while the earlier one became unclickable.
*
* Re-appending the wrapper when its dialog opens makes paint order follow open order
* instead of mount order. The element stays mounted on close, so enter/leave animations
* are unchanged.
*/
export function useDialogLayerOrder(positioner: Ref<HTMLElement | null>) {
const rootContext = injectDialogRootContext();
function raiseLayer() {
const element = positioner.value;
const parent = element?.parentNode;
if (!element || !parent || parent.lastElementChild === element) return;
// The overlay is the sibling right in front of the wrapper; move both so a later
// dialog's backdrop still covers the earlier dialog instead of slipping under it.
const overlay = element.previousElementSibling;
if (overlay?.getAttribute("data-slot") === "dialog-overlay") parent.appendChild(overlay);
parent.appendChild(element);
}
watch(
() => rootContext?.open.value ?? false,
(isOpen) => {
if (isOpen) raiseLayer();
},
{ flush: "post" },
);
}