@stamprally/react 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -1,591 +1,70 @@
 'use strict';
 
-var core = require('@stamprally/core');
 var react = require('react');
 
 // src/useStampRally.ts
-function getServerSnapshot() {
+function serverSnapshot() {
   return null;
 }
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function applyOptimisticAcquire(currentState, action) {
-  if (currentState === null || currentState.records.some((record) => record.stampId === action.stampId)) {
-    return currentState;
-  }
-  return {
-    ...currentState,
-    records: [...currentState.records, { stampId: action.stampId, acquiredAt: action.acquiredAt }],
-    updatedAt: action.acquiredAt
-  };
-}
-function createIdempotencyKey() {
-  const cryptoApi = globalThis.crypto;
-  if (cryptoApi !== void 0 && typeof cryptoApi.randomUUID === "function") {
-    return cryptoApi.randomUUID();
-  }
-  return `stamp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-}
-function isOnline(adapter) {
-  if (adapter?.isOnline === void 0) {
-    return typeof navigator === "undefined" || navigator.onLine !== false;
-  }
-  return typeof adapter.isOnline === "function" ? adapter.isOnline() : adapter.isOnline;
-}
-function isRejectedVerification(value) {
-  return value === false || typeof value === "object" && value !== null && "ok" in value && value.ok === false;
-}
-function isNetworkFailure(error) {
-  if (typeof navigator !== "undefined" && navigator.onLine === false) return true;
-  if (!(error instanceof Error)) return true;
-  return /aborted|connection|fetch|network|offline|timeout/i.test(`${error.name} ${error.message}`);
-}
-function notifyAcquisitionEvents(result, events, onStampClaimed, onRewardUnlocked) {
-  for (const event of result.events) {
-    if (event.type === "stampAcquired") {
-      (events?.onStampClaimed ?? onStampClaimed)?.(event.record);
-    }
-    if (event.type === "rewardUnlocked") {
-      (events?.onRewardUnlocked ?? onRewardUnlocked)?.(event.rewardId);
-    }
-  }
+function errorFrom(value) {
+  return value instanceof Error ? value : new Error(String(value));
 }
 function useStampRally(client, options = {}) {
-  const syncAdapter = options.syncAdapter;
-  const events = options.events;
-  const [offlineQueue, setOfflineQueue] = react.useState([]);
-  const queuedMetadata = react.useRef(/* @__PURE__ */ new Map());
-  const isFlushingQueue = react.useRef(false);
-  const activeClient = react.useRef(client);
-  const subscribe = react.useCallback(
-    (onStoreChange) => client.subscribe(() => onStoreChange()),
-    [client]
-  );
+  const subscribe = react.useCallback((listener) => client.subscribe(listener), [client]);
   const getSnapshot = react.useCallback(() => client.getState(), [client]);
-  const rawState = react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-  const [clientStatus, setClientStatus] = react.useState(() => ({
-    client,
-    isInitializing: client.getState() === null
-  }));
-  const [clientError, setClientError] = react.useState(null);
-  const [isPending] = react.useTransition();
-  const [isOperationPending, setIsOperationPending] = react.useState(false);
-  const [optimisticState, setOptimisticState] = react.useState(rawState);
-  react.useEffect(() => {
-    setOptimisticState(rawState);
-  }, [rawState]);
-  react.useEffect(() => {
-    if (activeClient.current === client) return;
-    activeClient.current = client;
-    setOfflineQueue([]);
-    queuedMetadata.current.clear();
-  }, [client]);
-  react.useEffect(() => {
-    if (syncAdapter?.onStateChange === void 0) return;
-    return client.subscribe(syncAdapter.onStateChange);
-  }, [client, syncAdapter]);
+  const state = react.useSyncExternalStore(subscribe, getSnapshot, serverSnapshot);
+  const [error, setError] = react.useState(null);
   react.useEffect(() => {
+    if (options.initialize === false || client.getState() !== null) return;
     let active = true;
-    setClientError(null);
-    if (rawState !== null) {
-      setClientStatus({ client, isInitializing: false });
-      return () => {
-        active = false;
-      };
-    }
-    setClientStatus({ client, isInitializing: true });
-    void client.init().catch((initializationError) => {
-      if (active) {
-        setClientError({ client, value: toError(initializationError) });
-      }
-    }).finally(() => {
-      if (active) {
-        setClientStatus({ client, isInitializing: false });
-      }
+    void client.init().catch((reason) => {
+      if (active) setError(errorFrom(reason));
     });
     return () => {
       active = false;
     };
-  }, [client, rawState]);
-  const queueRequest = react.useCallback(
-    (request, metadata) => {
-      if (metadata !== void 0) queuedMetadata.current.set(request.idempotencyKey, metadata);
-      setOfflineQueue(
-        (current) => current.some((item) => item.idempotencyKey === request.idempotencyKey) ? current : [...current, request]
-      );
-    },
-    []
-  );
-  const acquire = react.useCallback(
-    (stampId, context, now, idempotencyKey) => {
-      const acquiredAt = now ?? (/* @__PURE__ */ new Date()).toISOString();
-      const request = {
-        stampId,
-        context,
-        now: acquiredAt,
-        idempotencyKey: idempotencyKey ?? createIdempotencyKey()
-      };
-      setClientError(null);
-      if (!isOnline(syncAdapter)) {
-        queueRequest(request);
-        const queued = {
-          ok: false,
-          error: { code: "OFFLINE_QUEUED", stampId, idempotencyKey: request.idempotencyKey }
-        };
-        setClientError({ client, value: queued.error });
-        return Promise.resolve(queued);
-      }
-      setIsOperationPending(true);
-      setOptimisticState((current) => applyOptimisticAcquire(current, { stampId, acquiredAt }));
-      return new Promise((resolve, reject) => {
-        void (async () => {
-          try {
-            const before = await syncAdapter?.onBeforeCheckIn?.(request);
-            if (before === false) {
-              const rejected = {
-                ok: false,
-                error: { code: "INVALID_PROOF", stampId }
-              };
-              setClientError({ client, value: rejected.error });
-              setIsOperationPending(false);
-              resolve(rejected);
-              return;
-            }
-            const previousState = client.getState();
-            const result = await client.acquire(stampId, context, acquiredAt);
-            if (result.ok) {
-              let verified;
-              try {
-                verified = await syncAdapter?.onServerVerify?.(request);
-              } catch (verificationError) {
-                if (!isNetworkFailure(verificationError)) throw verificationError;
-                queueRequest(request, { previousState, result: result.value });
-                const queued = {
-                  ok: false,
-                  error: {
-                    code: "OFFLINE_QUEUED",
-                    stampId,
-                    idempotencyKey: request.idempotencyKey
-                  }
-                };
-                setClientError({ client, value: toError(verificationError) });
-                setOptimisticState(client.getState());
-                setIsOperationPending(false);
-                resolve(queued);
-                return;
-              }
-              if (isRejectedVerification(verified)) {
-                await client.restore(rawState ?? client.getState() ?? result.value.nextState);
-                const rejected = {
-                  ok: false,
-                  error: { code: "INVALID_PROOF", stampId }
-                };
-                setClientError({ client, value: rejected.error });
-                setOptimisticState(client.getState());
-                setIsOperationPending(false);
-                resolve(rejected);
-                return;
-              }
-              notifyAcquisitionEvents(
-                result.value,
-                events,
-                options.onStampClaimed,
-                options.onRewardUnlocked
-              );
-            }
-            if (!result.ok) {
-              setClientError({ client, value: result.error });
-              setOptimisticState(client.getState());
-            }
-            setIsOperationPending(false);
-            resolve(result);
-          } catch (acquireError) {
-            if (isNetworkFailure(acquireError)) {
-              queueRequest(request);
-              const queued = {
-                ok: false,
-                error: { code: "OFFLINE_QUEUED", stampId, idempotencyKey: request.idempotencyKey }
-              };
-              setClientError({ client, value: queued.error });
-              setOptimisticState(client.getState());
-              setIsOperationPending(false);
-              resolve(queued);
-              return;
-            }
-            const normalizedError = toError(acquireError);
-            setClientError({ client, value: normalizedError });
-            setOptimisticState(client.getState());
-            setIsOperationPending(false);
-            reject(normalizedError);
-          }
-        })();
-      });
-    },
-    [
-      client,
-      events,
-      options.onRewardUnlocked,
-      options.onStampClaimed,
-      queueRequest,
-      rawState,
-      syncAdapter
-    ]
-  );
-  const reset = react.useCallback(
-    (now) => {
-      setClientError(null);
-      setIsOperationPending(true);
-      return new Promise((resolve, reject) => {
-        void (async () => {
-          try {
-            const nextState = now === void 0 ? await client.reset() : await client.reset(now);
-            setIsOperationPending(false);
-            resolve(nextState);
-          } catch (resetError) {
-            const normalizedError = toError(resetError);
-            setClientError({ client, value: normalizedError });
-            setIsOperationPending(false);
-            reject(normalizedError);
-          }
-        })();
+  }, [client, options.initialize]);
+  const onCheckIn = react.useCallback(
+    (spotId, proof, checkInOptions = {}) => {
+      setError(null);
+      return client.checkIn(spotId, proof, checkInOptions).then((result) => {
+        if (!result.ok) setError(errorFrom(result.error));
+        return result;
       });
     },
     [client]
   );
-  const redeem = react.useCallback(
-    (rewardId, redeemOptions = {}) => {
-      setClientError(null);
-      setIsOperationPending(true);
-      return new Promise((resolve, reject) => {
-        void (async () => {
-          const reward = client.getConfig().rewards?.find((item) => item.id === rewardId);
-          if (reward === void 0) {
-            const result2 = {
-              ok: false,
-              error: { code: "REWARD_NOT_FOUND", rewardId }
-            };
-            setClientError({ client, value: result2.error });
-            setIsOperationPending(false);
-            resolve(result2);
-            return;
-          }
-          const currentState = client.getState();
-          const currentRewardState = currentState?.rewards?.find(
-            (state) => state.rewardId === rewardId
-          );
-          if (currentState === null || currentRewardState === void 0) {
-            const result2 = {
-              ok: false,
-              error: { code: "NOT_AVAILABLE", rewardId }
-            };
-            setClientError({ client, value: result2.error });
-            setIsOperationPending(false);
-            resolve(result2);
-            return;
-          }
-          const result = core.consumeReward({
-            reward,
-            currentState: currentRewardState,
-            now: (/* @__PURE__ */ new Date()).toISOString(),
-            ...redeemOptions.passcode === void 0 ? {} : { inputPasscode: redeemOptions.passcode },
-            ...redeemOptions.staffId === void 0 ? {} : { staffId: redeemOptions.staffId }
-          });
-          if (!result.ok) {
-            setClientError({ client, value: result.error });
-            setIsOperationPending(false);
-            resolve(result);
-            return;
-          }
-          if (result.value === currentRewardState) {
-            setIsOperationPending(false);
-            resolve(result);
-            return;
-          }
-          const nextState = {
-            ...currentState,
-            rewards: (currentState.rewards ?? []).map(
-              (state) => state.rewardId === rewardId ? result.value : state
-            ),
-            updatedAt: result.value.consumedAt ?? currentState.updatedAt
-          };
-          try {
-            await client.restore(nextState);
-            (events?.onRewardConsumed ?? options.onRewardConsumed)?.(rewardId);
-            setIsOperationPending(false);
-            resolve(result);
-          } catch (redeemError) {
-            const normalizedError = toError(redeemError);
-            setClientError({ client, value: normalizedError });
-            setIsOperationPending(false);
-            reject(normalizedError);
-          }
-        })();
+  const onClaimReward = react.useCallback(
+    (rewardId, claimOptions = {}) => {
+      setError(null);
+      return client.claimReward(rewardId, claimOptions).then((result) => {
+        if (!result.ok) setError(errorFrom(result.error));
+        return result;
       });
     },
-    [client, events, options.onRewardConsumed]
+    [client]
   );
-  const exportRecoveryCode = react.useCallback(() => {
-    const state = client.getState();
-    if (state === null) {
-      throw new Error("Cannot export recovery code before the rally is initialized.");
-    }
-    return core.exportProgressToken({
-      version: 1,
-      rallyId: state.rallyId,
-      stamps: state.records,
-      rewards: state.rewards ?? [],
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+  const onSync = react.useCallback(() => {
+    setError(null);
+    return client.sync().catch((reason) => {
+      const next = errorFrom(reason);
+      setError(next);
+      throw next;
     });
   }, [client]);
-  const importRecoveryCode = react.useCallback(
-    (token) => {
-      setClientError(null);
-      setIsOperationPending(true);
-      return new Promise((resolve, reject) => {
-        void (async () => {
-          const config = client.getConfig();
-          const snapshot = core.importProgressToken(token, config.id);
-          if (snapshot === null) {
-            setIsOperationPending(false);
-            resolve(false);
-            return;
-          }
-          const stampIds = new Set(config.stamps.map((stamp) => stamp.id));
-          const rewardIds = new Set((config.rewards ?? []).map((reward) => reward.id));
-          const importedStampIds = /* @__PURE__ */ new Set();
-          const importedRewardIds = /* @__PURE__ */ new Set();
-          const stamps = snapshot.stamps.filter((record) => {
-            if (!stampIds.has(record.stampId) || importedStampIds.has(record.stampId)) return false;
-            importedStampIds.add(record.stampId);
-            return true;
-          });
-          const rewards = snapshot.rewards.filter((state) => {
-            if (!rewardIds.has(state.rewardId) || importedRewardIds.has(state.rewardId))
-              return false;
-            importedRewardIds.add(state.rewardId);
-            return true;
-          });
-          try {
-            await client.restore({
-              rallyId: config.id,
-              records: stamps,
-              ...config.rewards === void 0 && rewards.length === 0 ? {} : { rewards },
-              updatedAt: snapshot.exportedAt
-            });
-            setIsOperationPending(false);
-            resolve(true);
-          } catch (importError) {
-            const normalizedError = toError(importError);
-            setClientError({ client, value: normalizedError });
-            setIsOperationPending(false);
-            reject(normalizedError);
-          }
-        })();
-      });
-    },
-    [client]
-  );
-  const exportRecoveryToken = react.useCallback(
-    async (secretKey, tokenOptions = {}) => {
-      const state = client.getState();
-      if (state === null)
-        throw new Error("Cannot export recovery token before the rally is initialized.");
-      return core.createSecureToken(
-        {
-          type: "recovery",
-          rallyId: state.rallyId,
-          state,
-          exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        secretKey,
-        { encrypt: tokenOptions.encrypt ?? true, ...tokenOptions }
-      );
-    },
-    [client]
-  );
-  const importRecoveryToken = react.useCallback(
-    async (token, secretKey) => {
-      setClientError(null);
-      setIsOperationPending(true);
-      try {
-        const verified = await core.verifySecureToken(token, secretKey);
-        if (!verified.ok || verified.payload.type !== "recovery" || verified.payload.rallyId !== client.getConfig().id) {
-          setIsOperationPending(false);
-          return false;
-        }
-        const candidate = verified.payload.state;
-        if (!core.isStampRallyState(candidate)) {
-          setIsOperationPending(false);
-          return false;
-        }
-        await client.restore(candidate);
-        setIsOperationPending(false);
-        return true;
-      } catch (error2) {
-        setClientError({ client, value: toError(error2) });
-        setIsOperationPending(false);
-        return false;
-      }
-    },
-    [client]
-  );
-  const syncWithServer = react.useCallback(
-    async (serverEndpoint, authHeader) => {
-      if (typeof fetch !== "function")
-        throw new Error("Fetch API is unavailable in this environment.");
-      setClientError(null);
-      setIsOperationPending(true);
-      try {
-        const endpoint = serverEndpoint.replace(/\/$/u, "").endsWith("/sync") ? serverEndpoint : `${serverEndpoint.replace(/\/$/u, "")}/api/sync`;
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            ...authHeader === void 0 ? {} : { authorization: authHeader }
-          },
-          body: JSON.stringify({
-            userId: options.serverUserId ?? "anonymous",
-            queue: offlineQueue.map((request) => ({
-              ...request,
-              userId: options.serverUserId ?? "anonymous",
-              spotId: request.stampId,
-              claimMethod: request.context.type,
-              proofData: request.context.type === "token" ? { token: request.context.token } : request.context.type === "geo" ? {
-                latitude: request.context.currentLatitude,
-                longitude: request.context.currentLongitude
-              } : void 0
-            }))
-          })
-        });
-        const payload = await response.json();
-        if (!response.ok || !isObject(payload) || payload.ok !== true || !core.isStampRallyState(payload.state)) {
-          throw new Error("Server synchronization was rejected.");
-        }
-        await client.restore(payload.state);
-        queuedMetadata.current.clear();
-        setOfflineQueue([]);
-        client.notifySyncCompleted(payload.state);
-      } catch (error2) {
-        setClientError({ client, value: toError(error2) });
-        throw error2;
-      } finally {
-        setIsOperationPending(false);
-      }
-    },
-    [client, offlineQueue, options.serverUserId]
-  );
-  const isLoading = rawState === null && (clientStatus.client !== client || clientStatus.isInitializing);
-  const error = clientError?.client === client ? clientError.value : null;
-  const flushQueue = react.useCallback(async () => {
-    if (!isOnline(syncAdapter) || isFlushingQueue.current) return;
-    isFlushingQueue.current = true;
-    setIsOperationPending(true);
-    try {
-      for (const request of offlineQueue) {
-        if (!isOnline(syncAdapter)) break;
-        const metadata = queuedMetadata.current.get(request.idempotencyKey);
-        const previousState = metadata?.previousState ?? client.getState();
-        try {
-          const before = await syncAdapter?.onBeforeCheckIn?.(request);
-          if (before === false) {
-            if (metadata !== void 0 && previousState !== null)
-              await client.restore(previousState);
-            setClientError({ client, value: { code: "INVALID_PROOF", stampId: request.stampId } });
-            queuedMetadata.current.delete(request.idempotencyKey);
-            setOfflineQueue(
-              (current) => current.filter((item) => item.idempotencyKey !== request.idempotencyKey)
-            );
-            continue;
-          }
-          let result = metadata?.result;
-          if (result === void 0) {
-            const localResult = await client.acquire(request.stampId, request.context, request.now);
-            if (!localResult.ok) {
-              setClientError({ client, value: localResult.error });
-              queuedMetadata.current.delete(request.idempotencyKey);
-              setOfflineQueue(
-                (current) => current.filter((item) => item.idempotencyKey !== request.idempotencyKey)
-              );
-              continue;
-            }
-            result = localResult.value;
-            queuedMetadata.current.set(request.idempotencyKey, {
-              previousState,
-              result
-            });
-          }
-          const verified = await syncAdapter?.onServerVerify?.(request);
-          if (isRejectedVerification(verified)) {
-            if (previousState !== null) await client.restore(previousState);
-            setClientError({
-              client,
-              value: { code: "INVALID_PROOF", stampId: request.stampId }
-            });
-          } else {
-            notifyAcquisitionEvents(
-              result,
-              events,
-              options.onStampClaimed,
-              options.onRewardUnlocked
-            );
-          }
-          queuedMetadata.current.delete(request.idempotencyKey);
-          setOfflineQueue(
-            (current) => current.filter((item) => item.idempotencyKey !== request.idempotencyKey)
-          );
-        } catch (flushError) {
-          if (isNetworkFailure(flushError)) {
-            setClientError({ client, value: toError(flushError) });
-            break;
-          }
-          setClientError({ client, value: toError(flushError) });
-          queuedMetadata.current.delete(request.idempotencyKey);
-          setOfflineQueue(
-            (current) => current.filter((item) => item.idempotencyKey !== request.idempotencyKey)
-          );
-        }
-      }
-    } finally {
-      isFlushingQueue.current = false;
-      setIsOperationPending(false);
-    }
-  }, [client, events, offlineQueue, options.onRewardUnlocked, options.onStampClaimed, syncAdapter]);
-  react.useEffect(() => {
-    if (typeof window === "undefined") return;
-    const handleOnline = () => {
-      void flushQueue();
-    };
-    window.addEventListener("online", handleOnline);
-    return () => window.removeEventListener("online", handleOnline);
-  }, [flushQueue]);
   return {
-    state: optimisticState,
-    isLoading,
-    isPending: isPending || isOperationPending,
+    state,
+    config: client.getConfig(),
+    isLoading: state === null,
     error,
-    rewardsState: optimisticState?.rewards ?? [],
-    acquire,
-    reset,
-    redeem,
-    exportRecoveryCode,
-    importRecoveryCode,
-    exportRecoveryToken,
-    importRecoveryToken,
-    syncWithServer,
-    offlineQueue,
-    queuedCount: offlineQueue.length,
-    flushQueue
+    onCheckIn,
+    onClaimReward,
+    onSync,
+    switchUser: client.switchUser.bind(client),
+    clearUserState: client.clearUserState.bind(client)
   };
 }
-function usePublicStampRally(config, options) {
-  return { ...useStampRally(options.client, options), config };
-}
 
-exports.usePublicStampRally = usePublicStampRally;
 exports.useStampRally = useStampRally;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map