@snowcone-app/ui 0.9.5 → 0.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowcone-app/ui",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "React components for merchandise visualization and customization",
   "keywords": [
     "react",

package/src/patterns/RealtimeProvider.tsx

@@ -64,6 +64,8 @@ const MAX_CONCURRENT_BLOBS = 5;
 
 /** How long a frame whose blob: URL was revoked waits for its newer frame before counting as a real failure. */
 const FRAME_SUPERSEDE_GRACE_MS = 2000;
+/** The box accepts one `rerender` per this many ms (rc#840; more are refused with E_RERENDER_RATE_LIMITED). */
+const RERENDER_MIN_INTERVAL_MS = 550;
 
 /** `current` in order, then any of `extra` not already in it. */
 function mergeMockupIds(current: readonly string[], extra: readonly string[]): string[] {
@@ -617,6 +619,10 @@ export function RealtimeProvider({
   // Mockups a `rerender` was sent for, until it is answered or refused.
   const pendingRerenderRef = useRef<string[]>([]);
   const forceRerenderByConfigRef = useRef<((failed: string[]) => void) | null>(null);
+  // Pacing of `rerender` requests (the box allows one per 500 ms).
+  const lastRerenderAtRef = useRef(0);
+  const rerenderQueueRef = useRef<string[]>([]);
+  const rerenderTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   // Cropped frames that could not be shown, waiting for one batched
   // full-frame re-render (see rerenderFullFrame).
   const fullFrameRerenderIdsRef = useRef<Set<string>>(new Set());
@@ -743,6 +749,35 @@ export function RealtimeProvider({
   );
   forceRerenderByConfigRef.current = forceRerenderByConfig;
 
+  /**
+   * Ask the box to re-render `ids`, never faster than it allows (one request
+   * per RERENDER_MIN_INTERVAL_MS; it refuses more with E_RERENDER_RATE_LIMITED,
+   * prod 2026-11-11). Requests inside the interval wait for the remainder and
+   * go out as ONE request with every picture that failed meanwhile.
+   */
+  const sendRerenderPaced = useCallback(
+    (ids: string[]) => {
+      rerenderQueueRef.current = mergeMockupIds(rerenderQueueRef.current, ids);
+      if (rerenderTimerRef.current) return;
+      const wait = Math.max(0, lastRerenderAtRef.current + RERENDER_MIN_INTERVAL_MS - Date.now());
+      const flush = () => {
+        rerenderTimerRef.current = null;
+        const batch = rerenderQueueRef.current;
+        rerenderQueueRef.current = [];
+        if (batch.length === 0) return;
+        lastRerenderAtRef.current = Date.now();
+        pendingRerenderRef.current = mergeMockupIds(pendingRerenderRef.current, batch);
+        if (!rerenderRaw(batch)) {
+          pendingRerenderRef.current = [];
+          forceRerenderByConfigRef.current?.(batch);
+        }
+      };
+      if (wait === 0) flush();
+      else rerenderTimerRef.current = setTimeout(flush, wait);
+    },
+    [rerenderRaw]
+  );
+
   const rerenderFullFrame = useCallback(
     (mockupId: string) => {
       fullFrameRerenderIdsRef.current.add(mockupId);
@@ -769,14 +804,13 @@ export function RealtimeProvider({
           // for exactly the failed pictures. A refusal (E_RERENDER_*) falls
           // back to the config way (see onError).
           sendFullFrameConfig(ids);
-          pendingRerenderRef.current = failed;
-          if (rerenderRaw(failed)) return;
-          pendingRerenderRef.current = [];
+          sendRerenderPaced(failed);
+          return;
         }
         forceRerenderByConfig(failed);
       }, 0);
     },
-    [sendFullFrameConfig, forceRerenderByConfig, rerenderRaw]
+    [sendFullFrameConfig, forceRerenderByConfig, sendRerenderPaced]
   );
 
   /** Flip to cropped delivery once every configured mockup has a frozen

package/src/patterns/__tests__/RealtimeProvider.cropDelivery.test.tsx

@@ -453,5 +453,29 @@ describe("RealtimeProvider cropped delivery", () => {
     expect(sentConfigs().every((c) => c.overlayCrop === undefined)).toBe(true);
     errSpy.mockRestore();
   });
+
+  it("never asks the box to rerender faster than it allows: failures 100 ms apart become 2 requests >= 500 ms apart", async () => {
+    const { rerender } = render(<Harness version={1} />);
+    await waitFor(() => expect(h.sendConfig).toHaveBeenCalled());
+    const v = { versions: { Front: 1 } };
+    h.state.results = [{ ...fullResult("m1", "https://r/m1-full"), ...v }, { ...fullResult("m2", "https://r/m2-full"), ...v }];
+    await act(async () => rerender(<Harness version={2} />));
+    await waitFor(() => expect(sentConfigs().some((c) => c.overlayCrop === "auto")).toBe(true));
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    h.compositeCroppedFrame.mockRejectedValue(new Error("E_OVERLAY_ENCODE_FAILED"));
+    const calls: number[] = [];
+    h.rerender.mockImplementation(() => { calls.push(Date.now()); return true; });
+
+    h.state.results = [croppedResult("m1", "https://r/m1-crop-a")];
+    await act(async () => rerender(<Harness version={3} />));
+    await act(async () => { await new Promise((r) => setTimeout(r, 100)); });
+    h.state.results = [croppedResult("m1", "https://r/m1-crop-a"), croppedResult("m2", "https://r/m2-crop-a")];
+    await act(async () => rerender(<Harness version={4} />));
+    await act(async () => { await new Promise((r) => setTimeout(r, 900)); });
+
+    expect(h.rerender.mock.calls.map((c) => c[0])).toEqual([["m1"], ["m2"]]);
+    expect(calls[1] - calls[0]).toBeGreaterThanOrEqual(500);
+    errSpy.mockRestore();
+  });
 });