@aranova/tracking-next 0.22.0 → 0.22.3

package/dist/index.js

@@ -1744,6 +1744,9 @@ function buildHeartbeatMetadata(surface, sdkVersion, packageName, triggers, gtag
 var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
 var DEFAULT_MAX_QUEUE_SIZE = 10;
 var HARD_MAX_BATCH = 50;
+var MAX_RETRY_BACKOFF_MS = 6e4;
+var MAX_BUFFERED_EVENTS2 = 200;
+var RETRY_BUFFER_KEY_PREFIX = "aranova_tracking_pending_v1";
 var API_KEY_HEADER = "X-Aranova-Api-Key";
 var SDK_VERSION_HEADER = "X-Aranova-Sdk-Version";
 var SDK_PACKAGE_HEADER = "X-Aranova-Sdk-Package";
@@ -1786,9 +1789,9 @@ function consentSnapshot() {
   }
 }
 async function postWithFetch(url, body, apiKey, identity, keepalive) {
-  if (typeof fetch !== "function") return;
+  if (typeof fetch !== "function") return "drop";
   try {
-    await fetch(url, {
+    const response = await fetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1804,9 +1807,49 @@ async function postWithFetch(url, body, apiKey, identity, keepalive) {
       credentials: "omit",
       mode: "cors"
     });
+    if (response.ok) return "ok";
+    if (response.status === 408 || response.status === 429 || response.status >= 500) {
+      return "retry";
+    }
+    return "drop";
   } catch {
+    return "retry";
   }
 }
+function retryBufferKey(apiKey, endpoint) {
+  return `${RETRY_BUFFER_KEY_PREFIX}:${apiKey}:${endpoint}`;
+}
+function readPendingBatches(key) {
+  if (typeof window === "undefined") return [];
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (entry) => typeof entry === "object" && entry !== null && "session" in entry && Array.isArray(entry.events)
+    );
+  } catch {
+    return [];
+  }
+}
+function writePendingBatches(key, batches) {
+  if (typeof window === "undefined") return;
+  try {
+    if (batches.length === 0) window.localStorage.removeItem(key);
+    else window.localStorage.setItem(key, JSON.stringify(batches));
+  } catch {
+  }
+}
+function trimToBufferCap(batches) {
+  let total = batches.reduce((sum, batch) => sum + batch.events.length, 0);
+  const trimmed = batches.slice();
+  while (total > MAX_BUFFERED_EVENTS2 && trimmed.length > 1) {
+    const dropped = trimmed.shift();
+    total -= dropped ? dropped.events.length : 0;
+  }
+  return trimmed;
+}
 var globalClient = null;
 var globalClientKey = null;
 function clientConfigKey(config) {
@@ -1862,6 +1905,10 @@ function createTrackingClient(config) {
   };
   let queue = [];
   let flushTimer = null;
+  const bufferKey = retryBufferKey(config.apiKey, endpointBase);
+  let pending = readPendingBatches(bufferKey);
+  let flushChain = Promise.resolve();
+  let retryAttempt = 0;
   let firstPage = null;
   let initialParams = createEmptyTrackingParams();
   let destroyed = false;
@@ -1898,6 +1945,9 @@ function createTrackingClient(config) {
   if (initialSession.isNew) {
     enqueueHeartbeat();
   }
+  if (pending.length > 0) {
+    scheduleFlush();
+  }
   function buildSessionPayload() {
     const rotated = getOrRotateSessionId();
     if (rotated.isNew && rotated.id !== sessionId) {
@@ -1936,12 +1986,12 @@ function createTrackingClient(config) {
       context
     };
   }
-  function scheduleFlush() {
+  function scheduleFlush(delayMs = flushIntervalMs) {
     if (flushTimer !== null || destroyed) return;
     flushTimer = setTimeout(() => {
       flushTimer = null;
       void flush();
-    }, flushIntervalMs);
+    }, delayMs);
   }
   function clearScheduledFlush() {
     if (flushTimer !== null) {
@@ -1949,17 +1999,50 @@ function createTrackingClient(config) {
       flushTimer = null;
     }
   }
-  async function flush() {
+  function bufferQueued() {
     if (queue.length === 0) return;
     const events = queue.slice(0, HARD_MAX_BATCH);
     queue = queue.slice(events.length);
+    pending = trimToBufferCap([...pending, { session: buildSessionPayload(), events }]);
+    writePendingBatches(bufferKey, pending);
+  }
+  function flush() {
+    flushChain = flushChain.then(runFlush).catch(() => {
+    });
+    return flushChain;
+  }
+  async function runFlush() {
+    if (destroyed) return;
     clearScheduledFlush();
-    const body = {
-      session: buildSessionPayload(),
-      events
-    };
-    const serialized = JSON.stringify(body);
-    await postWithFetch(eventsUrl, serialized, config.apiKey, identityHeaders2, false);
+    bufferQueued();
+    if (pending.length === 0) return;
+    try {
+      while (pending.length > 0) {
+        const batch = pending[0];
+        const body = { session: batch.session, events: batch.events };
+        const outcome = await postWithFetch(
+          eventsUrl,
+          JSON.stringify(body),
+          config.apiKey,
+          identityHeaders2,
+          false
+        );
+        if (outcome === "retry") {
+          retryAttempt += 1;
+          return;
+        }
+        pending = pending.slice(1);
+        writePendingBatches(bufferKey, pending);
+        retryAttempt = 0;
+      }
+    } finally {
+      if (pending.length > 0) {
+        const backoff = Math.min(flushIntervalMs * 2 ** retryAttempt, MAX_RETRY_BACKOFF_MS);
+        scheduleFlush(backoff);
+      } else if (queue.length > 0) {
+        scheduleFlush();
+      }
+    }
   }
   function trackEvent(input) {
     if (destroyed) return;
@@ -1985,16 +2068,14 @@ function createTrackingClient(config) {
     }
   }
   function flushOnUnload() {
-    if (queue.length === 0) return;
-    const events = queue.slice(0, HARD_MAX_BATCH);
-    queue = queue.slice(events.length);
+    bufferQueued();
     clearScheduledFlush();
-    const body = {
-      session: buildSessionPayload(),
-      events
-    };
-    const serialized = JSON.stringify(body);
-    void postWithFetch(eventsUrl, serialized, config.apiKey, identityHeaders2, true);
+    if (pending.length === 0) return;
+    const batch = pending[0];
+    pending = pending.slice(1);
+    writePendingBatches(bufferKey, pending);
+    const body = { session: batch.session, events: batch.events };
+    void postWithFetch(eventsUrl, JSON.stringify(body), config.apiKey, identityHeaders2, true);
   }
   if (typeof window !== "undefined") {
     window.addEventListener("pagehide", flushOnUnload);
@@ -3169,7 +3250,12 @@ var saleCreateSchema = import_zod12.z.object({
   customer_email: customerEmailSchema.nullable().optional(),
   // CASL consent attestation: the customer agreed to receive SMS. Recorded
   // with a timestamp server-side; every SMS send path gates on it.
-  sms_consent: import_zod12.z.boolean().default(false)
+  //
+  // Tri-state: omit it (or send null) to let the server apply the business's
+  // configured default-opt-in policy, honouring a returning customer's
+  // remembered preference. Send an explicit boolean to assert consent state
+  // yourself — `false` records a deliberate opt-out.
+  sms_consent: import_zod12.z.boolean().nullable().optional()
 }).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
 var saleUpdateSchema = import_zod12.z.object({
   description: import_zod12.z.string().nullable().optional(),
@@ -3181,6 +3267,9 @@ var saleUpdateSchema = import_zod12.z.object({
   items: import_zod12.z.array(saleItemSchema).optional(),
   metadata: metadataSchema.nullable().optional(),
   customer_name: customerNameSchema.nullable().optional(),
+  // Re-attest when changing a filler-looking name; the server clears the
+  // prior attestation whenever `customer_name` changes.
+  customer_name_placeholder_confirmed: import_zod12.z.boolean().optional(),
   customer_phone: customerPhoneSchema.nullable().optional(),
   customer_email: customerEmailSchema.nullable().optional(),
   // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
@@ -3555,7 +3644,7 @@ function GoogleAdsTracking(props) {
 var import_navigation3 = require("next/navigation");
 
 // package.json
-var version = "0.22.0";
+var version = "0.22.3";
 
 // src/factory.tsx
 var import_react5 = require("react");