@eventlook/sdk 1.7.4 → 1.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventlook/sdk",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",

package/src/form/tickets/TicketSelection.tsx

@@ -121,7 +121,13 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
   };
 
   const selectedTickets = async () => {
-    const releases = await mutate();
+    // Use the cache we already have instead of revalidating here. A network
+    // revalidate refetches active-releases and returns the next wave as
+    // locked again, clobbering the local unlock below (mutate(..., false)).
+    // Since this runs in an effect keyed on [tickets, activeReleases], that
+    // re-locking re-fires the effect and we ping-pong, hammering
+    // /active-releases several times a second (and dropping the user's add).
+    const releases = activeReleases;
     const currentReleases = releases || activeReleases || [];
     const allFilled = tickets.filter((item) => !item.releaseId || !item.quantity);
 
@@ -142,19 +148,25 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
             item.order === release.order - 1
         );
 
-        if (!release.locked || !previousRelease) return release;
+        // The first wave in a category is never gated by a previous one.
+        if (!previousRelease) return release;
 
         const previousTicket = tickets.find((ticket) => ticket.releaseId === previousRelease.id);
         const previousMaxSelectable = Math.min(
           previousRelease.availableTickets || 0,
           maxTicketsPerOrder
         );
-        const shouldUnlock = Number(previousTicket?.quantity || 0) >= previousMaxSelectable;
+        // A later wave is unlocked only while the previous wave is filled to its
+        // max. Derive the lock from the cart both ways: unlock when the previous
+        // wave is maxed, re-lock when the customer reduces it again. (We can't
+        // lean on a server refetch to re-lock — that revalidation was the cause
+        // of the active-releases loop.)
+        const shouldBeLocked = Number(previousTicket?.quantity || 0) < previousMaxSelectable;
 
-        if (!shouldUnlock) return release;
+        if (release.locked === shouldBeLocked) return release;
 
         hasChanges = true;
-        return { ...release, locked: false };
+        return { ...release, locked: shouldBeLocked };
       });
 
       if (hasChanges) {

package/src/form/tickets/TicketWithMerchandiseSelection.tsx

@@ -62,7 +62,11 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
   const isReleaseSelected = (id: number) => !!tickets.find((ticket) => ticket.releaseId === id);
 
   const selectedTickets = async () => {
-    const releases = await mutate();
+    // Use the cache we already have instead of revalidating here. A network
+    // revalidate refetches active-releases and returns the next wave as locked
+    // again, clobbering the local lock state below and ping-ponging the effect
+    // (deps [tickets, activeReleases]) into an active-releases refetch loop.
+    const releases = activeReleases;
     const currentReleases = releases || activeReleases || [];
     const allFilled = tickets.filter((item) => !item.releaseId || !item.quantity);
 
@@ -84,19 +88,24 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
             item.order === release.order - 1
         );
 
-        if (!release.locked || !previousRelease) return release;
+        // The first wave in a category is never gated by a previous one.
+        if (!previousRelease) return release;
 
         const previousTicket = tickets.find((ticket) => ticket.releaseId === previousRelease.id);
         const previousMaxSelectable = Math.min(
           previousRelease.availableTickets || 0,
           maxTicketsPerOrder
         );
-        const shouldUnlock = Number(previousTicket?.quantity || 0) >= previousMaxSelectable;
+        // Derive the lock from the cart both ways: unlock the next wave while the
+        // previous one is filled to its max, re-lock it when the customer reduces
+        // it again (we can't lean on a server refetch to re-lock — that was the
+        // active-releases loop).
+        const shouldBeLocked = Number(previousTicket?.quantity || 0) < previousMaxSelectable;
 
-        if (!shouldUnlock) return release;
+        if (release.locked === shouldBeLocked) return release;
 
         hasChanges = true;
-        return { ...release, locked: false };
+        return { ...release, locked: shouldBeLocked };
       });
 
       if (hasChanges) {