@pol-studios/powersync 1.0.4 → 1.0.7

package/dist/chunk-YSTEESEG.js

@@ -0,0 +1,676 @@
+// src/provider/context.ts
+import { createContext } from "react";
+var PowerSyncContext = createContext(null);
+PowerSyncContext.displayName = "PowerSyncContext";
+var SyncStatusContext = createContext(null);
+SyncStatusContext.displayName = "SyncStatusContext";
+var ConnectionStatusContext = createContext(null);
+ConnectionStatusContext.displayName = "ConnectionStatusContext";
+var SyncActivityContext = createContext(null);
+SyncActivityContext.displayName = "SyncActivityContext";
+var PendingMutationsContext = createContext(null);
+PendingMutationsContext.displayName = "PendingMutationsContext";
+var FailedTransactionsContext = createContext(null);
+FailedTransactionsContext.displayName = "FailedTransactionsContext";
+var CompletedTransactionsContext = createContext(null);
+CompletedTransactionsContext.displayName = "CompletedTransactionsContext";
+var SyncModeContext = createContext(null);
+SyncModeContext.displayName = "SyncModeContext";
+var ConnectionHealthContext = createContext(null);
+ConnectionHealthContext.displayName = "ConnectionHealthContext";
+var SyncMetricsContext = createContext(null);
+SyncMetricsContext.displayName = "SyncMetricsContext";
+var AttachmentQueueContext = createContext(null);
+AttachmentQueueContext.displayName = "AttachmentQueueContext";
+
+// src/provider/hooks.ts
+import { c as _c } from "react/compiler-runtime";
+import { useContext, useCallback, useMemo, useRef, useState, useEffect } from "react";
+var warnedSyncStatusCallSites = __DEV__ ? /* @__PURE__ */ new Set() : null;
+var SYNCED_DISPLAY_DURATION_MS = 3e3;
+function usePowerSync() {
+  const context = useContext(PowerSyncContext);
+  if (!context) {
+    throw new Error("usePowerSync must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useSyncStatus() {
+  if (__DEV__ && warnedSyncStatusCallSites) {
+    const stack = new Error().stack?.split("\n")[2] ?? "unknown";
+    if (!warnedSyncStatusCallSites.has(stack)) {
+      warnedSyncStatusCallSites.add(stack);
+      console.warn("[useSyncStatus] Deprecated: This hook causes re-renders on any status change. Use focused hooks: useConnectionStatus, useSyncActivityContext, usePendingMutationsContext, etc. See migration guide in JSDoc.");
+    }
+  }
+  const context = useContext(SyncStatusContext);
+  if (!context) {
+    throw new Error("useSyncStatus must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useConnectionStatus() {
+  const context = useContext(ConnectionStatusContext);
+  if (!context) {
+    throw new Error("useConnectionStatus must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useSyncActivityContext() {
+  const context = useContext(SyncActivityContext);
+  if (!context) {
+    throw new Error("useSyncActivityContext must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function usePendingMutationsContext() {
+  const context = useContext(PendingMutationsContext);
+  if (!context) {
+    throw new Error("usePendingMutationsContext must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useFailedTransactionsContext() {
+  const context = useContext(FailedTransactionsContext);
+  if (!context) {
+    throw new Error("useFailedTransactionsContext must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useCompletedTransactionsContext() {
+  const context = useContext(CompletedTransactionsContext);
+  if (!context) {
+    throw new Error("useCompletedTransactionsContext must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useSyncModeContext() {
+  const context = useContext(SyncModeContext);
+  if (!context) {
+    throw new Error("useSyncModeContext must be used within a PowerSyncProvider");
+  }
+  return context;
+}
+function useSyncControl() {
+  const $ = _c(35);
+  const {
+    db,
+    connector,
+    platform
+  } = usePowerSync();
+  const {
+    setSyncMode: setContextSyncMode,
+    setForceNextUpload
+  } = useSyncModeContext();
+  const scopeRef = useRef(null);
+  let t0;
+  if ($[0] !== connector || $[1] !== db || $[2] !== platform || $[3] !== setContextSyncMode) {
+    t0 = async (mode) => {
+      await setContextSyncMode(mode);
+      if (mode === "offline") {
+        if (db?.connected) {
+          platform.logger.info("[useSyncControl] Mode changed to offline - disconnecting");
+          await db.disconnect();
+        }
+      } else {
+        if (db && connector && !db.connected) {
+          platform.logger.info("[useSyncControl] Mode changed to", mode, "- reconnecting");
+          await db.connect(connector);
+        }
+      }
+    };
+    $[0] = connector;
+    $[1] = db;
+    $[2] = platform;
+    $[3] = setContextSyncMode;
+    $[4] = t0;
+  } else {
+    t0 = $[4];
+  }
+  const setSyncMode = t0;
+  let t1;
+  if ($[5] !== connector || $[6] !== db || $[7] !== platform || $[8] !== setForceNextUpload) {
+    t1 = async () => {
+      if (!db || !connector) {
+        platform.logger.warn("[useSyncControl] Cannot sync - database not initialized");
+        return;
+      }
+      setForceNextUpload(true);
+      platform.logger.info("[useSyncControl] Sync Now triggered - forcing full sync");
+      if (db.connected) {
+        await db.disconnect();
+      }
+      await db.connect(connector);
+      platform.logger.info("[useSyncControl] Connected, sync should start automatically");
+    };
+    $[5] = connector;
+    $[6] = db;
+    $[7] = platform;
+    $[8] = setForceNextUpload;
+    $[9] = t1;
+  } else {
+    t1 = $[9];
+  }
+  const syncNow = t1;
+  let t2;
+  if ($[10] !== connector || $[11] !== db || $[12] !== platform || $[13] !== setContextSyncMode) {
+    t2 = async () => {
+      if (!db || !connector) {
+        platform.logger.warn("[useSyncControl] Cannot trigger sync - not initialized");
+        return;
+      }
+      await setContextSyncMode("push-pull");
+      if (db.connected) {
+        platform.logger.info("[useSyncControl] Disconnecting to force fresh sync...");
+        await db.disconnect();
+      }
+      platform.logger.info("[useSyncControl] Connecting...");
+      await db.connect(connector);
+      platform.logger.info("[useSyncControl] Connected, sync should start automatically");
+    };
+    $[10] = connector;
+    $[11] = db;
+    $[12] = platform;
+    $[13] = setContextSyncMode;
+    $[14] = t2;
+  } else {
+    t2 = $[14];
+  }
+  const triggerSync = t2;
+  let t3;
+  if ($[15] !== platform || $[16] !== setSyncMode) {
+    t3 = async () => {
+      await setSyncMode("offline");
+      platform.logger.info("[useSyncControl] Sync paused");
+    };
+    $[15] = platform;
+    $[16] = setSyncMode;
+    $[17] = t3;
+  } else {
+    t3 = $[17];
+  }
+  const pause = t3;
+  let t4;
+  if ($[18] !== platform || $[19] !== setSyncMode) {
+    t4 = async () => {
+      await setSyncMode("push-pull");
+      platform.logger.info("[useSyncControl] Sync resumed");
+    };
+    $[18] = platform;
+    $[19] = setSyncMode;
+    $[20] = t4;
+  } else {
+    t4 = $[20];
+  }
+  const resume = t4;
+  let t5;
+  if ($[21] !== db || $[22] !== platform) {
+    t5 = async () => {
+      if (!db) {
+        platform.logger.warn("[useSyncControl] Cannot disconnect - not initialized");
+        return;
+      }
+      platform.logger.info("[useSyncControl] Disconnecting...");
+      await db.disconnect();
+      platform.logger.info("[useSyncControl] Disconnected");
+    };
+    $[21] = db;
+    $[22] = platform;
+    $[23] = t5;
+  } else {
+    t5 = $[23];
+  }
+  const disconnect = t5;
+  let t6;
+  if ($[24] !== connector || $[25] !== platform) {
+    t6 = (scope) => {
+      scopeRef.current = scope;
+      if (connector && scope) {
+        connector.setActiveProjectIds(scope.ids);
+        platform.logger.info("[useSyncControl] Scope set:", scope);
+      }
+    };
+    $[24] = connector;
+    $[25] = platform;
+    $[26] = t6;
+  } else {
+    t6 = $[26];
+  }
+  const setScope = t6;
+  let t7;
+  if ($[27] !== disconnect || $[28] !== pause || $[29] !== resume || $[30] !== setScope || $[31] !== setSyncMode || $[32] !== syncNow || $[33] !== triggerSync) {
+    t7 = {
+      triggerSync,
+      syncNow,
+      pause,
+      resume,
+      disconnect,
+      setScope,
+      setSyncMode
+    };
+    $[27] = disconnect;
+    $[28] = pause;
+    $[29] = resume;
+    $[30] = setScope;
+    $[31] = setSyncMode;
+    $[32] = syncNow;
+    $[33] = triggerSync;
+    $[34] = t7;
+  } else {
+    t7 = $[34];
+  }
+  return t7;
+}
+function useSyncMode() {
+  const $ = _c(6);
+  const {
+    syncMode,
+    setSyncMode,
+    networkReachable
+  } = useSyncModeContext();
+  const t0 = networkReachable && syncMode === "push-pull";
+  const t1 = syncMode !== "offline";
+  let t2;
+  if ($[0] !== networkReachable || $[1] !== setSyncMode || $[2] !== syncMode || $[3] !== t0 || $[4] !== t1) {
+    t2 = {
+      mode: syncMode,
+      setMode: setSyncMode,
+      canUpload: t0,
+      canDownload: t1,
+      networkReachable
+    };
+    $[0] = networkReachable;
+    $[1] = setSyncMode;
+    $[2] = syncMode;
+    $[3] = t0;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+function useConnectionHealth() {
+  const context = useContext(ConnectionHealthContext);
+  if (!context) {
+    throw new Error("useConnectionHealth must be used within a PowerSyncProvider");
+  }
+  return context.health;
+}
+function useSyncMetrics() {
+  const context = useContext(SyncMetricsContext);
+  if (!context) {
+    throw new Error("useSyncMetrics must be used within a PowerSyncProvider");
+  }
+  return context.metrics;
+}
+function useAttachmentQueue() {
+  return useContext(AttachmentQueueContext);
+}
+function useAttachmentQueueReady() {
+  const {
+    attachmentQueueReady
+  } = usePowerSync();
+  return attachmentQueueReady;
+}
+function useDatabase() {
+  const {
+    db,
+    isReady,
+    error
+  } = usePowerSync();
+  if (error) {
+    throw error;
+  }
+  if (!isReady || !db) {
+    throw new Error("PowerSync database is not ready");
+  }
+  return db;
+}
+function usePlatform() {
+  const {
+    platform
+  } = usePowerSync();
+  return platform;
+}
+function useOnlineStatus() {
+  const $ = _c(4);
+  const {
+    platform
+  } = usePowerSync();
+  const [isOnline, setIsOnline] = useState(true);
+  let t0;
+  if ($[0] !== platform.network) {
+    t0 = () => {
+      platform.network.isConnected().then(setIsOnline);
+      const unsubscribe = platform.network.addConnectionListener(setIsOnline);
+      return unsubscribe;
+    };
+    $[0] = platform.network;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== platform) {
+    t1 = [platform];
+    $[2] = platform;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  useEffect(t0, t1);
+  return isOnline;
+}
+function usePendingMutations() {
+  const $ = _c(3);
+  const {
+    pendingMutations,
+    pendingCount
+  } = usePendingMutationsContext();
+  let t0;
+  if ($[0] !== pendingCount || $[1] !== pendingMutations) {
+    t0 = {
+      mutations: pendingMutations,
+      count: pendingCount
+    };
+    $[0] = pendingCount;
+    $[1] = pendingMutations;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function useIsSyncing() {
+  const {
+    uploading,
+    downloading
+  } = useSyncActivityContext();
+  return uploading || downloading;
+}
+function useDownloadProgress() {
+  const {
+    downloadProgress
+  } = useSyncActivityContext();
+  return downloadProgress;
+}
+function useEntitySyncStatus(entityId) {
+  const {
+    pendingMutations
+  } = usePendingMutationsContext();
+  const {
+    failedTransactions,
+    clearFailure
+  } = useFailedTransactionsContext();
+  const [, forceUpdate] = useState(0);
+  const recentlySyncedRef = useRef(/* @__PURE__ */ new Map());
+  const entityPendingMutations = useMemo(() => {
+    if (!entityId) return [];
+    return pendingMutations.filter((entry) => entry.id === entityId || String(entry.opData?.id) === entityId);
+  }, [entityId, pendingMutations]);
+  const failedTransaction = useMemo(() => {
+    if (!entityId) return null;
+    return failedTransactions.find((ft) => ft.affectedEntityIds.includes(entityId)) ?? null;
+  }, [entityId, failedTransactions]);
+  const wasSyncingRef = useRef(false);
+  const isCurrentlySyncing = entityPendingMutations.length > 0;
+  useEffect(() => {
+    if (!entityId) return;
+    if (wasSyncingRef.current && !isCurrentlySyncing && !failedTransaction) {
+      recentlySyncedRef.current.set(entityId, Date.now());
+      const timer = setTimeout(() => {
+        const syncedAt = recentlySyncedRef.current.get(entityId);
+        if (syncedAt && Date.now() - syncedAt >= SYNCED_DISPLAY_DURATION_MS) {
+          recentlySyncedRef.current.delete(entityId);
+          forceUpdate((n) => n + 1);
+        }
+      }, SYNCED_DISPLAY_DURATION_MS);
+      return () => {
+        clearTimeout(timer);
+        recentlySyncedRef.current.delete(entityId);
+      };
+    }
+    wasSyncingRef.current = isCurrentlySyncing;
+  }, [entityId, isCurrentlySyncing, failedTransaction]);
+  const state = useMemo(() => {
+    if (!entityId) return "idle";
+    if (failedTransaction) {
+      return "error";
+    }
+    if (entityPendingMutations.length > 0) {
+      return "syncing";
+    }
+    const syncedAt_0 = recentlySyncedRef.current.get(entityId);
+    if (syncedAt_0 && Date.now() - syncedAt_0 < SYNCED_DISPLAY_DURATION_MS) {
+      return "synced";
+    }
+    return "idle";
+  }, [entityId, failedTransaction, entityPendingMutations.length]);
+  const error = failedTransaction?.error ?? null;
+  const dismiss = useCallback(() => {
+    if (failedTransaction) {
+      clearFailure(failedTransaction.id);
+    }
+  }, [failedTransaction, clearFailure]);
+  return {
+    state,
+    error,
+    pendingOperations: entityPendingMutations.length,
+    failedTransaction,
+    dismiss
+  };
+}
+function useUploadStatus() {
+  const $ = _c(12);
+  const {
+    pendingCount
+  } = usePendingMutationsContext();
+  const {
+    failedTransactions,
+    hasUploadErrors,
+    permanentErrorCount,
+    clearAllFailures
+  } = useFailedTransactionsContext();
+  const {
+    triggerSync
+  } = useSyncControl();
+  let t0;
+  if ($[0] !== triggerSync) {
+    t0 = async () => {
+      await triggerSync();
+    };
+    $[0] = triggerSync;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const retryAll = t0;
+  let t1;
+  if ($[2] !== clearAllFailures) {
+    t1 = () => {
+      clearAllFailures();
+    };
+    $[2] = clearAllFailures;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const dismissAll = t1;
+  const t2 = permanentErrorCount > 0;
+  let t3;
+  if ($[4] !== dismissAll || $[5] !== failedTransactions || $[6] !== hasUploadErrors || $[7] !== pendingCount || $[8] !== permanentErrorCount || $[9] !== retryAll || $[10] !== t2) {
+    t3 = {
+      pendingCount,
+      failedCount: failedTransactions.length,
+      permanentFailureCount: permanentErrorCount,
+      hasErrors: hasUploadErrors,
+      hasPermanentErrors: t2,
+      failedTransactions,
+      retryAll,
+      dismissAll
+    };
+    $[4] = dismissAll;
+    $[5] = failedTransactions;
+    $[6] = hasUploadErrors;
+    $[7] = pendingCount;
+    $[8] = permanentErrorCount;
+    $[9] = retryAll;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
+}
+function useSyncActivity() {
+  const $ = _c(24);
+  const {
+    pendingMutations
+  } = usePendingMutationsContext();
+  const {
+    failedTransactions,
+    clearFailure,
+    retryFailure
+  } = useFailedTransactionsContext();
+  const {
+    completedTransactions,
+    clearCompletedHistory,
+    clearCompletedItem,
+    newCompletedTransactions,
+    markNotificationsAsSeen
+  } = useCompletedTransactionsContext();
+  const {
+    uploading: isUploading,
+    downloading: isDownloading
+  } = useSyncActivityContext();
+  const {
+    triggerSync
+  } = useSyncControl();
+  let t0;
+  if ($[0] !== triggerSync) {
+    t0 = async () => {
+      await triggerSync();
+    };
+    $[0] = triggerSync;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const retryAll = t0;
+  let t1;
+  if ($[2] !== clearFailure) {
+    t1 = (failureId) => {
+      clearFailure(failureId);
+    };
+    $[2] = clearFailure;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const dismissFailure = t1;
+  let t2;
+  if ($[4] !== clearCompletedHistory) {
+    t2 = () => {
+      clearCompletedHistory();
+    };
+    $[4] = clearCompletedHistory;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const clearCompleted = t2;
+  let t3;
+  if ($[6] !== completedTransactions.length || $[7] !== failedTransactions.length || $[8] !== newCompletedTransactions.length || $[9] !== pendingMutations.length) {
+    t3 = {
+      pending: pendingMutations.length,
+      failed: failedTransactions.length,
+      completed: completedTransactions.length,
+      newCompleted: newCompletedTransactions.length
+    };
+    $[6] = completedTransactions.length;
+    $[7] = failedTransactions.length;
+    $[8] = newCompletedTransactions.length;
+    $[9] = pendingMutations.length;
+    $[10] = t3;
+  } else {
+    t3 = $[10];
+  }
+  const counts = t3;
+  const hasActivity = isUploading || isDownloading || failedTransactions.length > 0;
+  let t4;
+  if ($[11] !== clearCompleted || $[12] !== clearCompletedItem || $[13] !== completedTransactions || $[14] !== counts || $[15] !== dismissFailure || $[16] !== failedTransactions || $[17] !== hasActivity || $[18] !== markNotificationsAsSeen || $[19] !== newCompletedTransactions || $[20] !== pendingMutations || $[21] !== retryAll || $[22] !== retryFailure) {
+    t4 = {
+      pending: pendingMutations,
+      failed: failedTransactions,
+      completed: completedTransactions,
+      newCompleted: newCompletedTransactions,
+      counts,
+      hasActivity,
+      retryAll,
+      retryFailure,
+      dismissFailure,
+      clearCompleted,
+      clearCompletedItem,
+      markNotificationsAsSeen
+    };
+    $[11] = clearCompleted;
+    $[12] = clearCompletedItem;
+    $[13] = completedTransactions;
+    $[14] = counts;
+    $[15] = dismissFailure;
+    $[16] = failedTransactions;
+    $[17] = hasActivity;
+    $[18] = markNotificationsAsSeen;
+    $[19] = newCompletedTransactions;
+    $[20] = pendingMutations;
+    $[21] = retryAll;
+    $[22] = retryFailure;
+    $[23] = t4;
+  } else {
+    t4 = $[23];
+  }
+  return t4;
+}
+var useFailedTransactions = useFailedTransactionsContext;
+var useCompletedTransactions = useCompletedTransactionsContext;
+
+export {
+  PowerSyncContext,
+  SyncStatusContext,
+  ConnectionStatusContext,
+  SyncActivityContext,
+  PendingMutationsContext,
+  FailedTransactionsContext,
+  CompletedTransactionsContext,
+  SyncModeContext,
+  ConnectionHealthContext,
+  SyncMetricsContext,
+  AttachmentQueueContext,
+  usePowerSync,
+  useSyncStatus,
+  useConnectionStatus,
+  useSyncActivityContext,
+  usePendingMutationsContext,
+  useFailedTransactionsContext,
+  useCompletedTransactionsContext,
+  useSyncModeContext,
+  useSyncControl,
+  useSyncMode,
+  useConnectionHealth,
+  useSyncMetrics,
+  useAttachmentQueue,
+  useAttachmentQueueReady,
+  useDatabase,
+  usePlatform,
+  useOnlineStatus,
+  usePendingMutations,
+  useIsSyncing,
+  useDownloadProgress,
+  useEntitySyncStatus,
+  useUploadStatus,
+  useSyncActivity,
+  useFailedTransactions,
+  useCompletedTransactions
+};
+//# sourceMappingURL=chunk-YSTEESEG.js.map