File size: 5,643 Bytes
103a492
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
95fb175
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
import { TOAST_EVENT, UNAUTHORIZED_EVENT } from "../apiContract";
import "../styles/sdlc76/toasts.css";

type ToastTone = "info" | "error";
type ToastDetail = { text: string; tone: ToastTone };
type ToastMessage = ToastDetail & { id: number };

function parseToast(detail: unknown): ToastDetail | null {
  if (typeof detail === "string") {
    const text = detail.trim();
    return text ? { text, tone: "info" } : null;
  }
  if (!detail || typeof detail !== "object" || Array.isArray(detail)) return null;
  const { text, tone } = detail as Record<string, unknown>;
  if (typeof text !== "string" || !text.trim() || (tone !== "info" && tone !== "error")) return null;
  return { text: text.trim(), tone };
}

function Toast({ message, onDismiss }: { message: ToastMessage; onDismiss: (id: number) => void }) {
  const element = useRef<HTMLDivElement>(null);
  const remaining = useRef(Math.min(12000, 6000 + Array.from(message.text).length * 60));
  const started = useRef<number | null>(null);
  const timers = useRef<{ exit: number | null; remove: number | null }>({ exit: null, remove: null });
  const hovered = useRef(false);
  const focused = useRef(false);
  const [leaving, setLeaving] = useState(false);
  const [text, setText] = useState("");

  const stop = useCallback(() => {
    if (started.current !== null) {
      remaining.current = Math.max(0, remaining.current - (performance.now() - started.current));
      started.current = null;
    }
    if (timers.current.exit !== null) window.clearTimeout(timers.current.exit);
    if (timers.current.remove !== null) window.clearTimeout(timers.current.remove);
    timers.current = { exit: null, remove: null };
  }, []);

  const resume = useCallback(() => {
    if (hovered.current || focused.current || started.current !== null || !element.current) return;
    const duration = Math.max(0, ...window.getComputedStyle(element.current).transitionDuration.split(",").map((time) => {
      const value = parseFloat(time);
      return Number.isFinite(value) ? value * (time.trim().endsWith("ms") ? 1 : 1000) : 0;
    }));
    started.current = performance.now();
    // Exit motion is part of the reading time, so DOM removal keeps the same deadline.
    if (duration > 0) {
      timers.current.exit = window.setTimeout(() => setLeaving(true), Math.max(0, remaining.current - duration));
    }
    timers.current.remove = window.setTimeout(() => onDismiss(message.id), remaining.current);
  }, [message.id, onDismiss]);

  useLayoutEffect(() => {
    resume();
    return stop;
  }, [resume, stop]);

  // Populate the live region after it mounts, once for each message identity.
  useEffect(() => setText(message.text), [message.text]);

  return (
    <div ref={element} className={`shell-toast${leaving ? " is-leaving" : ""}`}
      role="status" aria-atomic="true" tabIndex={0} data-tone={message.tone}
      onPointerEnter={() => { hovered.current = true; stop(); setLeaving(false); }}
      onPointerLeave={() => { hovered.current = false; resume(); }}
      onFocus={() => { focused.current = true; stop(); setLeaving(false); }}
      onBlur={(event) => {
        if (event.currentTarget.contains(event.relatedTarget)) return;
        focused.current = false;
        resume();
      }}>
      {text}
    </div>
  );
}

export function ToastStack({ signOutEvent }: { signOutEvent: string }) {
  const [messages, setMessages] = useState<ToastMessage[]>([]);
  const sequence = useRef(0);
  const dismiss = useCallback((id: number) => {
    setMessages((current) => current.filter((message) => message.id !== id));
  }, []);

  useLayoutEffect(() => {
    let accepting = true;
    const onToast = (event: Event) => {
      if (!accepting) return;
      const detail = parseToast((event as CustomEvent<unknown>).detail);
      if (!detail) return;
      const message = { ...detail, id: ++sequence.current };
      setMessages((current) => [...current.slice(-2), message]);
    };
    const clear = () => { accepting = false; setMessages([]); };
    window.addEventListener(TOAST_EVENT, onToast);
    window.addEventListener(signOutEvent, clear);
    window.addEventListener(UNAUTHORIZED_EVENT, clear);
    return () => {
      accepting = false;
      window.removeEventListener(TOAST_EVENT, onToast);
      window.removeEventListener(signOutEvent, clear);
      window.removeEventListener(UNAUTHORIZED_EVENT, clear);
    };
  }, [signOutEvent]);

  if (!messages.length) return null;
  return (
    <div className="shell-toast-stack">
      {messages.map((message) => <Toast key={message.id} message={message} onDismiss={dismiss} />)}
    </div>
  );
}

// Refusals reach the shared stack as error toasts. The callback is stable, so effects may depend on it.
export function useRefusalToast() {
  const [messages, setMessages] = useState<{ id: number; text: string }[]>([]);
  const sequence = useRef(0);
  const delivered = useRef(0);
  useEffect(() => {
    if (!messages.length) return;
    const through = messages[messages.length - 1].id;
    for (const message of messages) {
      if (message.id <= delivered.current) continue;
      delivered.current = message.id;
      const text = message.text;
      window.dispatchEvent(new CustomEvent(TOAST_EVENT, { detail: { text, tone: "error" } }));
    }
    setMessages((current) => current.filter((message) => message.id > through));
  }, [messages]);
  return useCallback((text: string) => {
    if (!text) return;
    const message = { id: ++sequence.current, text };
    setMessages((current) => [...current, message]);
  }, []);
}