@stamprally/core 0.15.0 → 0.16.0

package/dist/index.js

@@ -1135,6 +1135,18 @@ var StampRallyClient = class {
   get pendingCount() {
     return this.#offlineQueue?.pendingCount ?? 0;
   }
+  get rejectedHistory() {
+    return this.#offlineQueue?.rejectedHistory ?? [];
+  }
+  get queueCapability() {
+    return this.#offlineQueue?.queueCapability ?? "custom";
+  }
+  discardRejected(operationId) {
+    return this.#offlineQueue?.discardRejected(operationId) ?? Promise.resolve(false);
+  }
+  retryRejected(operationId) {
+    return this.#offlineQueue?.retryRejected(operationId) ?? Promise.resolve(false);
+  }
   subscribe(listener) {
     this.#listeners.add(listener);
     return () => this.#listeners.delete(listener);
@@ -1457,12 +1469,19 @@ var StampRallyClient = class {
 // src/client/offlineQueue.ts
 var MemoryQueueStorage = class {
   #values = /* @__PURE__ */ new Map();
+  #rejected = /* @__PURE__ */ new Map();
   async load(key) {
     return this.#values.get(key) ?? [];
   }
   async save(key, operations) {
     this.#values.set(key, structuredClone(operations));
   }
+  async loadRejectedHistory(key) {
+    return this.#rejected.get(key) ?? [];
+  }
+  async saveRejectedHistory(key, history) {
+    this.#rejected.set(key, structuredClone(history));
+  }
 };
 var LocalStorageQueueStorage = class {
   constructor(storage) {
@@ -1482,6 +1501,19 @@ var LocalStorageQueueStorage = class {
   async save(key, operations) {
     this.storage.setItem(key, JSON.stringify(operations));
   }
+  async loadRejectedHistory(key) {
+    const value = this.storage.getItem(`${key}:rejected-history`);
+    if (value === null) return [];
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async saveRejectedHistory(key, history) {
+    this.storage.setItem(`${key}:rejected-history`, JSON.stringify(history));
+  }
 };
 var IndexedDBOfflineQueueStorage = class {
   #providedFactory;
@@ -1509,6 +1541,26 @@ var IndexedDBOfflineQueueStorage = class {
       transaction.onabort = () => reject(transaction.error ?? new Error("Offline queue write aborted."));
     });
   }
+  async loadRejectedHistory(key) {
+    const database = await this.#open();
+    return new Promise((resolve, reject) => {
+      const request = database.transaction("operations", "readonly").objectStore("operations").get(`${key}:rejected-history`);
+      request.onsuccess = () => resolve(
+        Array.isArray(request.result) ? request.result : []
+      );
+      request.onerror = () => reject(request.error ?? new Error("Failed to read rejected operation history."));
+    });
+  }
+  async saveRejectedHistory(key, history) {
+    const database = await this.#open();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction("operations", "readwrite");
+      transaction.objectStore("operations").put(structuredClone(history), `${key}:rejected-history`);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error ?? new Error("Failed to save rejected operation history."));
+      transaction.onabort = () => reject(transaction.error ?? new Error("Rejected operation history write aborted."));
+    });
+  }
   #open() {
     if (this.#databasePromise !== null) return this.#databasePromise;
     let factory = this.#providedFactory;
@@ -1531,22 +1583,35 @@ var IndexedDBOfflineQueueStorage = class {
     return this.#databasePromise;
   }
 };
+function availableLocalStorage() {
+  try {
+    const storage = globalThis.localStorage;
+    return storage ?? null;
+  } catch {
+    return null;
+  }
+}
 function defaultStorage(databaseName) {
   try {
     const indexedDB = globalThis.indexedDB;
     if (indexedDB !== void 0)
-      return new IndexedDBOfflineQueueStorage({
-        indexedDB,
-        ...databaseName === void 0 ? {} : { databaseName }
-      });
-    const storage = globalThis.localStorage;
-    if (storage !== void 0 && storage !== null) return new LocalStorageQueueStorage(storage);
+      return {
+        storage: new IndexedDBOfflineQueueStorage({
+          indexedDB,
+          ...databaseName === void 0 ? {} : { databaseName }
+        }),
+        capability: "indexeddb"
+      };
+    const storage = availableLocalStorage();
+    if (storage !== void 0 && storage !== null)
+      return { storage: new LocalStorageQueueStorage(storage), capability: "localstorage" };
   } catch {
   }
-  return new MemoryQueueStorage();
+  return { storage: new MemoryQueueStorage(), capability: "memory" };
 }
-function operationId(operation) {
-  return operation.kind === "checkIn" ? `checkIn:${operation.request.rallyId}:${operation.request.userId ?? "anonymous"}:${operation.request.idempotencyKey}` : `claimReward:${operation.request.rallyId}:${operation.request.userId ?? "anonymous"}:${operation.request.idempotencyKey}`;
+function offlineOperationId(operation) {
+  const identity = operation.request.userId ?? operation.request.anonymousSessionId ?? "anonymous";
+  return operation.kind === "checkIn" ? `checkIn:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}` : `claimReward:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}`;
 }
 function requestScope(operation) {
   return {
@@ -1576,12 +1641,14 @@ function randomId() {
 }
 var OfflineQueue = class {
   #storage;
+  #queueCapability;
   #configuredKey;
   #rallyId;
   #userId;
   #conflictPolicy;
   #onSyncConflict;
   #operations = [];
+  #rejectedHistory = [];
   #loaded = false;
   #state = "idle";
   #error = null;
@@ -1592,13 +1659,22 @@ var OfflineQueue = class {
   #retryOptions;
   #instanceId = randomId();
   #lockStorage;
+  #observedLocks = /* @__PURE__ */ new Map();
+  #warnedMemoryLock = false;
   #storageListener;
   #channel = null;
   constructor(options = {}) {
-    if (options.storage !== void 0) this.#storage = options.storage;
-    else if (options.storageLike !== void 0 && options.storageLike !== null)
+    if (options.storage !== void 0) {
+      this.#storage = options.storage;
+      this.#queueCapability = "custom";
+    } else if (options.storageLike !== void 0 && options.storageLike !== null) {
       this.#storage = new LocalStorageQueueStorage(options.storageLike);
-    else this.#storage = defaultStorage(options.databaseName);
+      this.#queueCapability = "localstorage";
+    } else {
+      const selected = defaultStorage(options.databaseName);
+      this.#storage = selected.storage;
+      this.#queueCapability = selected.capability;
+    }
     this.#configuredKey = options.key;
     this.#rallyId = options.rallyId;
     this.#userId = options.userId ?? null;
@@ -1614,7 +1690,7 @@ var OfflineQueue = class {
       initialIntervalMs: Math.max(0, retryOptions.initialIntervalMs),
       backoffMultiplier: Math.max(1, retryOptions.backoffMultiplier)
     };
-    this.#lockStorage = options.storageLike ?? globalThis.localStorage ?? null;
+    this.#lockStorage = options.storageLike ?? availableLocalStorage();
     if (this.#synchronizeInstances) this.#subscribeToExternalChanges();
   }
   get syncState() {
@@ -1623,6 +1699,12 @@ var OfflineQueue = class {
   get pendingCount() {
     return this.#operations.length;
   }
+  get queueCapability() {
+    return this.#queueCapability;
+  }
+  get rejectedHistory() {
+    return this.#rejectedHistory;
+  }
   get error() {
     return this.#error;
   }
@@ -1646,7 +1728,20 @@ var OfflineQueue = class {
   }
   async initialize() {
     if (this.#loaded) return;
-    this.#operations = (await this.#storage.load(this.#storageKey())).map(normalizeOperation);
+    try {
+      const key = this.#storageKey();
+      this.#operations = (await this.#storage.load(key)).map(normalizeOperation);
+      this.#rejectedHistory = (await this.#storage.loadRejectedHistory?.(key))?.map(normalizeRejectedHistory) ?? [];
+    } catch (error) {
+      if (this.#queueCapability === "memory") throw error;
+      this.#storage = new MemoryQueueStorage();
+      this.#queueCapability = "memory";
+      this.#operations = [];
+      this.#rejectedHistory = [];
+      this.#warnMemoryLock(
+        `Offline queue persistence is unavailable; queued data can be lost after reload (${String(error)}).`
+      );
+    }
     this.#loaded = true;
   }
   /** Releases browser listeners when the queue is no longer used. */
@@ -1689,8 +1784,8 @@ var OfflineQueue = class {
         throw new Error("Offline operation belongs to another rally or user queue.");
     }
     await this.initialize();
-    const id2 = operationId(operation);
-    if (this.#operations.some((item) => operationId(item) === id2)) return;
+    const id2 = offlineOperationId(operation);
+    if (this.#operations.some((item) => offlineOperationId(item) === id2)) return;
     this.#operations = [...this.#operations, { ...operation, status: "PENDING", attempts: 0 }];
     await this.#storage.save(this.#storageKey(), this.#operations);
     this.#announceChange();
@@ -1707,6 +1802,47 @@ var OfflineQueue = class {
     await this.#storage.save(this.#storageKey(), this.#operations);
     this.#announceChange();
   }
+  async discardRejected(operationId) {
+    await this.initialize();
+    const next = this.#rejectedHistory.filter(
+      (entry) => offlineOperationId(entry.operation) !== operationId
+    );
+    if (next.length === this.#rejectedHistory.length) return false;
+    this.#rejectedHistory = next;
+    await this.#saveRejectedHistory();
+    this.#announceChange();
+    return true;
+  }
+  async retryRejected(operationId) {
+    await this.initialize();
+    const entry = this.#rejectedHistory.find(
+      (candidate) => offlineOperationId(candidate.operation) === operationId
+    );
+    if (entry === void 0) return false;
+    if (!this.#operations.some((operation) => offlineOperationId(operation) === operationId))
+      this.#operations = [
+        ...this.#operations,
+        { ...entry.operation, status: "PENDING", attempts: 0 }
+      ];
+    this.#rejectedHistory = this.#rejectedHistory.filter((candidate) => candidate !== entry);
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    await this.#saveRejectedHistory();
+    this.#announceChange();
+    return true;
+  }
+  async discardRejectedOperation(operationId) {
+    return this.discardRejected(operationId);
+  }
+  async retryRejectedOperation(operationId) {
+    return this.retryRejected(operationId);
+  }
+  async clearRejectedHistory() {
+    await this.initialize();
+    if (this.#rejectedHistory.length === 0) return;
+    this.#rejectedHistory = [];
+    await this.#saveRejectedHistory();
+    this.#announceChange();
+  }
   async sync(sender = this.#sender) {
     await this.initialize();
     if (sender === void 0) throw new Error("OfflineQueue.sync requires a sender.");
@@ -1722,7 +1858,7 @@ var OfflineQueue = class {
   }
   async #run(sender) {
     const locks = globalThis.navigator?.locks;
-    if (locks !== void 0) {
+    if (locks !== void 0 && typeof locks.request === "function") {
       let callbackStarted = false;
       try {
         const acquired = await locks.request(
@@ -1745,6 +1881,10 @@ var OfflineQueue = class {
         if (callbackStarted) throw error;
       }
     }
+    if (this.#lockStorage === null)
+      this.#warnMemoryLock(
+        "No cross-tab storage lock is available; offline sync is single-tab only."
+      );
     await this.#runWithStorageLock(sender);
   }
   async #runWithStorageLock(sender) {
@@ -1775,20 +1915,38 @@ var OfflineQueue = class {
           const error2 = errorValue(response.error ?? response.reason, "RETRYABLE_ERROR");
           await this.#updateOperationStatus("PENDING", attempt + 1);
           await this.#syncResultListener?.({ operation, status: response.status, error: error2 });
-          if (attempt >= this.#retryOptions.maxRetries) throw new Error(error2.message);
+          if (attempt >= this.#retryOptions.maxRetries) {
+            await this.#updateOperationStatus("FAILED_RETRYABLE", attempt + 1);
+            throw new Error(error2.message);
+          }
           const interval = this.#retryOptions.initialIntervalMs * this.#retryOptions.backoffMultiplier ** attempt;
           await new Promise((resolve) => setTimeout(resolve, Math.max(0, interval)));
           attempt += 1;
         }
         const result = response.result;
-        const state = response.state ?? (result !== void 0 && "conflict" in result && result.conflict === true ? await this.resolveConflict(operation, result.localState, result.serverState) : result !== void 0 && "ok" in result && result.ok ? result.value.state : void 0);
-        const error = response.status === "REJECTED_PERMANENT" ? errorValue(response.error ?? response.reason, "REJECTED_PERMANENT") : void 0;
+        const state = response.state ?? (result !== void 0 && "conflict" in result && result.conflict === true ? result.serverState : result !== void 0 && "ok" in result && result.ok ? result.value.state : void 0);
+        const error = response.status === "REJECTED_PERMANENT" ? errorValue(
+          response.error ?? response.reason ?? (result !== void 0 && "ok" in result && !result.ok ? result.error : void 0),
+          "REJECTED_PERMANENT"
+        ) : void 0;
         await this.#updateOperationStatus(
-          response.status === "ACCEPTED" ? "ACCEPTED" : "REJECTED",
+          response.status === "ACCEPTED" ? "ACCEPTED" : "REJECTED_PERMANENT",
           attempt + 1
         );
-        const fallbackState = response.status === "REJECTED_PERMANENT" ? operation.request.state : void 0;
-        const eventState = state ?? fallbackState;
+        const eventState = state;
+        if (response.status === "REJECTED_PERMANENT" && error !== void 0) {
+          this.#rejectedHistory = [
+            ...this.#rejectedHistory,
+            {
+              operation: { ...operation, status: "REJECTED_PERMANENT", attempts: attempt + 1 },
+              reason: error,
+              errorCode: error.code,
+              rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              attempts: attempt + 1
+            }
+          ];
+          await this.#saveRejectedHistory();
+        }
         this.#operations = this.#operations.slice(1);
         await this.#storage.save(this.#storageKey(), this.#operations);
         this.#announceChange();
@@ -1820,7 +1978,8 @@ var OfflineQueue = class {
     const windowLike = globalThis.window;
     if (windowLike !== void 0) {
       this.#storageListener = (event) => {
-        if (event.key === this.#storageKey()) void this.#reloadFromStorage();
+        if (event.key === this.#storageKey() || event.key === `${this.#storageKey()}:rejected-history`)
+          void this.#reloadFromStorage();
       };
       windowLike.addEventListener("storage", this.#storageListener);
     }
@@ -1829,6 +1988,20 @@ var OfflineQueue = class {
       try {
         this.#channel = new Channel("stamprally:queue-sync");
         this.#channel.addEventListener("message", (event) => {
+          if (typeof event.data === "object" && event.data !== null) {
+            const data = event.data;
+            if (data.type === "lock" && data.lockKey === this.#lockKey()) {
+              this.#observedLocks.set(data.lockKey, {
+                owner: typeof data.owner === "string" ? data.owner : "unknown",
+                expiresAt: typeof data.expiresAt === "number" ? data.expiresAt : 0
+              });
+              return;
+            }
+            if (data.type === "unlock" && data.lockKey === this.#lockKey()) {
+              this.#observedLocks.delete(data.lockKey);
+              return;
+            }
+          }
           if (typeof event.data === "object" && event.data !== null && "key" in event.data && event.data.key === this.#storageKey())
             void this.#reloadFromStorage();
         });
@@ -1838,12 +2011,18 @@ var OfflineQueue = class {
     }
   }
   #announceChange() {
-    this.#channel?.postMessage({ key: this.#storageKey(), owner: this.#instanceId });
+    this.#channel?.postMessage({
+      type: "change",
+      key: this.#storageKey(),
+      owner: this.#instanceId
+    });
   }
   async #reloadFromStorage() {
     if (this.#state === "syncing") return;
     try {
-      this.#operations = (await this.#storage.load(this.#storageKey())).map(normalizeOperation);
+      const key = this.#storageKey();
+      this.#operations = (await this.#storage.load(key)).map(normalizeOperation);
+      this.#rejectedHistory = (await this.#storage.loadRejectedHistory?.(key))?.map(normalizeRejectedHistory) ?? this.#rejectedHistory;
       this.#loaded = true;
     } catch {
     }
@@ -1857,6 +2036,9 @@ var OfflineQueue = class {
     const local = syncLocks.get(key);
     if (local !== void 0 && local.expiresAt > now && local.owner !== this.#instanceId)
       return false;
+    const observed = this.#observedLocks.get(key);
+    if (observed !== void 0 && observed.expiresAt > now && observed.owner !== this.#instanceId)
+      return false;
     if (this.#lockStorage !== null) {
       try {
         const existing = this.#lockStorage.getItem(key);
@@ -1869,7 +2051,14 @@ var OfflineQueue = class {
           key,
           JSON.stringify({ owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS })
         );
+        this.#channel?.postMessage({
+          type: "lock",
+          lockKey: key,
+          owner: this.#instanceId,
+          expiresAt: now + SYNC_LOCK_TTL_MS
+        });
       } catch {
+        this.#warnMemoryLock("Persistent lock access failed; offline sync is single-tab only.");
       }
     }
     syncLocks.set(key, { owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS });
@@ -1884,6 +2073,7 @@ var OfflineQueue = class {
         const value = this.#lockStorage.getItem(key);
         if (value !== null && JSON.parse(value).owner === this.#instanceId)
           this.#lockStorage.removeItem?.(key);
+        this.#channel?.postMessage({ type: "unlock", lockKey: key, owner: this.#instanceId });
       } catch {
       }
     }
@@ -1912,14 +2102,33 @@ var OfflineQueue = class {
     const policy = (typeof configured === "function" ? await configured({ operation, localState, serverState }) : configured) ?? this.#conflictPolicy;
     return resolveRallyStateConflict(serverState, localState, { policy });
   }
+  async #saveRejectedHistory() {
+    await this.#storage.saveRejectedHistory?.(this.#storageKey(), this.#rejectedHistory);
+  }
+  #warnMemoryLock(message) {
+    if (this.#warnedMemoryLock) return;
+    this.#warnedMemoryLock = true;
+    console.warn(`[@stamprally/core] ${message}`);
+  }
 };
 function normalizeOperation(operation) {
+  const status = operation.status;
   return {
     ...operation,
-    status: operation.status === "IN_FLIGHT" ? "PENDING" : operation.status ?? "PENDING",
+    status: status === "IN_FLIGHT" || status === "REJECTED" ? "PENDING" : status === "RETRYABLE_ERROR" ? "FAILED_RETRYABLE" : operation.status ?? "PENDING",
     attempts: operation.attempts ?? 0
   };
 }
+function normalizeRejectedHistory(entry) {
+  return {
+    ...entry,
+    operation: normalizeOperation(entry.operation),
+    reason: errorValue(entry.reason, "REJECTED_PERMANENT"),
+    errorCode: entry.errorCode || entry.reason.code,
+    rejectedAt: entry.rejectedAt || (/* @__PURE__ */ new Date(0)).toISOString(),
+    attempts: entry.attempts ?? entry.operation.attempts ?? 0
+  };
+}
 
 // src/crypto/token.ts
 var encoder = new TextEncoder();
@@ -2900,6 +3109,6 @@ async function verifySnapshotToken(token, secretKey, now = Date.now()) {
   }
 }
 
-export { ConfigValidationError, DEFAULT_SHEET_THEME, MemoryQueueStorage as InMemoryOfflineQueueStorage, InMemoryStorage, IndexedDBAdapter, IndexedDBOfflineQueueStorage, LocalStorageAdapter, OfflineQueue, StampRallyClient, StorageAdapterError, THEME_PRESETS, assertPublicConfig, calculateDistanceMeters, calculateProgress, consumeReward, createAnonymousSessionId, createClaimTicketNumber, createSecureToken, createSignedSnapshotToken, createUniqueClaimTicketNumber, evaluateCondition, evaluateConditionDetailed, evaluateSpotStatus, exportProgressToken, getCurrentGeoContext, getOrderedSpots, getSpotStatus, importProgressToken, isGeolocationSupported, isNfcSupported, isPublicConfig, isQrSupported, isRewardState, isStampRallyState, issueClaimTicketNumber, normalizePasscode, parseAdminConfig, parsePublicConfig, processStamp, readNfcContext, readQrContext, reconcileRewardStates, resolveLocalizedText, resolveRallyStateConflict, safeParseAdminConfig, safeParsePublicConfig, sanitizeAdminConfig, storageKey, toLocalizedString, toPublicConfig, updateLocalizedField, validatePublicConfigSafety, validateRallyConfigRelations, verifyPasscode, verifySecureToken, verifySnapshotToken };
+export { ConfigValidationError, DEFAULT_SHEET_THEME, MemoryQueueStorage as InMemoryOfflineQueueStorage, InMemoryStorage, IndexedDBAdapter, IndexedDBOfflineQueueStorage, LocalStorageAdapter, OfflineQueue, StampRallyClient, StorageAdapterError, THEME_PRESETS, assertPublicConfig, calculateDistanceMeters, calculateProgress, consumeReward, createAnonymousSessionId, createClaimTicketNumber, createSecureToken, createSignedSnapshotToken, createUniqueClaimTicketNumber, evaluateCondition, evaluateConditionDetailed, evaluateSpotStatus, exportProgressToken, getCurrentGeoContext, getOrderedSpots, getSpotStatus, importProgressToken, isGeolocationSupported, isNfcSupported, isPublicConfig, isQrSupported, isRewardState, isStampRallyState, issueClaimTicketNumber, normalizePasscode, offlineOperationId, parseAdminConfig, parsePublicConfig, processStamp, readNfcContext, readQrContext, reconcileRewardStates, resolveLocalizedText, resolveRallyStateConflict, safeParseAdminConfig, safeParsePublicConfig, sanitizeAdminConfig, storageKey, toLocalizedString, toPublicConfig, updateLocalizedField, validatePublicConfigSafety, validateRallyConfigRelations, verifyPasscode, verifySecureToken, verifySnapshotToken };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map