@digilogiclabs/saas-factory-ui 2.7.0 → 2.8.0

package/dist/web/index.mjs

@@ -30544,6 +30544,7 @@ function DiceRoller({
   iconEmoji = "\u{1F3B2}",
   showHistory = false,
   historyMax = 8,
+  initialHistory,
   rollRef,
   arenaHeight: arenaHeightProp,
   hideResults = false,
@@ -30555,7 +30556,9 @@ function DiceRoller({
   const dark = useDarkMode(darkMode);
   const [rolling, setRolling] = useState66(false);
   const [results, setResults] = useState66(null);
-  const [history, setHistory] = useState66([]);
+  const [history, setHistory] = useState66(
+    () => initialHistory && initialHistory.length > 0 ? initialHistory.slice(0, historyMax) : []
+  );
   const dieWrapperRefs = useRef40([]);
   const cubeRefs = useRef40([]);
   const shadowRefs = useRef40([]);
@@ -30729,7 +30732,10 @@ function DiceRoller({
     defaultPositions,
     half
   ]);
+  const prevSidesRef = useRef40(sides);
   useEffect51(() => {
+    if (prevSidesRef.current === sides) return;
+    prevSidesRef.current = sides;
     setHistory([]);
   }, [sides]);
   const roll = useCallback41(() => {
@@ -31792,32 +31798,26 @@ function BracketGenerator({
   const autoPlay = useCallback42(() => {
     if (simulating) {
       if (autoRef.current) clearTimeout(autoRef.current);
+      autoRef.current = null;
       setSimulating(false);
       return;
     }
     setSimulating(true);
-    const tick = () => {
-      setBracketState((prev) => {
-        const next = prev.matches.find((m) => m.a && m.b && !m.winner);
-        if (!next) {
-          setSimulating(false);
-          return prev;
-        }
-        const completed = simulateMatch(next);
-        if (!completed) return prev;
-        let matches = prev.matches.map(
-          (m) => m.id === completed.id ? completed : m
-        );
-        matches = propagateWinner(matches, completed);
-        const finalMatch = matches.find((m) => m.round === prev.rounds - 1);
-        const champion = finalMatch?.winner || null;
-        if (!champion) autoRef.current = setTimeout(tick, simulateDelayMs);
-        else setSimulating(false);
-        return { ...prev, matches, champion };
-      });
+    simulateNext();
+  }, [simulating, simulateNext]);
+  useEffect52(() => {
+    if (!simulating) return;
+    const hasNext = bracketState.matches.some((m) => m.a && m.b && !m.winner);
+    if (bracketState.champion || !hasNext) {
+      setSimulating(false);
+      return;
+    }
+    autoRef.current = setTimeout(simulateNext, simulateDelayMs);
+    return () => {
+      if (autoRef.current) clearTimeout(autoRef.current);
+      autoRef.current = null;
     };
-    tick();
-  }, [simulating, simulateDelayMs]);
+  }, [simulating, bracketState, simulateDelayMs, simulateNext]);
   const advanceWinner = useCallback42(
     (matchId, winnerSlot) => {
       setBracketState((prev) => {
@@ -32811,6 +32811,8 @@ function CoinFlipper({
   tailsLabel = "Tails",
   showHistory = false,
   historyMax = 20,
+  initialHistory,
+  initialStats,
   flipRef,
   ariaLabel,
   className = ""
@@ -32819,8 +32821,23 @@ function CoinFlipper({
   const tc = typeof theme5 === "string" ? PRESETS3[theme5] || PRESETS3.gold : theme5;
   const [result, setResult] = useState68(null);
   const [flipping, setFlipping] = useState68(false);
-  const [history, setHistory] = useState68([]);
-  const [stats, setStats] = useState68({ heads: 0, tails: 0 });
+  const [history, setHistory] = useState68(
+    () => initialHistory && initialHistory.length > 0 ? initialHistory.slice(0, historyMax).map((result2, i) => ({ result: result2, id: -(i + 1) })) : []
+  );
+  const [stats, setStats] = useState68(() => {
+    if (initialStats) {
+      return {
+        heads: Math.max(0, Math.floor(initialStats.heads)),
+        tails: Math.max(0, Math.floor(initialStats.tails))
+      };
+    }
+    if (initialHistory && initialHistory.length > 0) {
+      const seeded = initialHistory.slice(0, historyMax);
+      const heads = seeded.filter((r) => r === "heads").length;
+      return { heads, tails: seeded.length - heads };
+    }
+    return { heads: 0, tails: 0 };
+  });
   const flipIdRef = useRef42(0);
   const coinRef = useRef42(null);
   const shadowRef = useRef42(null);
@@ -33755,6 +33772,23 @@ function ReelStage({
     }
   );
 }
+function computeDraftSeed(participants, drawnIds, removeWinners) {
+  if (!removeWinners || !drawnIds || drawnIds.length === 0) return null;
+  if (new Set(drawnIds).size !== drawnIds.length) return null;
+  const byId = new Map(participants.map((p) => [p.id, p]));
+  const drawn = [];
+  for (const id of drawnIds) {
+    const p = byId.get(id);
+    if (!p) return null;
+    drawn.push(p);
+  }
+  const drawnSet = new Set(drawnIds);
+  return {
+    pool: participants.filter((p) => !drawnSet.has(p.id)),
+    // Same cap as the live history (see the pop/promote paths).
+    history: drawn.slice(0, 20)
+  };
+}
 function RandomPlayerPicker({
   participants,
   mode = "wheel",
@@ -33769,6 +33803,7 @@ function RandomPlayerPicker({
   trigger = "button",
   label = "Spin",
   removeWinners = false,
+  initialDrawnIds,
   spinDuration = 5e3,
   minRevolutions = 4,
   maxRevolutions = 7,
@@ -33795,12 +33830,21 @@ function RandomPlayerPicker({
   const reducedMotion = usePrefersReducedMotion();
   const intensityCfg = INTENSITY_CONFIG[intensity];
   const physicsDriven = intensity === "dramatic" && !reducedMotion;
-  const [pool, setPool] = useState70(participants);
+  const [draftSeed] = useState70(
+    () => computeDraftSeed(participants, initialDrawnIds, removeWinners)
+  );
+  const [pool, setPool] = useState70(
+    draftSeed ? draftSeed.pool : participants
+  );
   const [rotation, setRotation] = useState70(0);
   const [reelY, setReelY] = useState70(0);
   const [spinning, setSpinning] = useState70(false);
-  const [winner, setWinner] = useState70(null);
-  const [history, setHistory] = useState70([]);
+  const [winner, setWinner] = useState70(
+    draftSeed ? draftSeed.history[0] ?? null : null
+  );
+  const [history, setHistory] = useState70(
+    draftSeed ? draftSeed.history : []
+  );
   const [revealKey, setRevealKey] = useState70(0);
   const [particles, setParticles] = useState70([]);
   const winnerTimer = useRef43(null);
@@ -33812,7 +33856,9 @@ function RandomPlayerPicker({
   const tickAudioRef = useRef43(null);
   const winAudioRef = useRef43(null);
   const containerRef = useRef43(null);
-  const prevIdsRef = useRef43("");
+  const prevIdsRef = useRef43(
+    draftSeed ? participants.map((p) => p.id).join("|") : ""
+  );
   const wheelSvgRef = useRef43(null);
   const reelTapeRef = useRef43(null);
   const rafRef = useRef43(null);
@@ -39418,8 +39464,8 @@ function RosterImport({
         maxNames,
         maxFileBytes,
         onClose: () => setOpen(false),
-        onImport: (names) => {
-          onImport(names);
+        onImport: (names, info) => {
+          onImport(names, info);
           setOpen(false);
         }
       }
@@ -39485,6 +39531,11 @@ function RosterImportModal({
     }),
     [table, column, skipHeader, maxNames]
   );
+  const extractedTotal = useMemo34(
+    () => extractRoster(table, { column, skipHeader }),
+    [table, column, skipHeader]
+  );
+  const trimmedCount = Math.max(0, extractedTotal.length - extracted.length);
   const handleFile = useCallback49(
     async (e) => {
       setFileError(null);
@@ -39862,7 +39913,10 @@ function RosterImportModal({
             "button",
             {
               type: "button",
-              onClick: () => onImport(extracted),
+              onClick: () => onImport(extracted, {
+                trimmedCount,
+                totalCount: extractedTotal.length
+              }),
               disabled: !canImport,
               style: primaryBtn(!canImport),
               children: confirmLabel
@@ -40066,6 +40120,19 @@ function IconUsers({ size = 40 }) {
     }
   );
 }
+function mergeNames(prev, incoming, max) {
+  const seen = new Set(prev.map((n) => n.toLowerCase()));
+  const room = Math.max(0, max - prev.length);
+  const deduped = [];
+  for (const n of incoming) {
+    const key = n.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(n);
+    if (deduped.length >= room) break;
+  }
+  return deduped.length > 0 ? [...prev, ...deduped] : prev;
+}
 function splitIntoTeams(names, count2) {
   const shuffled = shuffle(names);
   const teams = Array.from({ length: count2 }, () => []);
@@ -40139,29 +40206,14 @@ function TeamGenerator({
     const trimmed = input.trim();
     if (!trimmed) return;
     const newNames = trimmed.split(/[,\n]+/).map((n) => n.trim()).filter((n) => n.length > 0);
-    setNames((prev) => {
-      const room = Math.max(0, maxPlayers - prev.length);
-      return [...prev, ...newNames.slice(0, room)];
-    });
+    setNames((prev) => mergeNames(prev, newNames, maxPlayers));
     setInput("");
     inputRef.current?.focus();
   }, [input, maxPlayers]);
   const importNames = useCallback50(
     (incoming) => {
       if (incoming.length === 0) return;
-      setNames((prev) => {
-        const seen = new Set(prev.map((n) => n.toLowerCase()));
-        const room = Math.max(0, maxPlayers - prev.length);
-        const deduped = [];
-        for (const n of incoming) {
-          const key = n.toLowerCase();
-          if (seen.has(key)) continue;
-          seen.add(key);
-          deduped.push(n);
-          if (deduped.length >= room) break;
-        }
-        return deduped.length > 0 ? [...prev, ...deduped] : prev;
-      });
+      setNames((prev) => mergeNames(prev, incoming, maxPlayers));
     },
     [maxPlayers]
   );
@@ -40767,6 +40819,7 @@ function RoundRobinScheduler({
   resumeRounds,
   onTeamsChange,
   onGenerate,
+  onBeforeScheduleDiscard,
   labels,
   ariaLabel = "Round robin scheduler",
   className,
@@ -40785,7 +40838,7 @@ function RoundRobinScheduler({
   useEffect62(() => {
     onTeamsChange?.(teams);
   }, [teams, onTeamsChange]);
-  const mergeNames = useCallback51(
+  const mergeNames2 = useCallback51(
     (prev, incoming) => {
       const existing = new Set(prev.map((t) => t.toLowerCase()));
       const next = [...prev];
@@ -40802,23 +40855,29 @@ function RoundRobinScheduler({
     },
     [maxTeams, nameMaxLength]
   );
+  const gateDiscard = useCallback51(
+    (action) => rounds.length === 0 || !onBeforeScheduleDiscard || onBeforeScheduleDiscard(action),
+    [rounds.length, onBeforeScheduleDiscard]
+  );
   const addTeams = useCallback51(
     (raw) => {
       const names = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       if (names.length === 0) return;
-      setTeams((prev) => mergeNames(prev, names));
+      if (!gateDiscard("add")) return;
+      setTeams((prev) => mergeNames2(prev, names));
       setInput("");
       setRounds([]);
     },
-    [mergeNames]
+    [mergeNames2, gateDiscard]
   );
   const importTeams = useCallback51(
     (incoming) => {
       if (incoming.length === 0) return;
-      setTeams((prev) => mergeNames(prev, incoming));
+      if (!gateDiscard("import")) return;
+      setTeams((prev) => mergeNames2(prev, incoming));
       setRounds([]);
     },
-    [mergeNames]
+    [mergeNames2, gateDiscard]
   );
   const handleKeyDown = useCallback51(
     (e) => {
@@ -40829,10 +40888,14 @@ function RoundRobinScheduler({
     },
     [addTeams, input]
   );
-  const removeTeam = useCallback51((idx) => {
-    setTeams((prev) => prev.filter((_, i) => i !== idx));
-    setRounds([]);
-  }, []);
+  const removeTeam = useCallback51(
+    (idx) => {
+      if (!gateDiscard("remove")) return;
+      setTeams((prev) => prev.filter((_, i) => i !== idx));
+      setRounds([]);
+    },
+    [gateDiscard]
+  );
   const handleGenerate = useCallback51(() => {
     if (teams.length < minTeams) return;
     const result = generateSchedule(teams, L.roundLabel);
@@ -40840,15 +40903,17 @@ function RoundRobinScheduler({
     onGenerate?.(result);
   }, [teams, minTeams, L.roundLabel, onGenerate]);
   const handleShuffle = useCallback51(() => {
+    if (!gateDiscard("shuffle")) return;
     setTeams((prev) => shuffle(prev));
     setRounds([]);
-  }, []);
+  }, [gateDiscard]);
   const handleClear = useCallback51(() => {
+    if (!gateDiscard("clear")) return;
     setTeams([]);
     setRounds([]);
     setInput("");
     inputRef.current?.focus();
-  }, []);
+  }, [gateDiscard]);
   const canGenerate = teams.length >= minTeams;
   const rootStyle = {
     borderRadius: 16,
@@ -41314,7 +41379,11 @@ function Scoreboard({
   onRoundAdvance,
   onNewGame,
   onReset,
+  onBeforeReset,
+  onBeforeNewGame,
   nameMaxLength,
+  scoreMin = -9999,
+  scoreMax = 9999,
   labels,
   ariaLabel = "Scoreboard",
   className
@@ -41358,11 +41427,19 @@ function Scoreboard({
   useEffect63(() => {
     onTeamsChange?.(teams);
   }, [teams, onTeamsChange]);
-  const updateScore = useCallback52((index, delta) => {
-    setTeams(
-      (prev) => prev.map((t, i) => i === index ? { ...t, score: t.score + delta } : t)
-    );
-  }, []);
+  const updateScore = useCallback52(
+    (index, delta) => {
+      setTeams(
+        (prev) => prev.map(
+          (t, i) => i === index ? {
+            ...t,
+            score: Math.min(scoreMax, Math.max(scoreMin, t.score + delta))
+          } : t
+        )
+      );
+    },
+    [scoreMin, scoreMax]
+  );
   const updateName = useCallback52((index, name) => {
     setTeams((prev) => prev.map((t, i) => i === index ? { ...t, name } : t));
   }, []);
@@ -41385,19 +41462,21 @@ function Scoreboard({
     [minTeams]
   );
   const resetScores = useCallback52(() => {
+    if (onBeforeReset && !onBeforeReset()) return;
     setTeams((prev) => prev.map((t) => ({ ...t, score: 0 })));
     setRound(1);
     setHistory([]);
     setHistoryOpen(false);
     onReset?.();
-  }, [onReset]);
+  }, [onReset, onBeforeReset]);
   const newGame = useCallback52(() => {
+    if (onBeforeNewGame && !onBeforeNewGame()) return;
     setTeams(createDefaultTeams(seedCount, L.teamNamePrefix));
     setRound(1);
     setHistory([]);
     setHistoryOpen(false);
     onNewGame?.();
-  }, [seedCount, L.teamNamePrefix, onNewGame]);
+  }, [seedCount, L.teamNamePrefix, onNewGame, onBeforeNewGame]);
   const nextRound = useCallback52(() => {
     const snapshot = {
       round,