@fatagnus/dink-sync 1.0.0

package/dist/react/useSyncRejected.js

@@ -0,0 +1,55 @@
+/**
+ * useSyncRejected - React hook for handling sync rejection events.
+ */
+import { useEffect, useRef } from 'react';
+import { SyncErrorCode } from '../client/types.js';
+/**
+ * Subscribe to sync rejection events from a collection.
+ *
+ * @param collection - The collection to listen for rejections
+ * @param options - Callbacks for handling different rejection types
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const tasks = client.collection<Task>('tasks');
+ *
+ *   useSyncRejected(tasks, {
+ *     onRejected: (event) => {
+ *       toast.error(`Failed to sync: ${event.error.message}`);
+ *     },
+ *     onUniqueViolation: (event, field) => {
+ *       toast.error(`Duplicate ${field || 'value'} detected`);
+ *     },
+ *   });
+ *
+ *   // ... rest of component
+ * }
+ * ```
+ */
+export function useSyncRejected(collection, options) {
+    // Use refs to avoid re-subscribing when callbacks change
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    useEffect(() => {
+        const unsubscribe = collection.onSyncRejected((event) => {
+            const opts = optionsRef.current;
+            // Call general handler
+            opts.onRejected?.(event);
+            // Call specific handlers based on error code
+            switch (event.error.code) {
+                case SyncErrorCode.UniqueViolation:
+                    opts.onUniqueViolation?.(event, event.error.field);
+                    break;
+                case SyncErrorCode.ValidationError:
+                    opts.onValidationError?.(event);
+                    break;
+                case SyncErrorCode.PermissionDenied:
+                    opts.onPermissionDenied?.(event);
+                    break;
+            }
+        });
+        return unsubscribe;
+    }, [collection]);
+}
+//# sourceMappingURL=useSyncRejected.js.map

package/dist/react/useSyncRejected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncRejected.js","sourceRoot":"","sources":["../../src/react/useSyncRejected.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EAAE,aAAa,EAA2C,MAAM,oBAAoB,CAAC;AAgB5F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,eAAe,CAC7B,UAAyB,EACzB,OAAkC;IAElC,yDAAyD;IACzD,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IACnC,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC;IAE7B,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,WAAW,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC,KAAK,EAAE,EAAE;YACtD,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC;YAEhC,uBAAuB;YACvB,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC;YAEzB,6CAA6C;YAC7C,QAAQ,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;gBACzB,KAAK,aAAa,CAAC,eAAe;oBAChC,IAAI,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBACnD,MAAM;gBACR,KAAK,aAAa,CAAC,eAAe;oBAChC,IAAI,CAAC,iBAAiB,EAAE,CAAC,KAAK,CAAC,CAAC;oBAChC,MAAM;gBACR,KAAK,aAAa,CAAC,gBAAgB;oBACjC,IAAI,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,CAAC;oBACjC,MAAM;YACV,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,WAAW,CAAC;IACrB,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;AACnB,CAAC"}

package/dist/react/useSyncStatus.d.ts

