@pol-studios/powersync 1.0.0 → 1.0.2

package/dist/chunk-Q3LFFMRR.js

@@ -1,925 +0,0 @@
-import {
-  AttachmentQueue
-} from "./chunk-GBGATW2S.js";
-import {
-  DEFAULT_CONNECTION_HEALTH,
-  DEFAULT_SYNC_METRICS,
-  DEFAULT_SYNC_STATUS,
-  HealthMonitor,
-  MetricsCollector,
-  SyncStatusTracker
-} from "./chunk-CFCK2LHI.js";
-import {
-  SupabaseConnector
-} from "./chunk-FLHDT4TS.js";
-import {
-  createSyncError,
-  extractEntityIds,
-  extractTableNames
-} from "./chunk-CHRTN5PF.js";
-
-// src/provider/context.ts
-import { createContext } from "react";
-var PowerSyncContext = createContext(null);
-PowerSyncContext.displayName = "PowerSyncContext";
-var SyncStatusContext = createContext(null);
-SyncStatusContext.displayName = "SyncStatusContext";
-var ConnectionHealthContext = createContext(null);
-ConnectionHealthContext.displayName = "ConnectionHealthContext";
-var SyncMetricsContext = createContext(null);
-SyncMetricsContext.displayName = "SyncMetricsContext";
-var AttachmentQueueContext = createContext(null);
-AttachmentQueueContext.displayName = "AttachmentQueueContext";
-
-// src/provider/PowerSyncProvider.tsx
-import {
-  useEffect,
-  useState,
-  useRef,
-  useMemo,
-  useCallback
-} from "react";
-import { jsx } from "react/jsx-runtime";
-function PowerSyncProvider({
-  config,
-  children,
-  onReady,
-  onError,
-  onSyncStatusChange
-}) {
-  const {
-    platform,
-    schema,
-    powerSyncUrl,
-    supabaseClient,
-    dbFilename = "powersync.db",
-    connector: connectorConfig,
-    attachments: attachmentConfig,
-    sync: syncConfig
-  } = config;
-  const logger = platform.logger;
-  const mergedSyncConfig = {
-    autoConnect: syncConfig?.autoConnect ?? true,
-    syncInterval: syncConfig?.syncInterval ?? 0,
-    enableHealthMonitoring: syncConfig?.enableHealthMonitoring ?? true,
-    enableMetrics: syncConfig?.enableMetrics ?? true
-  };
-  const [db, setDb] = useState(null);
-  const [connector, setConnector] = useState(null);
-  const [attachmentQueue, setAttachmentQueue] = useState(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isInitializing, setIsInitializing] = useState(true);
-  const [error, setError] = useState(null);
-  const [session, setSession] = useState(null);
-  const [syncStatus, setSyncStatus] = useState(DEFAULT_SYNC_STATUS);
-  const [pendingMutations, setPendingMutations] = useState([]);
-  const [syncModeState, setSyncModeState] = useState({
-    loaded: false,
-    mode: "push-pull"
-  });
-  const [lastSyncedAt, setLastSyncedAt] = useState(null);
-  const [connectionError, setConnectionError] = useState(null);
-  const [failedTransactions, setFailedTransactions] = useState([]);
-  const [completedTransactions, setCompletedTransactions] = useState([]);
-  const [connectionHealth, setConnectionHealth] = useState(DEFAULT_CONNECTION_HEALTH);
-  const [syncMetrics, setSyncMetrics] = useState(DEFAULT_SYNC_METRICS);
-  const statusTrackerRef = useRef(null);
-  const metricsCollectorRef = useRef(null);
-  const healthMonitorRef = useRef(null);
-  const attachmentQueueRef = useRef(null);
-  const listenerUnsubscribeRef = useRef(null);
-  const wasSyncingRef = useRef(false);
-  const initializingRef = useRef(false);
-  const dbClosedRef = useRef(false);
-  useEffect(() => {
-    const statusTracker = new SyncStatusTracker(
-      platform.storage,
-      logger,
-      {
-        onStatusChange: (status) => {
-          setSyncStatus(status);
-          setLastSyncedAt(status.lastSyncedAt);
-          onSyncStatusChange?.(status);
-        }
-      }
-    );
-    statusTrackerRef.current = statusTracker;
-    const metricsCollector = new MetricsCollector(
-      platform.storage,
-      logger,
-      {
-        onMetricsChange: setSyncMetrics
-      }
-    );
-    metricsCollectorRef.current = metricsCollector;
-    const healthMonitor = new HealthMonitor(
-      logger,
-      {
-        onHealthChange: setConnectionHealth
-      }
-    );
-    healthMonitorRef.current = healthMonitor;
-    const initPromise = Promise.all([
-      statusTracker.init(),
-      metricsCollector.init()
-    ]);
-    const timeoutPromise = new Promise((resolve) => {
-      setTimeout(() => {
-        logger.warn("[PowerSyncProvider] Sync mode state load timed out, using default (push-pull)");
-        resolve([void 0, void 0]);
-      }, 5e3);
-    });
-    Promise.race([initPromise, timeoutPromise]).then(() => {
-      logger.info("[PowerSyncProvider] Sync mode state loaded:", {
-        mode: statusTracker.getSyncMode()
-      });
-      setSyncModeState({ loaded: true, mode: statusTracker.getSyncMode() });
-    });
-    return () => {
-      statusTracker.dispose();
-      metricsCollector.dispose();
-      healthMonitor.dispose();
-    };
-  }, [platform, logger, onSyncStatusChange]);
-  useEffect(() => {
-    logger.debug("[PowerSyncProvider] Setting up auth listener");
-    supabaseClient.auth.getSession().then(({ data: { session: initialSession } }) => {
-      logger.debug("[PowerSyncProvider] Initial session:", !!initialSession);
-      setSession(initialSession);
-    });
-    const { data: { subscription } } = supabaseClient.auth.onAuthStateChange(
-      (_event, newSession) => {
-        logger.debug("[PowerSyncProvider] Auth state changed, hasSession:", !!newSession);
-        setSession(newSession);
-      }
-    );
-    return () => {
-      subscription.unsubscribe();
-    };
-  }, [supabaseClient, logger]);
-  useEffect(() => {
-    if (initializingRef.current) {
-      logger.debug("[PowerSyncProvider] Already initializing, skipping...");
-      return;
-    }
-    initializingRef.current = true;
-    const controller = { cancelled: false };
-    const initDatabase = async () => {
-      try {
-        logger.info("[PowerSyncProvider] Initializing database...");
-        const database = await platform.createDatabase({
-          dbFilename,
-          schema
-        });
-        if (controller.cancelled) {
-          logger.debug("[PowerSyncProvider] Init cancelled, closing database...");
-          await database.close();
-          initializingRef.current = false;
-          return;
-        }
-        logger.info("[PowerSyncProvider] Database initialized");
-        setDb(database);
-        setIsReady(true);
-        setIsInitializing(false);
-        healthMonitorRef.current?.setDatabase(database);
-        if (mergedSyncConfig.enableHealthMonitoring) {
-          healthMonitorRef.current?.start();
-        }
-        onReady?.();
-      } catch (err) {
-        const initError = err instanceof Error ? err : new Error(String(err));
-        logger.error("[PowerSyncProvider] Initialization failed:", initError);
-        if (!controller.cancelled) {
-          setError(initError);
-          setIsInitializing(false);
-          onError?.(initError);
-        }
-        initializingRef.current = false;
-      }
-    };
-    initDatabase();
-    return () => {
-      controller.cancelled = true;
-      initializingRef.current = false;
-    };
-  }, [platform, dbFilename, schema, logger, mergedSyncConfig.enableHealthMonitoring, onReady, onError]);
-  useEffect(() => {
-    if (__DEV__) {
-      console.log("[PowerSyncProvider] Connect effect triggered:", {
-        hasDb: !!db,
-        hasSession: !!session,
-        autoConnect: mergedSyncConfig.autoConnect,
-        syncModeState
-      });
-    }
-    logger.info("[PowerSyncProvider] Connect effect - db:", !!db, "session:", !!session, "autoConnect:", mergedSyncConfig.autoConnect, "syncModeLoaded:", syncModeState.loaded, "syncMode:", syncModeState.mode);
-    if (!db) {
-      logger.debug("[PowerSyncProvider] Connect effect - waiting for db");
-      return;
-    }
-    if (!session) {
-      logger.debug("[PowerSyncProvider] Connect effect - no session");
-      return;
-    }
-    if (!mergedSyncConfig.autoConnect) {
-      logger.debug("[PowerSyncProvider] Connect effect - autoConnect disabled");
-      return;
-    }
-    if (!syncModeState.loaded) {
-      logger.info("[PowerSyncProvider] Waiting for sync mode state to load...");
-      return;
-    }
-    if (syncModeState.mode === "offline") {
-      logger.debug("[PowerSyncProvider] Skipping connect - offline mode");
-      return;
-    }
-    const connectPowerSync = async () => {
-      try {
-        setConnectionError(null);
-        const statusTracker = statusTrackerRef.current;
-        const newConnector = new SupabaseConnector({
-          supabaseClient,
-          powerSyncUrl,
-          schemaRouter: connectorConfig?.schemaRouter,
-          crudHandler: connectorConfig?.crudHandler,
-          logger,
-          // Check if uploads should be performed based on sync mode
-          shouldUpload: () => statusTrackerRef.current?.shouldUpload() ?? true,
-          // Clear failures when transaction succeeds
-          onTransactionSuccess: (entries) => {
-            if (!statusTracker) return;
-            const entityIds = extractEntityIds(entries);
-            entityIds.forEach((id) => {
-              const failures = statusTracker.getFailuresForEntity(id);
-              failures.forEach((f) => statusTracker.clearFailure(f.id));
-            });
-            setFailedTransactions(statusTracker.getFailedTransactions());
-          },
-          // Record failures when transaction fails
-          onTransactionFailure: (entries, error2, classified) => {
-            if (!statusTracker) return;
-            statusTracker.recordTransactionFailure(
-              entries,
-              createSyncError(classified, error2.message),
-              classified.isPermanent,
-              extractEntityIds(entries),
-              extractTableNames(entries)
-            );
-            setFailedTransactions(statusTracker.getFailedTransactions());
-          },
-          // Record completed transactions
-          onTransactionComplete: (entries) => {
-            if (!statusTracker) return;
-            statusTracker.recordTransactionComplete(entries);
-            setCompletedTransactions(statusTracker.getCompletedTransactions());
-          }
-        });
-        setConnector(newConnector);
-        if (db.connected) {
-          logger.debug("[PowerSyncProvider] Already connected, reconnecting...");
-          await db.disconnect();
-        }
-        logger.info("[PowerSyncProvider] Connecting to PowerSync...");
-        await db.connect(newConnector);
-        logger.info("[PowerSyncProvider] Connected successfully");
-        healthMonitorRef.current?.resetReconnectAttempts();
-      } catch (err) {
-        const connectError = err instanceof Error ? err : new Error(String(err));
-        logger.error("[PowerSyncProvider] Connection failed:", connectError);
-        setConnectionError(connectError);
-        healthMonitorRef.current?.recordReconnectAttempt();
-      }
-    };
-    connectPowerSync();
-  }, [db, session, powerSyncUrl, supabaseClient, connectorConfig, mergedSyncConfig.autoConnect, syncModeState, logger]);
-  useEffect(() => {
-    if (!db) return;
-    const initialStatus = db.currentStatus;
-    if (initialStatus) {
-      statusTrackerRef.current?.handleStatusChange(initialStatus);
-    }
-    const unsubscribe = db.registerListener({
-      statusChanged: (status) => {
-        statusTrackerRef.current?.handleStatusChange(status);
-        const dataFlow = status.dataFlowStatus;
-        const isDownloading = dataFlow?.downloading ?? false;
-        const progress = status.downloadProgress;
-        if (isDownloading && !wasSyncingRef.current) {
-          metricsCollectorRef.current?.markSyncStart();
-        }
-        if (!isDownloading && wasSyncingRef.current) {
-          const duration = metricsCollectorRef.current?.markSyncEnd();
-          if (duration !== null && duration !== void 0) {
-            metricsCollectorRef.current?.recordSync({
-              durationMs: duration,
-              success: true,
-              operationsDownloaded: progress?.totalOperations ?? 0
-            });
-          }
-        }
-        wasSyncingRef.current = isDownloading;
-      }
-    });
-    listenerUnsubscribeRef.current = unsubscribe;
-    return () => {
-      unsubscribe();
-      listenerUnsubscribeRef.current = null;
-    };
-  }, [db]);
-  const prevPendingCountRef = useRef(0);
-  const parseCrudRow = useCallback((row) => {
-    try {
-      const parsed = JSON.parse(row.data);
-      const opMap = {
-        "PUT": "PUT",
-        "PATCH": "PATCH",
-        "DELETE": "DELETE"
-      };
-      const op = opMap[parsed.op] ?? "PUT";
-      const entityId = parsed.data?.id ?? parsed.id ?? row.id;
-      return {
-        id: entityId,
-        clientId: parseInt(row.id, 10) || 0,
-        op,
-        table: parsed.type ?? "unknown",
-        opData: parsed.data ?? void 0,
-        // Ensure null becomes undefined
-        transactionId: row.tx_id ?? void 0
-      };
-    } catch (e) {
-      logger.warn("[PowerSyncProvider] Failed to parse CRUD entry:", e, row);
-      return null;
-    }
-  }, [logger]);
-  useEffect(() => {
-    if (!db) return;
-    const abortController = new AbortController();
-    db.watch(
-      "SELECT COUNT(*) as count FROM ps_crud",
-      [],
-      {
-        onResult: async (results) => {
-          if (dbClosedRef.current) {
-            logger.debug("[PowerSyncProvider] Skipping watch callback - database is closed");
-            return;
-          }
-          const count = results.rows?._array?.[0]?.count ?? 0;
-          const prevCount = prevPendingCountRef.current;
-          prevPendingCountRef.current = count;
-          let mutations = [];
-          if (count > 0) {
-            try {
-              if (dbClosedRef.current) {
-                logger.debug("[PowerSyncProvider] Skipping getAll - database is closed");
-                return;
-              }
-              const rows = await db.getAll(
-                "SELECT id, tx_id, data FROM ps_crud ORDER BY id ASC"
-              );
-              mutations = rows.map(parseCrudRow).filter((entry) => entry !== null);
-            } catch (e) {
-              const errorMessage = e instanceof Error ? e.message : String(e);
-              if (errorMessage.includes("not open") || errorMessage.includes("closed")) {
-                logger.debug("[PowerSyncProvider] Database closed during CRUD fetch, ignoring");
-                return;
-              }
-              logger.warn("[PowerSyncProvider] Failed to fetch CRUD entries:", e);
-            }
-          }
-          if (dbClosedRef.current) {
-            return;
-          }
-          statusTrackerRef.current?.updatePendingMutations(mutations);
-          setPendingMutations(mutations);
-          if (prevCount > 0 && count === 0) {
-            logger.debug("[PowerSyncProvider] All pending uploads complete, clearing force flag");
-            statusTrackerRef.current?.clearForceNextUpload();
-          }
-        },
-        onError: (error2) => {
-          const errorMessage = error2.message ?? "";
-          if (errorMessage.includes("not open") || errorMessage.includes("closed") || dbClosedRef.current) {
-            logger.debug("[PowerSyncProvider] Watch error during database close, ignoring");
-            return;
-          }
-          logger.warn("[PowerSyncProvider] Error watching ps_crud:", error2);
-        }
-      },
-      {
-        signal: abortController.signal,
-        throttleMs: 100
-        // Debounce to avoid excessive updates during bulk operations
-      }
-    );
-    return () => {
-      abortController.abort();
-    };
-  }, [db, logger, parseCrudRow]);
-  useEffect(() => {
-    if (!db || !attachmentConfig || attachmentQueueRef.current) {
-      return;
-    }
-    const initAttachmentQueue = async () => {
-      try {
-        logger.info("[PowerSyncProvider] Initializing attachment queue...");
-        const queue = new AttachmentQueue({
-          powersync: db,
-          platform,
-          config: attachmentConfig
-        });
-        await queue.init();
-        attachmentQueueRef.current = queue;
-        setAttachmentQueue(queue);
-        logger.info("[PowerSyncProvider] Attachment queue initialized");
-      } catch (err) {
-        logger.error("[PowerSyncProvider] Attachment queue initialization failed:", err);
-      }
-    };
-    initAttachmentQueue();
-    return () => {
-      attachmentQueueRef.current?.dispose();
-      attachmentQueueRef.current = null;
-    };
-  }, [db, attachmentConfig, platform, logger]);
-  useEffect(() => {
-    if (db) {
-      dbClosedRef.current = false;
-    }
-    return () => {
-      logger.info("[PowerSyncProvider] Cleaning up...");
-      dbClosedRef.current = true;
-      listenerUnsubscribeRef.current?.();
-      attachmentQueueRef.current?.dispose();
-      healthMonitorRef.current?.stop();
-      if (db) {
-        (async () => {
-          try {
-            await db.disconnect();
-            await db.close();
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            if (!errorMessage.includes("not open") && !errorMessage.includes("closed")) {
-              logger.warn("[PowerSyncProvider] Error during cleanup:", err);
-            }
-          }
-        })();
-      }
-    };
-  }, [db, logger]);
-  const clearFailure = useCallback((failureId) => {
-    const tracker = statusTrackerRef.current;
-    if (!tracker) {
-      logger.warn("[PowerSyncProvider] Cannot clear failure - tracker not initialized");
-      return;
-    }
-    tracker.clearFailure(failureId);
-    setFailedTransactions(tracker.getFailedTransactions());
-  }, [logger]);
-  const clearAllFailures = useCallback(() => {
-    const tracker = statusTrackerRef.current;
-    if (!tracker) {
-      logger.warn("[PowerSyncProvider] Cannot clear failures - tracker not initialized");
-      return;
-    }
-    tracker.clearAllFailures();
-    setFailedTransactions(tracker.getFailedTransactions());
-  }, [logger]);
-  const clearCompletedHistory = useCallback(() => {
-    const tracker = statusTrackerRef.current;
-    if (!tracker) {
-      logger.warn("[PowerSyncProvider] Cannot clear completed history - tracker not initialized");
-      return;
-    }
-    tracker.clearCompletedHistory();
-    setCompletedTransactions(tracker.getCompletedTransactions());
-  }, [logger]);
-  const setSyncMode = useCallback(async (mode) => {
-    const tracker = statusTrackerRef.current;
-    if (!tracker) {
-      logger.warn("[PowerSyncProvider] Cannot set sync mode - tracker not initialized");
-      return;
-    }
-    await tracker.setSyncMode(mode);
-    setSyncModeState({ loaded: true, mode });
-  }, [logger]);
-  const setForceNextUpload = useCallback((force) => {
-    const tracker = statusTrackerRef.current;
-    if (!tracker) {
-      logger.warn("[PowerSyncProvider] Cannot set force upload - tracker not initialized");
-      return;
-    }
-    tracker.setForceNextUpload(force);
-  }, [logger]);
-  const discardPendingMutation = useCallback(async (clientId) => {
-    if (!db || !connector) {
-      logger.warn("[PowerSync] Cannot discard - not initialized");
-      return;
-    }
-    if (syncStatus.uploading) {
-      throw new Error("Cannot discard while upload is in progress");
-    }
-    logger.info("[PowerSync] Discarding pending mutation:", clientId);
-    await db.disconnect();
-    try {
-      await db.execute("DELETE FROM ps_crud WHERE id = ?", [clientId]);
-      logger.info("[PowerSync] Mutation discarded successfully");
-    } finally {
-      await db.connect(connector);
-    }
-  }, [db, connector, syncStatus.uploading, logger]);
-  const discardAllPendingMutations = useCallback(async () => {
-    if (!db || !connector) {
-      logger.warn("[PowerSync] Cannot discard all - not initialized");
-      return;
-    }
-    if (syncStatus.uploading) {
-      throw new Error("Cannot discard while upload is in progress");
-    }
-    logger.info("[PowerSync] Discarding all pending mutations");
-    await db.disconnect();
-    try {
-      await db.execute("DELETE FROM ps_crud");
-      logger.info("[PowerSync] All mutations discarded successfully");
-    } finally {
-      await db.connect(connector);
-    }
-  }, [db, connector, syncStatus.uploading, logger]);
-  const powerSyncContextValue = useMemo(
-    () => ({
-      db,
-      connector,
-      attachmentQueue,
-      isReady,
-      isInitializing,
-      error,
-      schema,
-      platform
-    }),
-    [db, connector, attachmentQueue, isReady, isInitializing, error, schema, platform]
-  );
-  const syncStatusContextValue = useMemo(
-    () => ({
-      status: syncStatus,
-      pendingMutations,
-      pendingCount: pendingMutations.length,
-      // Expose uploading/downloading directly from syncStatus for reliable activity detection
-      isUploading: syncStatus.uploading,
-      isDownloading: syncStatus.downloading,
-      isPaused: syncModeState.mode === "offline",
-      syncMode: syncModeState.mode,
-      lastSyncedAt,
-      // Connection error for consumers to display
-      connectionError,
-      // Failed transaction fields
-      failedTransactions,
-      hasUploadErrors: failedTransactions.length > 0,
-      permanentErrorCount: failedTransactions.filter((f) => f.isPermanent).length,
-      // Clear failure functions
-      clearFailure,
-      clearAllFailures,
-      // Completed transaction fields
-      completedTransactions,
-      clearCompletedHistory,
-      // Sync mode control functions
-      setSyncMode,
-      setForceNextUpload,
-      // Discard mutation functions
-      discardPendingMutation,
-      discardAllPendingMutations
-    }),
-    [syncStatus, pendingMutations, syncModeState.mode, lastSyncedAt, connectionError, failedTransactions, clearFailure, clearAllFailures, completedTransactions, clearCompletedHistory, setSyncMode, setForceNextUpload, discardPendingMutation, discardAllPendingMutations]
-  );
-  const connectionHealthContextValue = useMemo(
-    () => ({ health: connectionHealth }),
-    [connectionHealth]
-  );
-  const syncMetricsContextValue = useMemo(
-    () => ({ metrics: syncMetrics }),
-    [syncMetrics]
-  );
-  return /* @__PURE__ */ jsx(PowerSyncContext.Provider, { value: powerSyncContextValue, children: /* @__PURE__ */ jsx(SyncStatusContext.Provider, { value: syncStatusContextValue, children: /* @__PURE__ */ jsx(ConnectionHealthContext.Provider, { value: connectionHealthContextValue, children: /* @__PURE__ */ jsx(SyncMetricsContext.Provider, { value: syncMetricsContextValue, children: /* @__PURE__ */ jsx(AttachmentQueueContext.Provider, { value: attachmentQueue, children }) }) }) }) });
-}
-
-// src/provider/hooks.ts
-import { useContext, useCallback as useCallback2, useMemo as useMemo2, useRef as useRef2, useState as useState2, useEffect as useEffect2 } from "react";
-function usePowerSync() {
-  const context = useContext(PowerSyncContext);
-  if (!context) {
-    throw new Error("usePowerSync must be used within a PowerSyncProvider");
-  }
-  return context;
-}
-function useSyncStatus() {
-  const context = useContext(SyncStatusContext);
-  if (!context) {
-    throw new Error("useSyncStatus must be used within a PowerSyncProvider");
-  }
-  return context;
-}
-function useSyncControl() {
-  const { db, connector, platform } = usePowerSync();
-  const { setSyncMode: setContextSyncMode, setForceNextUpload } = useSyncStatus();
-  const scopeRef = useRef2(null);
-  const setSyncMode = useCallback2(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);
-    }
-  }, [db, connector, platform, setContextSyncMode]);
-  const syncNow = useCallback2(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");
-  }, [db, connector, platform, setForceNextUpload]);
-  const triggerSync = useCallback2(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");
-  }, [db, connector, platform, setContextSyncMode]);
-  const pause = useCallback2(async () => {
-    await setSyncMode("offline");
-    platform.logger.info("[useSyncControl] Sync paused");
-  }, [setSyncMode, platform]);
-  const resume = useCallback2(async () => {
-    await setSyncMode("push-pull");
-    platform.logger.info("[useSyncControl] Sync resumed");
-  }, [setSyncMode, platform]);
-  const disconnect = useCallback2(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");
-  }, [db, platform]);
-  const setScope = useCallback2((scope) => {
-    scopeRef.current = scope;
-    if (connector && scope) {
-      connector.setActiveProjectIds(scope.ids);
-      platform.logger.info("[useSyncControl] Scope set:", scope);
-    }
-  }, [connector, platform]);
-  return useMemo2(
-    () => ({
-      triggerSync,
-      syncNow,
-      pause,
-      resume,
-      disconnect,
-      setScope,
-      setSyncMode
-    }),
-    [triggerSync, syncNow, pause, resume, disconnect, setScope, setSyncMode]
-  );
-}
-function useSyncMode() {
-  const { syncMode } = useSyncStatus();
-  const { setSyncMode } = useSyncControl();
-  return useMemo2(() => ({
-    mode: syncMode,
-    setMode: setSyncMode,
-    canUpload: syncMode === "push-pull",
-    canDownload: syncMode !== "offline"
-  }), [syncMode, setSyncMode]);
-}
-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 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 { platform } = usePowerSync();
-  const [isOnline, setIsOnline] = useState2(true);
-  useEffect2(() => {
-    platform.network.isConnected().then(setIsOnline);
-    const unsubscribe = platform.network.addConnectionListener(setIsOnline);
-    return unsubscribe;
-  }, [platform]);
-  return isOnline;
-}
-function usePendingMutations() {
-  const { pendingMutations, pendingCount } = useSyncStatus();
-  return useMemo2(
-    () => ({
-      mutations: pendingMutations,
-      count: pendingCount
-    }),
-    [pendingMutations, pendingCount]
-  );
-}
-function useIsSyncing() {
-  const { status } = useSyncStatus();
-  return status.uploading || status.downloading;
-}
-function useDownloadProgress() {
-  const { status } = useSyncStatus();
-  return status.downloadProgress;
-}
-var recentlySyncedEntities = /* @__PURE__ */ new Map();
-var SYNCED_DISPLAY_DURATION_MS = 3e3;
-function useEntitySyncStatus(entityId) {
-  const { status, pendingMutations, clearFailure, failedTransactions } = useSyncStatus();
-  const [, forceUpdate] = useState2(0);
-  const entityPendingMutations = useMemo2(() => {
-    if (!entityId) return [];
-    return pendingMutations.filter(
-      (entry) => entry.id === entityId || String(entry.opData?.id) === entityId
-    );
-  }, [entityId, pendingMutations]);
-  const failedTransaction = useMemo2(() => {
-    if (!entityId) return null;
-    return failedTransactions.find(
-      (ft) => ft.affectedEntityIds.includes(entityId)
-    ) ?? null;
-  }, [entityId, failedTransactions]);
-  const wasSyncingRef = useRef2(false);
-  const isCurrentlySyncing = entityPendingMutations.length > 0;
-  useEffect2(() => {
-    if (!entityId) return;
-    if (wasSyncingRef.current && !isCurrentlySyncing && !failedTransaction) {
-      recentlySyncedEntities.set(entityId, Date.now());
-      const timer = setTimeout(() => {
-        const syncedAt = recentlySyncedEntities.get(entityId);
-        if (syncedAt && Date.now() - syncedAt >= SYNCED_DISPLAY_DURATION_MS) {
-          recentlySyncedEntities.delete(entityId);
-          forceUpdate((n) => n + 1);
-        }
-      }, SYNCED_DISPLAY_DURATION_MS);
-      return () => clearTimeout(timer);
-    }
-    wasSyncingRef.current = isCurrentlySyncing;
-  }, [entityId, isCurrentlySyncing, failedTransaction]);
-  const state = useMemo2(() => {
-    if (!entityId) return "idle";
-    if (failedTransaction) {
-      return "error";
-    }
-    if (entityPendingMutations.length > 0) {
-      return "syncing";
-    }
-    const syncedAt = recentlySyncedEntities.get(entityId);
-    if (syncedAt && Date.now() - syncedAt < SYNCED_DISPLAY_DURATION_MS) {
-      return "synced";
-    }
-    return "idle";
-  }, [entityId, failedTransaction, entityPendingMutations.length]);
-  const error = failedTransaction?.error ?? null;
-  const dismiss = useCallback2(() => {
-    if (failedTransaction) {
-      clearFailure(failedTransaction.id);
-    }
-  }, [failedTransaction, clearFailure]);
-  return {
-    state,
-    error,
-    pendingOperations: entityPendingMutations.length,
-    failedTransaction,
-    dismiss
-  };
-}
-function useUploadStatus() {
-  const { status, pendingCount, clearAllFailures, failedTransactions, hasUploadErrors, permanentErrorCount } = useSyncStatus();
-  const { triggerSync } = useSyncControl();
-  const retryAll = useCallback2(async () => {
-    await triggerSync();
-  }, [triggerSync]);
-  const dismissAll = useCallback2(() => {
-    clearAllFailures();
-  }, [clearAllFailures]);
-  return useMemo2(
-    () => ({
-      pendingCount,
-      failedCount: failedTransactions.length,
-      permanentFailureCount: permanentErrorCount,
-      hasErrors: hasUploadErrors,
-      hasPermanentErrors: permanentErrorCount > 0,
-      failedTransactions,
-      retryAll,
-      dismissAll
-    }),
-    [
-      pendingCount,
-      failedTransactions,
-      permanentErrorCount,
-      hasUploadErrors,
-      retryAll,
-      dismissAll
-    ]
-  );
-}
-function useSyncActivity() {
-  const {
-    pendingMutations,
-    clearFailure,
-    failedTransactions,
-    completedTransactions,
-    clearCompletedHistory,
-    isUploading,
-    isDownloading
-  } = useSyncStatus();
-  const { triggerSync } = useSyncControl();
-  const retryAll = useCallback2(async () => {
-    await triggerSync();
-  }, [triggerSync]);
-  const dismissFailure = useCallback2((failureId) => {
-    clearFailure(failureId);
-  }, [clearFailure]);
-  const clearCompleted = useCallback2(() => {
-    clearCompletedHistory();
-  }, [clearCompletedHistory]);
-  const counts = useMemo2(() => ({
-    pending: pendingMutations.length,
-    failed: failedTransactions.length,
-    completed: completedTransactions.length
-  }), [pendingMutations.length, failedTransactions.length, completedTransactions.length]);
-  const hasActivity = isUploading || isDownloading || failedTransactions.length > 0;
-  return useMemo2(
-    () => ({
-      pending: pendingMutations,
-      failed: failedTransactions,
-      completed: completedTransactions,
-      counts,
-      hasActivity,
-      retryAll,
-      dismissFailure,
-      clearCompleted
-    }),
-    [pendingMutations, failedTransactions, completedTransactions, counts, hasActivity, retryAll, dismissFailure, clearCompleted]
-  );
-}
-
-export {
-  PowerSyncContext,
-  SyncStatusContext,
-  ConnectionHealthContext,
-  SyncMetricsContext,
-  AttachmentQueueContext,
-  PowerSyncProvider,
-  usePowerSync,
-  useSyncStatus,
-  useSyncControl,
-  useSyncMode,
-  useConnectionHealth,
-  useSyncMetrics,
-  useAttachmentQueue,
-  useDatabase,
-  usePlatform,
-  useOnlineStatus,
-  usePendingMutations,
-  useIsSyncing,
-  useDownloadProgress,
-  useEntitySyncStatus,
-  useUploadStatus,
-  useSyncActivity
-};
-//# sourceMappingURL=chunk-Q3LFFMRR.js.map