import { NativeThemeHost } from "./NativeThemeHost.android";
import {
AlertDialog,
Button,
OutlinedButton,
Icon,
FlowRow,
Column,
OutlinedTextField,
Text,
useNativeState,
} from "@expo/ui/jetpack-compose";
import { verticalScroll } from "@expo/ui/jetpack-compose/modifiers";
import { useAppearancePreferences } from "../../features/settings/appearance/AppearancePreferencesProvider";
import { useScaledTextRole } from "../../features/settings/appearance/useScaledTextRole";
import { useSyncExternalStore } from "react";
import { themeColorWithContrast } from "../../lib/mobileTheme";
import type { Alert, AlertButton } from "react-native";
import type { ConfirmDialogRequest, TextInputDialogRequest } from "./Dialog.types";
export type { ConfirmDialogRequest, TextInputDialogRequest } from "./Dialog.types";
type AlertRequest = {
readonly title: Parameters<typeof Alert.alert>[0];
readonly message: Parameters<typeof Alert.alert>[1];
readonly buttons: Parameters<typeof Alert.alert>[2];
readonly options: Parameters<typeof Alert.alert>[3];
};
type DialogRequest =
| { readonly kind: "alert"; readonly request: AlertRequest }
| { readonly kind: "confirm"; readonly request: ConfirmDialogRequest }
| { readonly kind: "text-input"; readonly request: TextInputDialogRequest };
type PresentedDialog = DialogRequest & { readonly id: number };
// App services raise dialogs before the root mounts, so the request lives in
// the module and the Host renders whatever is current. One dialog shows at a
// time: a new request replaces the presented one.
let presented: PresentedDialog | null = null;
let nextPresentationId = 0;
const listeners = new Set<() => void>();
function setPresented(next: PresentedDialog | null) {
presented = next;
for (const listener of listeners) listener();
}
function submitRequest(dialog: DialogRequest) {
setPresented({ ...dialog, id: ++nextPresentationId });
}
/** Closes the dialog only if it is still the one the action came from. */
function dismiss(id: number) {
if (presented?.id === id) setPresented(null);
}
function subscribe(listener: () => void) {
listeners.add(listener);
return () => {
listeners.delete(listener);
};
}
function getPresented() {
return presented;
}
export function alert(...[title, message, buttons, options]: Parameters<typeof Alert.alert>): void {
const actions = buttons?.length ? buttons.slice(0, 3) : [{ text: "OK" }];
const normalized = actions.map((action, index) =>
index === actions.length - 1 ? { ...action, text: action.text || "OK" } : action,
);
submitRequest({
kind: "alert",
request: { title, message, buttons: normalized, options },
});
}
export function confirm(request: ConfirmDialogRequest): void {
submitRequest({ kind: "confirm", request });
}
export function prompt(request: TextInputDialogRequest): void {
submitRequest({ kind: "text-input", request });
}
export function Host() {
const presented = useSyncExternalStore(subscribe, getPresented, getPresented);
const handleCancel = () => {
if (!presented) return;
dismiss(presented.id);
if (presented.kind === "alert") presented.request.options?.onDismiss?.();
else presented.request.onCancel?.();
};
const handleConfirm = (nativeInputValue?: string) => {
if (!presented) return;
dismiss(presented.id);
if (presented.kind === "confirm") {
presented.request.onConfirm();
} else if (presented.kind === "text-input") {
presented.request.onConfirm(nativeInputValue ?? presented.request.initialValue);
}
};
if (presented?.kind === "alert") {
return (
<DialogPresentation
key={presented.id}
request={{
title: presented.request.title ?? "",
message: presented.request.message ?? undefined,
confirmText: "",
}}
alertActions={presented.request.buttons ?? [{ text: "OK" }]}
dismissable={presented.request.options?.cancelable ?? false}
onAlertAction={(action) => {
dismiss(presented.id);
action.onPress?.();
}}
onCancel={handleCancel}
onConfirm={handleConfirm}
/>
);
}
return presented ? (
<DialogPresentation
key={presented.id}
request={presented.request}
inputInitialValue={
presented.kind === "text-input" ? presented.request.initialValue : undefined
}
inputPlaceholder={presented.kind === "text-input" ? presented.request.placeholder : undefined}
onCancel={handleCancel}
onConfirm={handleConfirm}
/>
) : null;
}
function DialogPresentation(props: DialogPresentationProps) {
const { themeVariables: colors } = useAppearancePreferences();
const titleTypography = useScaledTextRole("title");
const bodyTypography = useScaledTextRole("footnote");
const inputTypography = useScaledTextRole("body");
const inputState = useNativeState(props.inputInitialValue ?? "");
const inputSelection = useNativeState({ start: 0, end: props.inputInitialValue?.length ?? 0 });
const confirm = () => {
const value = props.inputInitialValue === undefined ? undefined : inputState.get();
props.onConfirm(value);
};
const actions = props.alertActions ?? [
{ text: props.request.cancelText ?? "Cancel", onPress: props.onCancel },
{
text: props.request.confirmText,
style: props.request.destructive ? ("destructive" as const) : ("default" as const),
onPress: confirm,
},
];
const destructive = actions.some((action) => action.style === "destructive");
// Error text colors can be pastel in dark themes. Filled actions need a white-label contrast pair.
const destructiveFill = themeColorWithContrast(colors["--color-danger-foreground"], "#ffffff");
const renderAction = (action: AlertButton, index: number) => {
const isDestructive = action.style === "destructive";
const isPrimary = isDestructive || index === actions.length - 1;
const Component = isPrimary ? Button : OutlinedButton;
return (
<Component
key={index}
onClick={() => (props.alertActions ? props.onAlertAction?.(action) : action.onPress?.())}
colors={{
containerColor: isDestructive
? destructiveFill
: isPrimary
? colors["--color-prominent-action"]
: "#00000000",
contentColor: isDestructive
? "#ffffff"
: isPrimary
? colors["--color-prominent-action-foreground"]
: colors["--color-foreground"],
}}
>
<Text style={bodyTypography}>{action.text ?? ""}</Text>
</Component>
);
};
return (
<NativeThemeHost ignoreSafeAreaKeyboardInsets style={{ height: 0, width: 0 }}>
<AlertDialog
onDismissRequest={props.onCancel}
properties={{
dismissOnBackPress: props.dismissable ?? true,
dismissOnClickOutside: props.dismissable ?? true,
}}
tonalElevation={0}
colors={{
containerColor: colors["--color-card"],
titleContentColor: colors["--color-foreground"],
textContentColor: colors["--color-foreground-secondary"],
}}
>
<AlertDialog.Title>
<Column verticalArrangement={{ spacedBy: 16 }}>
{destructive ? (
<Icon
source={require("../../../assets/icons/delete.xml")}
tint={colors["--color-danger-foreground"]}
size={24}
/>
) : null}
<Text style={titleTypography}>{props.request.title}</Text>
</Column>
</AlertDialog.Title>
{props.inputInitialValue !== undefined ? (
<AlertDialog.Text>
<Column verticalArrangement={{ spacedBy: 16 }}>
{props.request.message ? (
<Text style={bodyTypography}>{props.request.message}</Text>
) : null}
<OutlinedTextField
autoFocus
singleLine
value={inputState}
selection={inputSelection}
textStyle={inputTypography}
keyboardOptions={{ imeAction: "done" }}
keyboardActions={{
onDone: confirm,
}}
colors={{
focusedTextColor: colors["--color-foreground"],
unfocusedTextColor: colors["--color-foreground"],
focusedIndicatorColor: colors["--color-focus"],
unfocusedIndicatorColor: colors["--color-border"],
cursorColor: colors["--color-focus"],
}}
>
<OutlinedTextField.Label>
<Text style={bodyTypography}>{props.request.title}</Text>
</OutlinedTextField.Label>
{props.inputPlaceholder ? (
<OutlinedTextField.Placeholder>
<Text style={bodyTypography}>{props.inputPlaceholder}</Text>
</OutlinedTextField.Placeholder>
) : null}
</OutlinedTextField>
</Column>
</AlertDialog.Text>
) : props.request.message ? (
<AlertDialog.Text>
<Text modifiers={[verticalScroll()]} style={bodyTypography}>
{props.request.message}
</Text>
</AlertDialog.Text>
) : null}
{actions.length > 1 ? (
<AlertDialog.DismissButton>
<FlowRow>{actions.slice(0, -1).map(renderAction)}</FlowRow>
</AlertDialog.DismissButton>
) : null}
{actions.length > 0 ? (
<AlertDialog.ConfirmButton>
{renderAction(actions[actions.length - 1]!, actions.length - 1)}
</AlertDialog.ConfirmButton>
) : null}
</AlertDialog>
</NativeThemeHost>
);
}
interface DialogPresentationProps {
readonly alertActions?: readonly AlertButton[];
readonly onAlertAction?: (action: AlertButton) => void;
readonly dismissable?: boolean;
readonly request: Pick<
ConfirmDialogRequest,
"title" | "message" | "cancelText" | "confirmText" | "destructive"
>;
readonly inputInitialValue?: string;
readonly inputPlaceholder?: string;
readonly onCancel: () => void;
readonly onConfirm: (inputValue?: string) => void;
}