@@ -0,0 +1,56 @@
+/**
+ * useSyncStatus - React hook for accessing sync status from a SyncedDocument.
+ *
+ * This hook provides a convenient way to access sync status with derived boolean flags.
+ */
+import { SyncStatus, type SyncError, type SyncedDocument } from '../client/types.js';
+/**
+ * Result of useSyncStatus hook with derived boolean flags.
+ */
+export interface SyncStatusResult {
+    /** Current sync status */
+    readonly status: SyncStatus;
+    /** True if document has not been synced yet (local only) */
+    readonly isLocal: boolean;
+    /** True if document is currently being synced */
+    readonly isSyncing: boolean;
+    /** True if document is synced with server */
+    readonly isSynced: boolean;
+    /** True if sync was rejected by server */
+    readonly isRejected: boolean;
+    /** True if document has pending changes (local or syncing) */
+    readonly isPending: boolean;
+    /** Error details if sync was rejected */
+    readonly error?: SyncError;
+    /** Timestamp of last sync attempt */
+    readonly lastSyncAttempt?: number;
+    /** Timestamp of last successful sync */
+    readonly lastSynced?: number;
+    /** Number of retry attempts */
+    readonly retryCount: number;
+}
+/**
+ * Extract sync status from a SyncedDocument with derived boolean flags.
+ *
+ * @param document - A document with sync metadata (_sync property)
+ * @returns Sync status with convenience boolean flags
+ *
+ * @example
+ * ```tsx
+ * function TaskItem({ task }: { task: SyncedDocument<Task> }) {
+ *   const { isPending, isRejected, error } = useSyncStatus(task);
+ *
+ *   return (
+ *     <div className={isRejected ? 'border-red-500' : ''}>
+ *       <span>{task.title}</span>
+ *       {isPending && <Spinner className="ml-2" />}
+ *       {isRejected && <span className="text-red-500">{error?.message}</span>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSyncStatus<T extends {
+    id: string;
+}>(document: SyncedDocument<T> | null | undefined): SyncStatusResult;
+//# sourceMappingURL=useSyncStatus.d.ts.map

package/dist/react/useSyncStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncStatus.d.ts","sourceRoot":"","sources":["../../src/react/useSyncStatus.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yCAAyC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,qCAAqC;IACrC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,wCAAwC;IACxC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,+BAA+B;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EACpD,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,GAC7C,gBAAgB,CA+BlB"}

package/dist/react/useSyncStatus.js

@@ -0,0 +1,59 @@
+/**
+ * useSyncStatus - React hook for accessing sync status from a SyncedDocument.
+ *
+ * This hook provides a convenient way to access sync status with derived boolean flags.
+ */
+import { useMemo } from 'react';
+import { SyncStatus } from '../client/types.js';
+/**
+ * Extract sync status from a SyncedDocument with derived boolean flags.
+ *
+ * @param document - A document with sync metadata (_sync property)
+ * @returns Sync status with convenience boolean flags
+ *
+ * @example
+ * ```tsx
+ * function TaskItem({ task }: { task: SyncedDocument<Task> }) {
+ *   const { isPending, isRejected, error } = useSyncStatus(task);
+ *
+ *   return (
+ *     <div className={isRejected ? 'border-red-500' : ''}>
+ *       <span>{task.title}</span>
+ *       {isPending && <Spinner className="ml-2" />}
+ *       {isRejected && <span className="text-red-500">{error?.message}</span>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useSyncStatus(document) {
+    return useMemo(() => {
+        if (!document || !document._sync) {
+            // Return default "synced" state for missing documents
+            return {
+                status: SyncStatus.Synced,
+                isLocal: false,
+                isSyncing: false,
+                isSynced: true,
+                isRejected: false,
+                isPending: false,
+                retryCount: 0,
+            };
+        }
+        const sync = document._sync;
+        const status = sync.status;
+        return {
+            status,
+            isLocal: status === SyncStatus.Local,
+            isSyncing: status === SyncStatus.Syncing,
+            isSynced: status === SyncStatus.Synced,
+            isRejected: status === SyncStatus.Rejected,
+            isPending: status === SyncStatus.Local || status === SyncStatus.Syncing,
+            error: sync.error,
+            lastSyncAttempt: sync.lastSyncAttempt,
+            lastSynced: sync.lastSynced,
+            retryCount: sync.retryCount ?? 0,
+        };
+    }, [document?._sync?.status, document?._sync?.error, document?._sync?.lastSyncAttempt, document?._sync?.lastSynced, document?._sync?.retryCount]);
+}
+//# sourceMappingURL=useSyncStatus.js.map

package/dist/react/useSyncStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncStatus.js","sourceRoot":"","sources":["../../src/react/useSyncStatus.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,UAAU,EAAuC,MAAM,oBAAoB,CAAC;AA4BrF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAC3B,QAA8C;IAE9C,OAAO,OAAO,CAAC,GAAG,EAAE;QAClB,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACjC,sDAAsD;YACtD,OAAO;gBACL,MAAM,EAAE,UAAU,CAAC,MAAM;gBACzB,OAAO,EAAE,KAAK;gBACd,SAAS,EAAE,KAAK;gBAChB,QAAQ,EAAE,IAAI;gBACd,UAAU,EAAE,KAAK;gBACjB,SAAS,EAAE,KAAK;gBAChB,UAAU,EAAE,CAAC;aACd,CAAC;QACJ,CAAC;QAED,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAE3B,OAAO;YACL,MAAM;YACN,OAAO,EAAE,MAAM,KAAK,UAAU,CAAC,KAAK;YACpC,SAAS,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO;YACxC,QAAQ,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM;YACtC,UAAU,EAAE,MAAM,KAAK,UAAU,CAAC,QAAQ;YAC1C,SAAS,EAAE,MAAM,KAAK,UAAU,CAAC,KAAK,IAAI,MAAM,KAAK,UAAU,CAAC,OAAO;YACvE,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,CAAC;SACjC,CAAC;IACJ,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;AACpJ,CAAC"}

package/dist/react/useSyncedOfflineEdge.d.ts

@@ -0,0 +1,69 @@
+/**
+ * useSyncedOfflineEdge - React hook to access the SyncedOfflineEdge from context.
+ *
+ * This hook provides access to the full SyncedOfflineEdge instance and its initialization state.
+ * Must be used within a SyncedOfflineEdgeProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useSyncedOfflineEdge } from '@fatagnus/dink-sync/react';
+ *
+ * function MyComponent() {
+ *   const { edge, isLoading, isReady, error } = useSyncedOfflineEdge();
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!isReady || !edge) return null;
+ *
+ *   const tasks = edge.collection<Task>('tasks');
+ *   // Use tasks collection with full sync capabilities...
+ * }
+ * ```
+ */
+import type { SyncedOfflineEdge } from '../client/synced-offline-edge-types.js';
+/**
+ * Result of useSyncedOfflineEdge hook.
+ */
+export interface UseSyncedOfflineEdgeResult {
+    /** The initialized SyncedOfflineEdge, or null if not yet ready */
+    edge: SyncedOfflineEdge | null;
+    /** True while initializing */
+    isLoading: boolean;
+    /** True when edge is ready to use */
+    isReady: boolean;
+    /** Error if initialization failed */
+    error: Error | null;
+}
+/**
+ * Hook to access the full SyncedOfflineEdge context state.
+ *
+ * Returns loading state, error state, and the edge instance when ready.
+ * The edge provides access to typed collections with full sync capabilities.
+ *
+ * @throws Error if used outside of SyncedOfflineEdgeProvider
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const { edge, isLoading, isReady, error } = useSyncedOfflineEdge();
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!isReady || !edge) return null;
+ *
+ *   // Get a typed collection with sync capabilities
+ *   const tasks = edge.collection<Task>('tasks');
+ *
+ *   // Access sync control methods
+ *   const syncMode = edge.getSyncMode('tasks');
+ *   edge.setSyncMode('tasks', 'manual');
+ *
+ *   // Manual sync control
+ *   await edge.flush('tasks');
+ *   edge.pause();
+ *   edge.resume();
+ * }
+ * ```
+ */
+export declare function useSyncedOfflineEdge(): UseSyncedOfflineEdgeResult;
+//# sourceMappingURL=useSyncedOfflineEdge.d.ts.map

