@pol-studios/powersync 1.0.1 → 1.0.3

package/dist/chunk-GMFDCVMZ.js

@@ -0,0 +1,1285 @@
+import {
+  AttachmentQueue
+} from "./chunk-V6LJ6MR2.js";
+import {
+  DEFAULT_CONNECTION_HEALTH,
+  DEFAULT_SYNC_METRICS,
+  DEFAULT_SYNC_STATUS,
+  HealthMonitor,
+  MetricsCollector,
+  SyncStatusTracker
+} from "./chunk-OTJXIRWX.js";
+import {
+  SupabaseConnector
+} from "./chunk-C2RSTGDC.js";
+import {
+  createSyncError,
+  extractEntityIds,
+  extractTableNames
+} from "./chunk-FPTDATY5.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";
+
+// src/conflicts/conflict-bus.ts
+var ConflictBus = class {
+  conflictListeners = /* @__PURE__ */ new Set();
+  resolutionListeners = /* @__PURE__ */ new Set();
+  /**
+   * Subscribe to conflict detection events.
+   * @returns Unsubscribe function
+   */
+  onConflict(listener) {
+    this.conflictListeners.add(listener);
+    return () => this.conflictListeners.delete(listener);
+  }
+  /**
+   * Subscribe to resolution events.
+   * @returns Unsubscribe function
+   */
+  onResolution(listener) {
+    this.resolutionListeners.add(listener);
+    return () => this.resolutionListeners.delete(listener);
+  }
+  /**
+   * Emit a conflict detection event (called by connector).
+   */
+  emitConflict(conflict) {
+    this.conflictListeners.forEach((listener) => listener(conflict));
+  }
+  /**
+   * Emit a resolution event (called by UI/ConflictContext).
+   */
+  emitResolution(table, recordId, resolution) {
+    this.resolutionListeners.forEach((listener) => listener(table, recordId, resolution));
+  }
+  /**
+   * Clear all listeners (for cleanup).
+   */
+  destroy() {
+    this.conflictListeners.clear();
+    this.resolutionListeners.clear();
+  }
+};
+
+// src/provider/PowerSyncProvider.tsx
+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 conflictBusRef = useRef(null);
+  if (!conflictBusRef.current) {
+    conflictBusRef.current = new ConflictBus();
+  }
+  const conflictBus = conflictBusRef.current;
+  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);
+  const connectorRef = useRef(null);
+  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);
+        connectorRef.current?.destroy();
+        const statusTracker_0 = statusTrackerRef.current;
+        const newConnector = new SupabaseConnector({
+          supabaseClient,
+          powerSyncUrl,
+          schemaRouter: connectorConfig?.schemaRouter,
+          crudHandler: connectorConfig?.crudHandler,
+          logger,
+          // Conflict detection - enabled by default
+          conflictDetection: {
+            enabled: true
+          },
+          conflictBus,
+          // Check if uploads should be performed based on sync mode
+          shouldUpload: () => statusTrackerRef.current?.shouldUpload() ?? true,
+          // Clear failures when transaction succeeds
+          onTransactionSuccess: (entries) => {
+            if (!statusTracker_0) return;
+            const entityIds = extractEntityIds(entries);
+            entityIds.forEach((id) => {
+              const failures = statusTracker_0.getFailuresForEntity(id);
+              failures.forEach((f) => statusTracker_0.clearFailure(f.id));
+            });
+            setFailedTransactions(statusTracker_0.getFailedTransactions());
+          },
+          // Record failures when transaction fails
+          onTransactionFailure: (entries_0, error_0, classified) => {
+            if (!statusTracker_0) return;
+            statusTracker_0.recordTransactionFailure(entries_0, createSyncError(classified, error_0.message), classified.isPermanent, extractEntityIds(entries_0), extractTableNames(entries_0));
+            setFailedTransactions(statusTracker_0.getFailedTransactions());
+          },
+          // Record completed transactions
+          onTransactionComplete: (entries_1) => {
+            if (!statusTracker_0) return;
+            statusTracker_0.recordTransactionComplete(entries_1);
+            setCompletedTransactions(statusTracker_0.getCompletedTransactions());
+          }
+        });
+        setConnector(newConnector);
+        connectorRef.current = 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_0) {
+        const connectError = err_0 instanceof Error ? err_0 : new Error(String(err_0));
+        logger.error("[PowerSyncProvider] Connection failed:", connectError);
+        setConnectionError(connectError);
+        healthMonitorRef.current?.recordReconnectAttempt();
+      }
+    };
+    connectPowerSync();
+  }, [db, session, powerSyncUrl, supabaseClient, connectorConfig, conflictBus, mergedSyncConfig.autoConnect, syncModeState, logger]);
+  useEffect(() => {
+    if (!db) return;
+    const initialStatus = db.currentStatus;
+    if (initialStatus) {
+      statusTrackerRef.current?.handleStatusChange(initialStatus);
+    }
+    const unsubscribe = db.registerListener({
+      statusChanged: (status_0) => {
+        statusTrackerRef.current?.handleStatusChange(status_0);
+        const dataFlow = status_0.dataFlowStatus;
+        const isDownloading = dataFlow?.downloading ?? false;
+        const progress = status_0.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_0) {
+            const errorMessage = e_0 instanceof Error ? e_0.message : String(e_0);
+            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_0);
+          }
+        }
+        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: (error_1) => {
+        const errorMessage_0 = error_1.message ?? "";
+        if (errorMessage_0.includes("not open") || errorMessage_0.includes("closed") || dbClosedRef.current) {
+          logger.debug("[PowerSyncProvider] Watch error during database close, ignoring");
+          return;
+        }
+        logger.warn("[PowerSyncProvider] Error watching ps_crud:", error_1);
+      }
+    }, {
+      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_1) {
+        logger.error("[PowerSyncProvider] Attachment queue initialization failed:", err_1);
+      }
+    };
+    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;
+      connectorRef.current?.destroy();
+      connectorRef.current = null;
+      listenerUnsubscribeRef.current?.();
+      attachmentQueueRef.current?.dispose();
+      healthMonitorRef.current?.stop();
+      conflictBusRef.current?.destroy();
+      if (db) {
+        (async () => {
+          try {
+            await db.disconnect();
+            await db.close();
+          } catch (err_2) {
+            const errorMessage_1 = err_2 instanceof Error ? err_2.message : String(err_2);
+            if (!errorMessage_1.includes("not open") && !errorMessage_1.includes("closed")) {
+              logger.warn("[PowerSyncProvider] Error during cleanup:", err_2);
+            }
+          }
+        })();
+      }
+    };
+  }, [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_0 = statusTrackerRef.current;
+    if (!tracker_0) {
+      logger.warn("[PowerSyncProvider] Cannot clear failures - tracker not initialized");
+      return;
+    }
+    tracker_0.clearAllFailures();
+    setFailedTransactions(tracker_0.getFailedTransactions());
+  }, [logger]);
+  const clearCompletedHistory = useCallback(() => {
+    const tracker_1 = statusTrackerRef.current;
+    if (!tracker_1) {
+      logger.warn("[PowerSyncProvider] Cannot clear completed history - tracker not initialized");
+      return;
+    }
+    tracker_1.clearCompletedHistory();
+    setCompletedTransactions(tracker_1.getCompletedTransactions());
+  }, [logger]);
+  const setSyncMode = useCallback(async (mode) => {
+    const tracker_2 = statusTrackerRef.current;
+    if (!tracker_2) {
+      logger.warn("[PowerSyncProvider] Cannot set sync mode - tracker not initialized");
+      return;
+    }
+    await tracker_2.setSyncMode(mode);
+    setSyncModeState({
+      loaded: true,
+      mode
+    });
+  }, [logger]);
+  const setForceNextUpload = useCallback((force) => {
+    const tracker_3 = statusTrackerRef.current;
+    if (!tracker_3) {
+      logger.warn("[PowerSyncProvider] Cannot set force upload - tracker not initialized");
+      return;
+    }
+    tracker_3.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,
+    conflictBus
+  }), [db, connector, attachmentQueue, isReady, isInitializing, error, schema, platform, conflictBus]);
+  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_0) => f_0.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 { c as _c } from "react/compiler-runtime";
+import { useContext, 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 $ = _c(35);
+  const {
+    db,
+    connector,
+    platform
+  } = usePowerSync();
+  const {
+    setSyncMode: setContextSyncMode,
+    setForceNextUpload
+  } = useSyncStatus();
+  const scopeRef = useRef2(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(5);
+  const {
+    syncMode
+  } = useSyncStatus();
+  const {
+    setSyncMode
+  } = useSyncControl();
+  const t0 = syncMode === "push-pull";
+  const t1 = syncMode !== "offline";
+  let t2;
+  if ($[0] !== setSyncMode || $[1] !== syncMode || $[2] !== t0 || $[3] !== t1) {
+    t2 = {
+      mode: syncMode,
+      setMode: setSyncMode,
+      canUpload: t0,
+      canDownload: t1
+    };
+    $[0] = setSyncMode;
+    $[1] = syncMode;
+    $[2] = t0;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  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 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] = useState2(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];
+  }
+  useEffect2(t0, t1);
+  return isOnline;
+}
+function usePendingMutations() {
+  const $ = _c(3);
+  const {
+    pendingMutations,
+    pendingCount
+  } = useSyncStatus();
+  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 {
+    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 $ = _c(27);
+  const {
+    pendingMutations,
+    clearFailure,
+    failedTransactions
+  } = useSyncStatus();
+  const [, forceUpdate] = useState2(0);
+  let t0;
+  bb0: {
+    if (!entityId) {
+      let t13;
+      if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+        t13 = [];
+        $[0] = t13;
+      } else {
+        t13 = $[0];
+      }
+      t0 = t13;
+      break bb0;
+    }
+    let t12;
+    if ($[1] !== entityId || $[2] !== pendingMutations) {
+      let t22;
+      if ($[4] !== entityId) {
+        t22 = (entry) => entry.id === entityId || String(entry.opData?.id) === entityId;
+        $[4] = entityId;
+        $[5] = t22;
+      } else {
+        t22 = $[5];
+      }
+      t12 = pendingMutations.filter(t22);
+      $[1] = entityId;
+      $[2] = pendingMutations;
+      $[3] = t12;
+    } else {
+      t12 = $[3];
+    }
+    t0 = t12;
+  }
+  const entityPendingMutations = t0;
+  let t1;
+  bb1: {
+    if (!entityId) {
+      t1 = null;
+      break bb1;
+    }
+    let t22;
+    if ($[6] !== entityId || $[7] !== failedTransactions) {
+      t22 = failedTransactions.find((ft) => ft.affectedEntityIds.includes(entityId)) ?? null;
+      $[6] = entityId;
+      $[7] = failedTransactions;
+      $[8] = t22;
+    } else {
+      t22 = $[8];
+    }
+    t1 = t22;
+  }
+  const failedTransaction = t1;
+  const wasSyncingRef = useRef2(false);
+  const isCurrentlySyncing = entityPendingMutations.length > 0;
+  let t2;
+  if ($[9] !== entityId || $[10] !== failedTransaction || $[11] !== forceUpdate || $[12] !== isCurrentlySyncing) {
+    t2 = () => {
+      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(_temp);
+          }
+        }, SYNCED_DISPLAY_DURATION_MS);
+        return () => clearTimeout(timer);
+      }
+      wasSyncingRef.current = isCurrentlySyncing;
+    };
+    $[9] = entityId;
+    $[10] = failedTransaction;
+    $[11] = forceUpdate;
+    $[12] = isCurrentlySyncing;
+    $[13] = t2;
+  } else {
+    t2 = $[13];
+  }
+  let t3;
+  if ($[14] !== entityId || $[15] !== failedTransaction || $[16] !== isCurrentlySyncing) {
+    t3 = [entityId, isCurrentlySyncing, failedTransaction];
+    $[14] = entityId;
+    $[15] = failedTransaction;
+    $[16] = isCurrentlySyncing;
+    $[17] = t3;
+  } else {
+    t3 = $[17];
+  }
+  useEffect2(t2, t3);
+  let t4;
+  bb2: {
+    if (!entityId) {
+      t4 = "idle";
+      break bb2;
+    }
+    if (failedTransaction) {
+      t4 = "error";
+      break bb2;
+    }
+    if (entityPendingMutations.length > 0) {
+      t4 = "syncing";
+      break bb2;
+    }
+    const syncedAt_0 = recentlySyncedEntities.get(entityId);
+    if (syncedAt_0 && Date.now() - syncedAt_0 < SYNCED_DISPLAY_DURATION_MS) {
+      t4 = "synced";
+      break bb2;
+    }
+    t4 = "idle";
+  }
+  const state = t4;
+  const error = failedTransaction?.error ?? null;
+  let t5;
+  if ($[18] !== clearFailure || $[19] !== failedTransaction) {
+    t5 = () => {
+      if (failedTransaction) {
+        clearFailure(failedTransaction.id);
+      }
+    };
+    $[18] = clearFailure;
+    $[19] = failedTransaction;
+    $[20] = t5;
+  } else {
+    t5 = $[20];
+  }
+  const dismiss = t5;
+  let t6;
+  if ($[21] !== dismiss || $[22] !== entityPendingMutations.length || $[23] !== error || $[24] !== failedTransaction || $[25] !== state) {
+    t6 = {
+      state,
+      error,
+      pendingOperations: entityPendingMutations.length,
+      failedTransaction,
+      dismiss
+    };
+    $[21] = dismiss;
+    $[22] = entityPendingMutations.length;
+    $[23] = error;
+    $[24] = failedTransaction;
+    $[25] = state;
+    $[26] = t6;
+  } else {
+    t6 = $[26];
+  }
+  return t6;
+}
+function _temp(n) {
+  return n + 1;
+}
+function useUploadStatus() {
+  const $ = _c(12);
+  const {
+    pendingCount,
+    clearAllFailures,
+    failedTransactions,
+    hasUploadErrors,
+    permanentErrorCount
+  } = useSyncStatus();
+  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(19);
+  const {
+    pendingMutations,
+    clearFailure,
+    failedTransactions,
+    completedTransactions,
+    clearCompletedHistory,
+    isUploading,
+    isDownloading
+  } = useSyncStatus();
+  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] !== pendingMutations.length) {
+    t3 = {
+      pending: pendingMutations.length,
+      failed: failedTransactions.length,
+      completed: completedTransactions.length
+    };
+    $[6] = completedTransactions.length;
+    $[7] = failedTransactions.length;
+    $[8] = pendingMutations.length;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  const counts = t3;
+  const hasActivity = isUploading || isDownloading || failedTransactions.length > 0;
+  let t4;
+  if ($[10] !== clearCompleted || $[11] !== completedTransactions || $[12] !== counts || $[13] !== dismissFailure || $[14] !== failedTransactions || $[15] !== hasActivity || $[16] !== pendingMutations || $[17] !== retryAll) {
+    t4 = {
+      pending: pendingMutations,
+      failed: failedTransactions,
+      completed: completedTransactions,
+      counts,
+      hasActivity,
+      retryAll,
+      dismissFailure,
+      clearCompleted
+    };
+    $[10] = clearCompleted;
+    $[11] = completedTransactions;
+    $[12] = counts;
+    $[13] = dismissFailure;
+    $[14] = failedTransactions;
+    $[15] = hasActivity;
+    $[16] = pendingMutations;
+    $[17] = retryAll;
+    $[18] = t4;
+  } else {
+    t4 = $[18];
+  }
+  return t4;
+}
+
+export {
+  ConflictBus,
+  PowerSyncContext,
+  SyncStatusContext,
+  ConnectionHealthContext,
+  SyncMetricsContext,
+  AttachmentQueueContext,
+  PowerSyncProvider,
+  usePowerSync,
+  useSyncStatus,
+  useSyncControl,
+  useSyncMode,
+  useConnectionHealth,
+  useSyncMetrics,
+  useAttachmentQueue,
+  useDatabase,
+  usePlatform,
+  useOnlineStatus,
+  usePendingMutations,
+  useIsSyncing,
+  useDownloadProgress,
+  useEntitySyncStatus,
+  useUploadStatus,
+  useSyncActivity
+};
+//# sourceMappingURL=chunk-GMFDCVMZ.js.map