@digilogiclabs/saas-factory-ui 1.16.0 → 1.16.2

package/dist/index.js

@@ -30292,6 +30292,8 @@ var SHOW_ROT = {
   6: { x: 90, y: 0 }
 };
 var MAX_COUNT = 6;
+var TUMBLE_MS = 950;
+var SETTLE_MS = 1100;
 function simulateDice(arenaW, arenaH, diceSize, starts, numDice) {
   const pad = diceSize * 0.55;
   const minX = pad;
@@ -30304,17 +30306,20 @@ function simulateDice(arenaW, arenaH, diceSize, starts, numDice) {
   for (let i = 0; i < numDice; i++) {
     const s = starts[i] ?? { x: arenaW / 2, y: arenaH / 2 };
     bodies.push({
-      x: clamp(s.x + (Math.random() - 0.5) * arenaW * 0.2, minX, maxX),
-      y: clamp(s.y + (Math.random() - 0.5) * arenaH * 0.2, minY, maxY),
-      vx: (Math.random() - 0.5) * arenaW * 0.9,
-      vy: (Math.random() - 0.5) * arenaH * 0.9
+      x: clamp(s.x + (Math.random() - 0.5) * arenaW * 0.25, minX, maxX),
+      y: clamp(s.y + (Math.random() - 0.5) * arenaH * 0.25, minY, maxY),
+      // Minimum baseline velocity so small arenas still bounce visibly
+      // instead of drifting a few pixels. The `|| 1` guard makes sure
+      // we never get a near-zero initial velocity from `random - 0.5`.
+      vx: (Math.sign(Math.random() - 0.5) || 1) * (0.5 + Math.random() * 0.5) * arenaW * 1.4,
+      vy: (Math.sign(Math.random() - 0.5) || 1) * (0.5 + Math.random() * 0.5) * arenaH * 1.6
     });
   }
-  const steps = 24;
+  const steps = 32;
   const dt = 2 / steps;
-  const friction = 0.86;
-  const wallRestitution = -0.55;
-  const diceRestitution = 0.7;
+  const friction = 0.9;
+  const wallRestitution = -0.72;
+  const diceRestitution = 0.8;
   const frames = [];
   for (let s = 0; s < steps; s++) {
     for (const b of bodies) {
@@ -30495,11 +30500,13 @@ function DiceRoller({
   const [rolling, setRolling] = (0, import_react66.useState)(false);
   const [results, setResults] = (0, import_react66.useState)(null);
   const [history, setHistory] = (0, import_react66.useState)([]);
-  const [rotations, setRotations] = (0, import_react66.useState)(
-    () => Array.from({ length: MAX_COUNT }, () => ({ x: 0, y: 0, z: 0, tr: true }))
-  );
-  const [positions, setPositions] = (0, import_react66.useState)(null);
+  const dieWrapperRefs = (0, import_react66.useRef)([]);
+  const cubeRefs = (0, import_react66.useRef)([]);
+  const shadowRefs = (0, import_react66.useRef)([]);
+  const currentPositionsRef = (0, import_react66.useRef)(null);
+  const rollingRef = (0, import_react66.useRef)(false);
   const timersRef = (0, import_react66.useRef)([]);
+  const rafHandleRef = (0, import_react66.useRef)(null);
   const arenaRef = (0, import_react66.useRef)(null);
   const arena = useArenaBounds(arenaRef);
   const colors = (0, import_react66.useMemo)(() => {
@@ -30568,15 +30575,54 @@ function DiceRoller({
     })),
     []
   );
+  const writeDiePosition = (0, import_react66.useCallback)(
+    (i, x, y) => {
+      const el = dieWrapperRefs.current[i];
+      if (!el) return;
+      el.style.transform = `translate3d(${x - half}px, ${y - half}px, 0)`;
+    },
+    [half]
+  );
+  const writeCubeRotation = (0, import_react66.useCallback)(
+    (i, rx, ry, rz, withTransition) => {
+      const el = cubeRefs.current[i];
+      if (!el) return;
+      el.style.transition = withTransition ? "transform 0.95s cubic-bezier(0.12,0.8,0.22,1)" : "none";
+      el.style.transform = `rotateX(${rx}deg) rotateY(${ry}deg) rotateZ(${rz}deg)`;
+    },
+    []
+  );
   (0, import_react66.useEffect)(() => {
+    const w = arenaRef.current?.offsetWidth ?? arena.w;
+    const h = arenaRef.current?.offsetHeight ?? arenaHeight;
+    if (w === 0 || h === 0) return;
+    const initial = defaultPositions(w, h, clampedCount);
+    currentPositionsRef.current = initial;
+    for (let i = 0; i < clampedCount; i++) {
+      const pos = initial[i];
+      const el = dieWrapperRefs.current[i];
+      if (el) {
+        el.style.transition = "transform 0.35s cubic-bezier(0.25,0.46,0.45,0.94)";
+        el.style.transform = `translate3d(${pos.x - half}px, ${pos.y - half}px, 0)`;
+      }
+      const cube = cubeRefs.current[i];
+      if (cube) {
+        cube.style.transition = "none";
+        cube.style.transform = "rotateX(0deg) rotateY(0deg) rotateZ(0deg)";
+      }
+    }
     setResults(null);
-    setPositions(null);
-    setRotations(
-      Array.from({ length: MAX_COUNT }, () => ({ x: 0, y: 0, z: 0, tr: true }))
-    );
-  }, [clampedCount, effectiveSize]);
+  }, [
+    clampedCount,
+    effectiveSize,
+    arena.w,
+    arenaHeight,
+    defaultPositions,
+    half
+  ]);
   const roll = (0, import_react66.useCallback)(() => {
-    if (rolling) return;
+    if (rollingRef.current) return;
+    rollingRef.current = true;
     setRolling(true);
     const vals = Array.from(
       { length: clampedCount },
@@ -30584,21 +30630,29 @@ function DiceRoller({
     );
     timersRef.current.forEach((t) => clearTimeout(t));
     timersRef.current = [];
+    if (rafHandleRef.current != null) {
+      cancelAnimationFrame(rafHandleRef.current);
+      rafHandleRef.current = null;
+    }
     const w = arenaRef.current?.offsetWidth ?? 400;
     const h = arenaRef.current?.offsetHeight ?? 260;
-    const starts = positions ?? defaultPositions(w, h, clampedCount);
+    const starts = currentPositionsRef.current ?? defaultPositions(w, h, clampedCount);
     if (reducedMotion) {
-      setPositions(defaultPositions(w, h, clampedCount));
-      setRotations((prev) => {
-        const n = [...prev];
-        for (let i = 0; i < clampedCount; i++) {
-          const tgt = SHOW_ROT[vals[i]];
-          n[i] = { x: tgt.x, y: tgt.y, z: 0, tr: false };
+      const final = defaultPositions(w, h, clampedCount);
+      currentPositionsRef.current = final;
+      for (let i = 0; i < clampedCount; i++) {
+        const p = final[i];
+        const el = dieWrapperRefs.current[i];
+        if (el) {
+          el.style.transition = "transform 0.2s ease-out";
+          el.style.transform = `translate3d(${p.x - half}px, ${p.y - half}px, 0)`;
         }
-        return n;
-      });
+        const tgt = SHOW_ROT[vals[i]];
+        writeCubeRotation(i, tgt.x, tgt.y, 0, true);
+      }
       setResults(vals);
       setRolling(false);
+      rollingRef.current = false;
       const total2 = vals.reduce((a, b) => a + b, 0);
       onRoll?.(vals, total2);
       if (showHistory) {
@@ -30607,60 +30661,84 @@ function DiceRoller({
       return;
     }
     const frames = simulateDice(w, h, effectiveSize, starts, clampedCount);
-    setRotations((prev) => {
-      const n = [...prev];
-      for (let i = 0; i < clampedCount; i++) {
-        n[i] = {
-          x: (Math.random() - 0.5) * 720,
-          y: (Math.random() - 0.5) * 720,
-          z: (Math.random() - 0.5) * 720,
-          tr: false
-        };
+    for (let i = 0; i < clampedCount; i++) {
+      writeCubeRotation(
+        i,
+        (Math.random() - 0.5) * 720,
+        (Math.random() - 0.5) * 720,
+        (Math.random() - 0.5) * 720,
+        false
+      );
+      const el = dieWrapperRefs.current[i];
+      if (el) el.style.transition = "none";
+      const shadow = shadowRefs.current[i];
+      if (shadow) shadow.style.opacity = "0.2";
+    }
+    if (dieWrapperRefs.current[0]) {
+      dieWrapperRefs.current[0].offsetHeight;
+    }
+    const playbackMs = TUMBLE_MS;
+    const startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const tick = (now) => {
+      const elapsed = now - startTime;
+      const progress = Math.max(0, Math.min(1, elapsed / playbackMs));
+      const idx = Math.min(
+        frames.length - 1,
+        Math.floor(progress * frames.length)
+      );
+      const frame = frames[idx];
+      if (frame) {
+        for (let i = 0; i < clampedCount; i++) {
+          const p = frame[i];
+          if (p) writeDiePosition(i, p.x, p.y);
+        }
+        currentPositionsRef.current = frame.slice(0, clampedCount);
       }
-      return n;
-    });
-    const stepMs = 40;
-    for (let s = 0; s < frames.length; s++) {
-      const timer = setTimeout(() => {
-        setPositions(frames[s].slice(0, clampedCount));
-      }, s * stepMs);
-      timersRef.current.push(timer);
-    }
+      if (progress < 1) {
+        rafHandleRef.current = requestAnimationFrame(tick);
+      } else {
+        rafHandleRef.current = null;
+        for (let i = 0; i < clampedCount; i++) {
+          const el = dieWrapperRefs.current[i];
+          if (el)
+            el.style.transition = "transform 0.35s cubic-bezier(0.25,0.46,0.45,0.94)";
+          const shadow = shadowRefs.current[i];
+          if (shadow) shadow.style.opacity = "0.85";
+        }
+      }
+    };
+    rafHandleRef.current = requestAnimationFrame(tick);
     requestAnimationFrame(() => {
       requestAnimationFrame(() => {
-        setRotations((prev) => {
-          const n = [...prev];
-          for (let i = 0; i < clampedCount; i++) {
-            const tgt = SHOW_ROT[vals[i]];
-            n[i] = {
-              x: tgt.x + (Math.random() > 0.5 ? 720 : -720),
-              y: tgt.y,
-              z: (Math.random() > 0.5 ? 1 : -1) * 360,
-              tr: true
-            };
-          }
-          return n;
-        });
+        for (let i = 0; i < clampedCount; i++) {
+          const tgt = SHOW_ROT[vals[i]];
+          const lx = tgt.x + (Math.random() > 0.5 ? 720 : -720);
+          const ly = tgt.y;
+          const lz = (Math.random() > 0.5 ? 1 : -1) * 360;
+          writeCubeRotation(i, lx, ly, lz, true);
+        }
       });
     });
     const settleTimer = setTimeout(() => {
       setResults(vals);
       setRolling(false);
+      rollingRef.current = false;
       const total2 = vals.reduce((a, b) => a + b, 0);
       onRoll?.(vals, total2);
       if (showHistory) {
         setHistory((prev) => [{ vals, total: total2 }, ...prev].slice(0, historyMax));
       }
-    }, 1050);
+    }, SETTLE_MS);
     timersRef.current.push(settleTimer);
   }, [
-    rolling,
     clampedCount,
-    positions,
     defaultPositions,
     effectiveSize,
+    half,
     reducedMotion,
     onRoll,
+    writeCubeRotation,
+    writeDiePosition,
     showHistory,
     historyMax
   ]);
@@ -30679,10 +30757,13 @@ function DiceRoller({
     () => () => {
       timersRef.current.forEach((t) => clearTimeout(t));
       timersRef.current = [];
+      if (rafHandleRef.current != null) {
+        cancelAnimationFrame(rafHandleRef.current);
+        rafHandleRef.current = null;
+      }
     },
     []
   );
-  const activePositions = positions ?? defaultPositions(arena.w, arenaHeight, clampedCount);
   const total = results ? results.reduce((a, b) => a + b, 0) : null;
   return /* @__PURE__ */ (0, import_jsx_runtime114.jsxs)(
     "div",
@@ -30710,27 +30791,22 @@ function DiceRoller({
               cursor: trigger === "click" ? "pointer" : void 0
             },
             children: Array.from({ length: clampedCount }, (_, d) => {
-              const rot = rotations[d] ?? { x: 0, y: 0, z: 0, tr: true };
-              const pos = activePositions[d] ?? {
-                x: arena.w / 2,
-                y: arenaHeight / 2
-              };
-              const translate = `translate3d(${pos.x - half}px, ${pos.y - half}px, 0)`;
               return /* @__PURE__ */ (0, import_jsx_runtime114.jsxs)(
                 "div",
                 {
+                  ref: (el) => {
+                    dieWrapperRefs.current[d] = el;
+                  },
                   style: {
                     position: "absolute",
                     left: 0,
                     top: 0,
                     width: effectiveSize,
                     height: effectiveSize,
-                    transform: translate,
                     // Parent must preserve 3D so the inner cube's rotateX/Y/Z
                     // still renders with depth — otherwise adding a transform
                     // to the wrapper would flatten its children into 2D.
                     transformStyle: "preserve-3d",
-                    transition: rolling ? "transform 0.04s linear" : "transform 0.35s cubic-bezier(0.25,0.46,0.45,0.94)",
                     willChange: "transform",
                     zIndex: 2,
                     perspective: 700
@@ -30739,6 +30815,9 @@ function DiceRoller({
                     /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(
                       "div",
                       {
+                        ref: (el) => {
+                          shadowRefs.current[d] = el;
+                        },
                         style: {
                           position: "absolute",
                           bottom: -6,
@@ -30748,7 +30827,7 @@ function DiceRoller({
                           background: `radial-gradient(ellipse,${colors.shadow} 0%,transparent 70%)`,
                           borderRadius: "50%",
                           pointerEvents: "none",
-                          opacity: rolling ? 0.2 : 0.85,
+                          opacity: 0.85,
                           transition: "opacity 0.3s"
                         }
                       }
@@ -30756,13 +30835,14 @@ function DiceRoller({
                     /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(
                       "div",
                       {
+                        ref: (el) => {
+                          cubeRefs.current[d] = el;
+                        },
                         style: {
                           width: "100%",
                           height: "100%",
                           position: "relative",
                           transformStyle: "preserve-3d",
-                          transition: rot.tr ? "transform 0.95s cubic-bezier(0.12,0.8,0.22,1)" : "none",
-                          transform: `rotateX(${rot.x}deg) rotateY(${rot.y}deg) rotateZ(${rot.z}deg)`,
                           willChange: "transform"
                         },
                         children: [1, 2, 3, 4, 5, 6].map((val, fi) => /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(