package/dist/react/useSyncedOfflineEdge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncedOfflineEdge.d.ts","sourceRoot":"","sources":["../../src/react/useSyncedOfflineEdge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC/B,8BAA8B;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,qCAAqC;IACrC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,IAAI,0BAA0B,CAQjE"}

package/dist/react/useSyncedOfflineEdge.js

@@ -0,0 +1,65 @@
+/**
+ * useSyncedOfflineEdge - React hook to access the SyncedOfflineEdge from context.
+ *
+ * This hook provides access to the full SyncedOfflineEdge instance and its initialization state.
+ * Must be used within a SyncedOfflineEdgeProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useSyncedOfflineEdge } from '@fatagnus/dink-sync/react';
+ *
+ * function MyComponent() {
+ *   const { edge, isLoading, isReady, error } = useSyncedOfflineEdge();
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!isReady || !edge) return null;
+ *
+ *   const tasks = edge.collection<Task>('tasks');
+ *   // Use tasks collection with full sync capabilities...
+ * }
+ * ```
+ */
+import { useContext } from 'react';
+// Import the context from SyncedOfflineEdgeProvider
+// We use a lazy import pattern to avoid circular dependencies
+import { SyncedOfflineEdgeContext } from './SyncedOfflineEdgeProvider.js';
+/**
+ * Hook to access the full SyncedOfflineEdge context state.
+ *
+ * Returns loading state, error state, and the edge instance when ready.
+ * The edge provides access to typed collections with full sync capabilities.
+ *
+ * @throws Error if used outside of SyncedOfflineEdgeProvider
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const { edge, isLoading, isReady, error } = useSyncedOfflineEdge();
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!isReady || !edge) return null;
+ *
+ *   // Get a typed collection with sync capabilities
+ *   const tasks = edge.collection<Task>('tasks');
+ *
+ *   // Access sync control methods
+ *   const syncMode = edge.getSyncMode('tasks');
+ *   edge.setSyncMode('tasks', 'manual');
+ *
+ *   // Manual sync control
+ *   await edge.flush('tasks');
+ *   edge.pause();
+ *   edge.resume();
+ * }
+ * ```
+ */
+export function useSyncedOfflineEdge() {
+    const context = useContext(SyncedOfflineEdgeContext);
+    if (context === null) {
+        throw new Error('useSyncedOfflineEdge must be used within a SyncedOfflineEdgeProvider');
+    }
+    return context;
+}
+//# sourceMappingURL=useSyncedOfflineEdge.js.map

