File size: 4,707 Bytes
affe37f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
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>
  );
}