import type { ConfirmDialogOptions, ConfirmDialogVariant } from "@t3tools/contracts";
export type ConfirmDialogState =
| { readonly status: "idle" }
| {
readonly status: "confirming";
readonly message: string;
readonly variant: ConfirmDialogVariant;
}
| {
readonly status: "closing";
readonly message: string;
readonly variant: ConfirmDialogVariant;
};
type PendingConfirmation = {
readonly message: string;
readonly variant: ConfirmDialogVariant;
readonly resolve: (confirmed: boolean) => void;
};
const idleState: ConfirmDialogState = { status: "idle" };
let state: ConfirmDialogState = idleState;
let activeConfirmation: PendingConfirmation | null = null;
let queuedConfirmations: PendingConfirmation[] = [];
const listeners = new Set<() => void>();
function publish(next: ConfirmDialogState): void {
state = next;
for (const listener of listeners) {
listener();
}
}
function resolvePendingConfirmations(confirmed: boolean): void {
activeConfirmation?.resolve(confirmed);
for (const confirmation of queuedConfirmations) {
confirmation.resolve(confirmed);
}
activeConfirmation = null;
queuedConfirmations = [];
}
export function readConfirmDialogState(): ConfirmDialogState {
return state;
}
/**
* Only themed hosts subscribe, so a subscriber is a mounted host. When the last
* one leaves, pending confirmations resolve as cancelled.
*/
export function subscribeConfirmDialogHost(listener: () => void): () => void {
listeners.add(listener);
return () => {
if (!listeners.delete(listener) || listeners.size > 0) return;
resolvePendingConfirmations(false);
publish(idleState);
};
}
/** Undefined means no themed host is available. */
export function requestConfirmDialog(
message: string,
options?: ConfirmDialogOptions,
): Promise<boolean> | undefined {
if (listeners.size === 0) return undefined;
const confirmation = new Promise<boolean>((resolve) => {
const pending = {
message,
variant: options?.variant ?? "default",
resolve,
} satisfies PendingConfirmation;
if (activeConfirmation || state.status === "closing") {
queuedConfirmations.push(pending);
return;
}
activeConfirmation = pending;
publish({ status: "confirming", message, variant: pending.variant });
});
return confirmation;
}
export function isConfirmDialogActive(): boolean {
return state.status !== "idle" || activeConfirmation !== null || queuedConfirmations.length > 0;
}
export function respondToConfirmDialog(confirmed: boolean): void {
if (state.status !== "confirming" || !activeConfirmation) return;
const confirmation = activeConfirmation;
activeConfirmation = null;
confirmation.resolve(confirmed);
publish({ status: "closing", message: state.message, variant: state.variant });
}
export function completeConfirmDialogClose(): void {
if (state.status !== "closing") return;
const next = queuedConfirmations.shift();
if (!next) {
publish(idleState);
return;
}
activeConfirmation = next;
publish({ status: "confirming", message: next.message, variant: next.variant });
}
export function resetConfirmDialogForTests(): void {
listeners.clear();
resolvePendingConfirmations(false);
publish(idleState);
}