package/dist/react/useSyncedOfflineEdge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncedOfflineEdge.js","sourceRoot":"","sources":["../../src/react/useSyncedOfflineEdge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAiBnC,oDAAoD;AACpD,8DAA8D;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,oBAAoB;IAClC,MAAM,OAAO,GAAG,UAAU,CAAC,wBAAwB,CAAC,CAAC;IAErD,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAC;IAC1F,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/service-worker/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Service Worker Background Sync module
+ *
+ * Provides background sync capabilities for offline-first applications.
+ */
+export { BackgroundSyncManager, SyncWorkerHandler, SyncWorkerMessageType, createSyncWorkerScript, registerSyncWorker, getBackgroundSyncManager, DEFAULT_SYNC_TAG, DEFAULT_PERIODIC_SYNC_TAG, DEFAULT_PERIODIC_SYNC_INTERVAL, type SyncWorkerMessage, type SyncWorkerMessageEvent, type SyncEvent, type PeriodicSyncEvent, type SyncWorkerScriptConfig, type Unsubscribe, } from './sync-worker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/service-worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/service-worker/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EACzB,8BAA8B,EAC9B,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,GACjB,MAAM,kBAAkB,CAAC"}

package/dist/service-worker/index.js

@@ -0,0 +1,7 @@
+/**
+ * Service Worker Background Sync module
+ *
+ * Provides background sync capabilities for offline-first applications.
+ */
+export { BackgroundSyncManager, SyncWorkerHandler, SyncWorkerMessageType, createSyncWorkerScript, registerSyncWorker, getBackgroundSyncManager, DEFAULT_SYNC_TAG, DEFAULT_PERIODIC_SYNC_TAG, DEFAULT_PERIODIC_SYNC_INTERVAL, } from './sync-worker.js';
+//# sourceMappingURL=index.js.map

package/dist/service-worker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/service-worker/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EACzB,8BAA8B,GAO/B,MAAM,kBAAkB,CAAC"}

package/dist/service-worker/sync-worker.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Service Worker Background Sync for Dink Offline-First SDK
+ *
+ * Provides:
+ * - Background Sync API registration for one-time sync when online
+ * - Periodic Background Sync for regular sync intervals
+ * - Fallback interval-based sync for browsers without Background Sync
+ * - Message passing between main thread and service worker
+ * - IndexedDB access for pending queue in service worker context
+ */
+/**
+ * Service Worker ExtendableMessageEvent type
+ * Using a local interface to avoid conflicts with DOM lib types
+ */
+export interface SyncWorkerMessageEvent {
+    readonly data: unknown;
+    readonly source: {
+        postMessage: (message: unknown) => void;
+    } | null;
+}
+/**
+ * Message types for communication between main thread and service worker
+ */
+export declare const SyncWorkerMessageType: {
+    /** Request sync from main thread */
+    readonly SYNC_REQUEST: "SYNC_REQUEST";
+    /** Sync completed successfully */
+    readonly SYNC_COMPLETE: "SYNC_COMPLETE";
+    /** Sync failed with error */
+    readonly SYNC_ERROR: "SYNC_ERROR";
+    /** Notify worker of pending changes count */
+    readonly PENDING_CHANGES: "PENDING_CHANGES";
+    /** Request to register a sync tag */
+    readonly REGISTER_SYNC: "REGISTER_SYNC";
+};
+export type SyncWorkerMessageType = typeof SyncWorkerMessageType[keyof typeof SyncWorkerMessageType];
+/**
+ * Message structure for worker communication
+ */
+export interface SyncWorkerMessage {
+    type: SyncWorkerMessageType;
+    payload: Record<string, unknown>;
+}
+/**
+ * Unsubscribe function type
+ */
+export type Unsubscribe = () => void;
+/**
+ * Sync event from Background Sync API
+ */
+export interface SyncEvent {
+    tag: string;
+    waitUntil?: (promise: Promise<unknown>) => void;
+    lastChance: boolean;
+}
+/**
+ * Periodic sync event
+ */
+export interface PeriodicSyncEvent {
+    tag: string;
+}
+/**
+ * BackgroundSyncManager - Main thread API for Background Sync
+ *
+ * Manages registration of background sync events and provides
+ * fallback for browsers without Background Sync support.
+ */
+export declare class BackgroundSyncManager {
+    private registration;
+    private fallbackTimer;
+    private fallbackHandler;
+    constructor(registration: ServiceWorkerRegistration);
+    /**
+     * Check if Background Sync API is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Check if Periodic Background Sync API is supported
+     */
+    isPeriodicSyncSupported(): boolean;
+    /**
+     * Request a one-time background sync
+     * @param tag - Unique tag to identify this sync
+     * @returns true if registration succeeded, false otherwise
+     */
+    requestSync(tag: string): Promise<boolean>;
+    /**
+     * Request periodic background sync
+     * @param tag - Unique tag to identify this periodic sync
+     * @param minInterval - Minimum interval between syncs in milliseconds
+     * @returns true if registration succeeded, false otherwise
+     */
+    requestPeriodicSync(tag: string, minInterval: number): Promise<boolean>;
+    /**
+     * Unregister a periodic background sync
+     * @param tag - Tag of the periodic sync to unregister
+     */
+    unregisterPeriodicSync(tag: string): Promise<void>;
+    /**
+     * Get all active sync tags
+     * @returns Array of active sync tags
+     */
+    getActiveSyncTags(): Promise<string[]>;
+    /**
+     * Set the fallback sync handler for browsers without Background Sync
+     * @param handler - Async function to call for sync
+     */
+    setFallbackSyncHandler(handler: () => Promise<void>): void;
+    /**
+     * Start fallback interval-based sync
+     * Only activates if Background Sync is not supported
+     * @param intervalMs - Sync interval in milliseconds
+     */
+    startFallbackSync(intervalMs: number): void;
+    /**
+     * Stop fallback interval-based sync
+     */
+    stopFallbackSync(): void;
+    /**
+     * Post a message to the service worker
+     * @param message - Message to send
+     */
+    postMessage(message: SyncWorkerMessage): void;
+}
+/**
+ * SyncWorkerHandler - Service Worker side handler
+ *
+ * Handles sync events and messages in the service worker context.
+ */
+export declare class SyncWorkerHandler {
+    private syncHandler;
+    private periodicSyncHandler;
+    private tagPrefix;
+    private errorCallbacks;
+    private lastChanceCallbacks;
+    /**
+     * Set the tag prefix for filtering sync events
+     * @param prefix - Only handle sync events with tags starting with this prefix
+     */
+    setTagPrefix(prefix: string): void;
+    /**
+     * Set the sync handler function
+     * @param handler - Async function to call when sync event fires
+     */
+    setSyncHandler(handler: (tag: string) => Promise<void>): void;
+    /**
+     * Set the periodic sync handler function
+     * @param handler - Async function to call when periodic sync event fires
+     */
+    setPeriodicSyncHandler(handler: (tag: string) => Promise<void>): void;
+    /**
+     * Handle a sync event from the Background Sync API
+     * @param event - Sync event
+     */
+    handleSyncEvent(event: SyncEvent): Promise<void>;
+    /**
+     * Handle a periodic sync event
+     * @param event - Periodic sync event
+     */
+    handlePeriodicSyncEvent(event: PeriodicSyncEvent): Promise<void>;
+    /**
+     * Handle a message from the main thread
+     * @param event - Message event
+     */
+    handleMessage(event: SyncWorkerMessageEvent): Promise<void>;
+    /**
+     * Subscribe to error events
+     * @param callback - Function to call when an error occurs
+     * @returns Unsubscribe function
+     */
+    onError(callback: (error: Error) => void): Unsubscribe;
+    /**
+     * Subscribe to last chance events
+     * Called when a sync fails and it's the browser's last attempt
+     * @param callback - Function to call on last chance
+     * @returns Unsubscribe function
+     */
+    onLastChance(callback: (tag: string) => void): Unsubscribe;
+}
+/**
+ * Configuration for generating a service worker script
+ */
+export interface SyncWorkerScriptConfig {
+    /** Tag for one-time sync events */
+    syncTag: string;
+    /** Tag for periodic sync events (optional) */
+    periodicSyncTag?: string;
+    /** IndexedDB database name for pending queue */
+    dbName: string;
+    /** Store name within IndexedDB */
+    storeName?: string;
+}
+/**
+ * Generate a service worker script string for background sync
+ *
+ * This generates a self-contained service worker script that can be
+ * registered to handle background sync events and access IndexedDB
+ * for the pending queue.
+ *
+ * @param config - Configuration for the script
+ * @returns Service worker script as a string
+ */
+export declare function createSyncWorkerScript(config: SyncWorkerScriptConfig): string;
+/**
+ * Register the background sync service worker
+ *
+ * @param scriptUrl - URL of the service worker script
+ * @param options - Registration options
+ * @returns BackgroundSyncManager instance
+ */
+export declare function registerSyncWorker(scriptUrl: string, options?: RegistrationOptions): Promise<BackgroundSyncManager>;
+/**
+ * Get the BackgroundSyncManager for an existing service worker
+ *
+ * @returns BackgroundSyncManager instance or null if no service worker
+ */
+export declare function getBackgroundSyncManager(): Promise<BackgroundSyncManager | null>;
+/**
+ * Default sync tag for Dink background sync
+ */
+export declare const DEFAULT_SYNC_TAG = "dink-sync";
+/**
+ * Default periodic sync tag for Dink background sync
+ */
+export declare const DEFAULT_PERIODIC_SYNC_TAG = "dink-periodic-sync";
+/**
+ * Default minimum interval for periodic sync (1 hour)
+ */
+export declare const DEFAULT_PERIODIC_SYNC_INTERVAL: number;
+//# sourceMappingURL=sync-worker.d.ts.map

package/dist/service-worker/sync-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-worker.d.ts","sourceRoot":"","sources":["../../src/service-worker/sync-worker.ts"],"names":[],"mappings":"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"}