@anfenn/dync 1.0.25 → 1.0.26

package/dist/react/index.js

@@ -1,50 +1,39 @@
-import {
-  Dync
-} from "../chunk-QA2TX54K.js";
-import "../chunk-SQB6E7V2.js";
-
-// src/react/useDync.ts
-import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
-function makeDync(config) {
-  const db = "syncApis" in config ? new Dync(config.databaseName, config.syncApis, config.storageAdapter, config.options) : new Dync(config.databaseName, config.batchSync, config.storageAdapter, config.options);
-  let cachedState = db.sync.getState();
-  const subscribe = (listener) => db.sync.onStateChange((nextState) => {
-    cachedState = nextState;
-    listener();
-  });
-  const getSnapshot = () => {
-    const fresh = db.sync.getState();
-    if (JSON.stringify(fresh) !== JSON.stringify(cachedState)) {
-      cachedState = fresh;
+// src/react/useSyncState.ts
+import { useCallback, useRef, useSyncExternalStore } from "react";
+function useSyncState(db) {
+  const cacheRef = useRef(db.sync.state);
+  const subscribe = useCallback(
+    (listener) => db.sync.onStateChange((nextState) => {
+      cacheRef.current = nextState;
+      listener();
+    }),
+    [db]
+  );
+  const getSnapshot = useCallback(() => {
+    const fresh = db.sync.state;
+    if (JSON.stringify(fresh) !== JSON.stringify(cacheRef.current)) {
+      cacheRef.current = fresh;
     }
-    return cachedState;
-  };
-  const useDync = () => {
-    const syncState = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-    return { db, syncState };
-  };
-  const boundUseLiveQuery = (querier, deps = [], tables) => {
-    return useLiveQueryImpl(db, querier, deps, tables);
-  };
-  return {
-    db,
-    useDync,
-    useLiveQuery: boundUseLiveQuery
-  };
+    return cacheRef.current;
+  }, [db]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
-function useLiveQueryImpl(db, querier, deps = [], tables) {
+
+// src/react/useLiveQuery.ts
+import { useCallback as useCallback2, useEffect, useRef as useRef2, useState } from "react";
+function useLiveQuery(db, querier, deps = [], tables) {
   const [result, setResult] = useState(void 0);
   const [, setError] = useState(null);
-  const isMountedRef = useRef(true);
-  const queryVersionRef = useRef(0);
-  const querierRef = useRef(querier);
-  const tablesRef = useRef(tables);
+  const isMountedRef = useRef2(true);
+  const queryVersionRef = useRef2(0);
+  const querierRef = useRef2(querier);
+  const tablesRef = useRef2(tables);
   querierRef.current = querier;
   tablesRef.current = tables;
-  const runQuery = useCallback(async () => {
+  const runQuery = useCallback2(async () => {
     const currentVersion = ++queryVersionRef.current;
     try {
-      const queryResult = await querierRef.current(db);
+      const queryResult = await querierRef.current();
       if (isMountedRef.current && currentVersion === queryVersionRef.current) {
         setResult(queryResult);
         setError(null);
@@ -54,7 +43,7 @@ function useLiveQueryImpl(db, querier, deps = [], tables) {
         setError(err);
       }
     }
-  }, [db]);
+  }, []);
   useEffect(() => {
     runQuery();
   }, [...deps, runQuery]);
@@ -73,6 +62,7 @@ function useLiveQueryImpl(db, querier, deps = [], tables) {
   return result;
 }
 export {
-  makeDync
+  useLiveQuery,
+  useSyncState
 };
 //# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/react/useDync.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react';\nimport { Dync } from '../index';\nimport type { ApiFunctions, BatchSync, MutationEvent, SyncOptions, SyncState } from '../types';\nimport type { StorageAdapter } from '../storage/types';\n\nexport interface MakeDyncConfigPerTable {\n    databaseName: string;\n    syncApis: Record<string, ApiFunctions>;\n    storageAdapter: StorageAdapter;\n    options?: SyncOptions;\n}\n\nexport interface MakeDyncConfigBatch {\n    databaseName: string;\n    batchSync: BatchSync;\n    storageAdapter: StorageAdapter;\n    options?: SyncOptions;\n}\n\nexport type MakeDyncConfig = MakeDyncConfigPerTable | MakeDyncConfigBatch;\n\nexport interface UseDyncValue<TStoreMap extends Record<string, any>> {\n    db: Dync<TStoreMap>;\n    syncState: SyncState;\n}\n\n/**\n * A hook returned by makeDync that observes database queries and automatically\n * re-runs them when data changes. The db instance is passed to the querier callback.\n *\n * @param querier - Function that receives db and returns query result\n * @param deps - Optional React dependency list for re-running the query\n * @param tables - Optional array of table names to watch for mutations, otherwise it's all tables\n * @returns The query result, or undefined if not yet available\n */\nexport type BoundUseLiveQuery<TStoreMap extends Record<string, any>> = <T>(\n    querier: (db: Dync<TStoreMap>) => Promise<T> | T,\n    deps?: React.DependencyList,\n    tables?: string[],\n) => T | undefined;\n\nexport interface MakeDyncResult<TStoreMap extends Record<string, any>> {\n    // The Dync database instance\n    db: Dync<TStoreMap>;\n    // Hook to get db and syncState in components\n    useDync: () => UseDyncValue<TStoreMap>;\n    // Hook for live queries - db is passed to the querier callback\n    useLiveQuery: BoundUseLiveQuery<TStoreMap>;\n}\n\nexport function makeDync<TStoreMap extends Record<string, any> = Record<string, unknown>>(config: MakeDyncConfig): MakeDyncResult<TStoreMap> {\n    // Determine which mode based on config shape\n    const db =\n        'syncApis' in config\n            ? new Dync<TStoreMap>(config.databaseName, config.syncApis, config.storageAdapter, config.options)\n            : new Dync<TStoreMap>(config.databaseName, config.batchSync, config.storageAdapter, config.options);\n\n    // Cache to provide referential stability (React requires stable references)\n    // Updated when subscription fires OR when getSnapshot detects value changes\n    let cachedState = db.sync.getState();\n\n    const subscribe = (listener: () => void) =>\n        db.sync.onStateChange((nextState) => {\n            // Update cache immediately when notified, before React calls getSnapshot\n            cachedState = nextState;\n            listener();\n        });\n\n    // getSnapshot returns cached state, but also checks for changes that happened\n    // before subscription was active (e.g., hydration during initial mount)\n    const getSnapshot = () => {\n        const fresh = db.sync.getState();\n        if (JSON.stringify(fresh) !== JSON.stringify(cachedState)) {\n            cachedState = fresh;\n        }\n        return cachedState;\n    };\n\n    const useDync = () => {\n        const syncState = useSyncExternalStore<SyncState>(subscribe, getSnapshot, getSnapshot);\n        return { db, syncState } as UseDyncValue<TStoreMap>;\n    };\n\n    // Create a bound useLiveQuery that passes db to the querier\n    const boundUseLiveQuery: BoundUseLiveQuery<TStoreMap> = <T>(\n        querier: (db: Dync<TStoreMap>) => Promise<T> | T,\n        deps: React.DependencyList = [],\n        tables?: string[],\n    ): T | undefined => {\n        return useLiveQueryImpl(db, querier, deps, tables);\n    };\n\n    return {\n        db,\n        useDync,\n        useLiveQuery: boundUseLiveQuery,\n    };\n}\n\nfunction useLiveQueryImpl<TStoreMap extends Record<string, any>, T>(\n    db: Dync<TStoreMap>,\n    querier: (db: Dync<TStoreMap>) => Promise<T> | T,\n    deps: React.DependencyList = [],\n    tables?: string[],\n): T | undefined {\n    const [result, setResult] = useState<T | undefined>(undefined);\n    const [, setError] = useState<Error | null>(null);\n    const isMountedRef = useRef(true);\n    const queryVersionRef = useRef(0);\n    const querierRef = useRef(querier);\n    const tablesRef = useRef(tables);\n\n    // Keep refs up to date\n    querierRef.current = querier;\n    tablesRef.current = tables;\n\n    const runQuery = useCallback(async () => {\n        const currentVersion = ++queryVersionRef.current;\n        try {\n            const queryResult = await querierRef.current(db);\n            // Only update if still mounted and this is the latest query\n            if (isMountedRef.current && currentVersion === queryVersionRef.current) {\n                setResult(queryResult);\n                setError(null);\n            }\n        } catch (err) {\n            if (isMountedRef.current && currentVersion === queryVersionRef.current) {\n                setError(err as Error);\n            }\n        }\n    }, [db]);\n\n    // Re-run query when deps change\n    useEffect(() => {\n        runQuery();\n    }, [...deps, runQuery]);\n\n    useEffect(() => {\n        isMountedRef.current = true;\n\n        // Subscribe to mutation events\n        const unsubscribe = db.sync.onMutation((event: MutationEvent) => {\n            // Only re-run if no tables filter specified, or if the mutation affects a watched table\n            if (!tablesRef.current || tablesRef.current.includes(event.tableName)) {\n                runQuery();\n            }\n        });\n\n        return () => {\n            isMountedRef.current = false;\n            unsubscribe();\n        };\n    }, [db, runQuery]);\n\n    return result;\n}\n"],"mappings":";;;;;;AAAA,SAAS,aAAa,WAAW,QAAQ,UAAU,4BAA4B;AAkDxE,SAAS,SAA0E,QAAmD;AAEzI,QAAM,KACF,cAAc,SACR,IAAI,KAAgB,OAAO,cAAc,OAAO,UAAU,OAAO,gBAAgB,OAAO,OAAO,IAC/F,IAAI,KAAgB,OAAO,cAAc,OAAO,WAAW,OAAO,gBAAgB,OAAO,OAAO;AAI1G,MAAI,cAAc,GAAG,KAAK,SAAS;AAEnC,QAAM,YAAY,CAAC,aACf,GAAG,KAAK,cAAc,CAAC,cAAc;AAEjC,kBAAc;AACd,aAAS;AAAA,EACb,CAAC;AAIL,QAAM,cAAc,MAAM;AACtB,UAAM,QAAQ,GAAG,KAAK,SAAS;AAC/B,QAAI,KAAK,UAAU,KAAK,MAAM,KAAK,UAAU,WAAW,GAAG;AACvD,oBAAc;AAAA,IAClB;AACA,WAAO;AAAA,EACX;AAEA,QAAM,UAAU,MAAM;AAClB,UAAM,YAAY,qBAAgC,WAAW,aAAa,WAAW;AACrF,WAAO,EAAE,IAAI,UAAU;AAAA,EAC3B;AAGA,QAAM,oBAAkD,CACpD,SACA,OAA6B,CAAC,GAC9B,WACgB;AAChB,WAAO,iBAAiB,IAAI,SAAS,MAAM,MAAM;AAAA,EACrD;AAEA,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA,cAAc;AAAA,EAClB;AACJ;AAEA,SAAS,iBACL,IACA,SACA,OAA6B,CAAC,GAC9B,QACa;AACb,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAwB,MAAS;AAC7D,QAAM,CAAC,EAAE,QAAQ,IAAI,SAAuB,IAAI;AAChD,QAAM,eAAe,OAAO,IAAI;AAChC,QAAM,kBAAkB,OAAO,CAAC;AAChC,QAAM,aAAa,OAAO,OAAO;AACjC,QAAM,YAAY,OAAO,MAAM;AAG/B,aAAW,UAAU;AACrB,YAAU,UAAU;AAEpB,QAAM,WAAW,YAAY,YAAY;AACrC,UAAM,iBAAiB,EAAE,gBAAgB;AACzC,QAAI;AACA,YAAM,cAAc,MAAM,WAAW,QAAQ,EAAE;AAE/C,UAAI,aAAa,WAAW,mBAAmB,gBAAgB,SAAS;AACpE,kBAAU,WAAW;AACrB,iBAAS,IAAI;AAAA,MACjB;AAAA,IACJ,SAAS,KAAK;AACV,UAAI,aAAa,WAAW,mBAAmB,gBAAgB,SAAS;AACpE,iBAAS,GAAY;AAAA,MACzB;AAAA,IACJ;AAAA,EACJ,GAAG,CAAC,EAAE,CAAC;AAGP,YAAU,MAAM;AACZ,aAAS;AAAA,EACb,GAAG,CAAC,GAAG,MAAM,QAAQ,CAAC;AAEtB,YAAU,MAAM;AACZ,iBAAa,UAAU;AAGvB,UAAM,cAAc,GAAG,KAAK,WAAW,CAAC,UAAyB;AAE7D,UAAI,CAAC,UAAU,WAAW,UAAU,QAAQ,SAAS,MAAM,SAAS,GAAG;AACnE,iBAAS;AAAA,MACb;AAAA,IACJ,CAAC;AAED,WAAO,MAAM;AACT,mBAAa,UAAU;AACvB,kBAAY;AAAA,IAChB;AAAA,EACJ,GAAG,CAAC,IAAI,QAAQ,CAAC;AAEjB,SAAO;AACX;","names":[]}
+{"version":3,"sources":["../../src/react/useSyncState.ts","../../src/react/useLiveQuery.ts"],"sourcesContent":["import { useCallback, useRef, useSyncExternalStore } from 'react';\nimport type { SyncState } from '../types';\nimport type { DyncLike } from './types';\n\n/**\n * React hook that subscribes to Dync sync state changes.\n * Returns the current SyncState and re-renders when it changes.\n *\n * @param db - The Dync database instance\n * @returns The current SyncState\n *\n * @example\n * ```tsx\n * import { db } from './store';\n * import { useSyncState } from '@anfenn/dync/react';\n *\n * function SyncStatus() {\n *   const syncState = useSyncState(db);\n *   return <div>Status: {syncState.status}</div>;\n * }\n * ```\n */\nexport function useSyncState(db: DyncLike): SyncState {\n    // Use refs to create stable subscribe/getSnapshot functions\n    const cacheRef = useRef<SyncState>(db.sync.state);\n\n    const subscribe = useCallback(\n        (listener: () => void) =>\n            db.sync.onStateChange((nextState) => {\n                cacheRef.current = nextState;\n                listener();\n            }),\n        [db],\n    );\n\n    const getSnapshot = useCallback(() => {\n        const fresh = db.sync.state;\n        if (JSON.stringify(fresh) !== JSON.stringify(cacheRef.current)) {\n            cacheRef.current = fresh;\n        }\n        return cacheRef.current;\n    }, [db]);\n\n    return useSyncExternalStore<SyncState>(subscribe, getSnapshot, getSnapshot);\n}\n","import { useCallback, useEffect, useRef, useState } from 'react';\nimport type { MutationEvent } from '../types';\nimport type { DyncLike } from './types';\n\n/**\n * React hook that observes database queries and automatically re-runs them when data changes.\n *\n * @param db - The Dync database instance\n * @param querier - Function that returns query result (can be async)\n * @param deps - Optional React dependency list for re-running the query\n * @param tables - Optional array of table names to watch for mutations (defaults to all tables)\n * @returns The query result, or undefined if not yet available\n *\n * @example\n * ```tsx\n * import { db } from './store';\n * import { useLiveQuery } from '@anfenn/dync/react';\n *\n * function TodoList() {\n *   const todos = useLiveQuery(db, () => db.todos.toArray());\n *   return <ul>{todos?.map(t => <li key={t._localId}>{t.title}</li>)}</ul>;\n * }\n *\n * // With dependencies\n * function FilteredTodos({ filter }: { filter: string }) {\n *   const todos = useLiveQuery(\n *     db,\n *     () => db.todos.where('status').equals(filter).toArray(),\n *     [filter]\n *   );\n *   return <ul>{todos?.map(t => <li key={t._localId}>{t.title}</li>)}</ul>;\n * }\n *\n * // Watch specific tables only\n * function TodoCount() {\n *   const count = useLiveQuery(\n *     db,\n *     () => db.todos.count(),\n *     [],\n *     ['todos']\n *   );\n *   return <span>{count ?? 0} todos</span>;\n * }\n * ```\n */\nexport function useLiveQuery<T>(db: DyncLike, querier: () => Promise<T> | T, deps: React.DependencyList = [], tables?: string[]): T | undefined {\n    const [result, setResult] = useState<T | undefined>(undefined);\n    const [, setError] = useState<Error | null>(null);\n    const isMountedRef = useRef(true);\n    const queryVersionRef = useRef(0);\n    const querierRef = useRef(querier);\n    const tablesRef = useRef(tables);\n\n    // Keep refs up to date\n    querierRef.current = querier;\n    tablesRef.current = tables;\n\n    const runQuery = useCallback(async () => {\n        const currentVersion = ++queryVersionRef.current;\n        try {\n            const queryResult = await querierRef.current();\n            // Only update if still mounted and this is the latest query\n            if (isMountedRef.current && currentVersion === queryVersionRef.current) {\n                setResult(queryResult);\n                setError(null);\n            }\n        } catch (err) {\n            if (isMountedRef.current && currentVersion === queryVersionRef.current) {\n                setError(err as Error);\n            }\n        }\n    }, []);\n\n    // Re-run query when deps change\n    useEffect(() => {\n        runQuery();\n    }, [...deps, runQuery]);\n\n    useEffect(() => {\n        isMountedRef.current = true;\n\n        // Subscribe to mutation events\n        const unsubscribe = db.sync.onMutation((event: MutationEvent) => {\n            // Only re-run if no tables filter specified, or if the mutation affects a watched table\n            if (!tablesRef.current || tablesRef.current.includes(event.tableName)) {\n                runQuery();\n            }\n        });\n\n        return () => {\n            isMountedRef.current = false;\n            unsubscribe();\n        };\n    }, [db, runQuery]);\n\n    return result;\n}\n"],"mappings":";AAAA,SAAS,aAAa,QAAQ,4BAA4B;AAsBnD,SAAS,aAAa,IAAyB;AAElD,QAAM,WAAW,OAAkB,GAAG,KAAK,KAAK;AAEhD,QAAM,YAAY;AAAA,IACd,CAAC,aACG,GAAG,KAAK,cAAc,CAAC,cAAc;AACjC,eAAS,UAAU;AACnB,eAAS;AAAA,IACb,CAAC;AAAA,IACL,CAAC,EAAE;AAAA,EACP;AAEA,QAAM,cAAc,YAAY,MAAM;AAClC,UAAM,QAAQ,GAAG,KAAK;AACtB,QAAI,KAAK,UAAU,KAAK,MAAM,KAAK,UAAU,SAAS,OAAO,GAAG;AAC5D,eAAS,UAAU;AAAA,IACvB;AACA,WAAO,SAAS;AAAA,EACpB,GAAG,CAAC,EAAE,CAAC;AAEP,SAAO,qBAAgC,WAAW,aAAa,WAAW;AAC9E;;;AC5CA,SAAS,eAAAA,cAAa,WAAW,UAAAC,SAAQ,gBAAgB;AA6ClD,SAAS,aAAgB,IAAc,SAA+B,OAA6B,CAAC,GAAG,QAAkC;AAC5I,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAwB,MAAS;AAC7D,QAAM,CAAC,EAAE,QAAQ,IAAI,SAAuB,IAAI;AAChD,QAAM,eAAeA,QAAO,IAAI;AAChC,QAAM,kBAAkBA,QAAO,CAAC;AAChC,QAAM,aAAaA,QAAO,OAAO;AACjC,QAAM,YAAYA,QAAO,MAAM;AAG/B,aAAW,UAAU;AACrB,YAAU,UAAU;AAEpB,QAAM,WAAWD,aAAY,YAAY;AACrC,UAAM,iBAAiB,EAAE,gBAAgB;AACzC,QAAI;AACA,YAAM,cAAc,MAAM,WAAW,QAAQ;AAE7C,UAAI,aAAa,WAAW,mBAAmB,gBAAgB,SAAS;AACpE,kBAAU,WAAW;AACrB,iBAAS,IAAI;AAAA,MACjB;AAAA,IACJ,SAAS,KAAK;AACV,UAAI,aAAa,WAAW,mBAAmB,gBAAgB,SAAS;AACpE,iBAAS,GAAY;AAAA,MACzB;AAAA,IACJ;AAAA,EACJ,GAAG,CAAC,CAAC;AAGL,YAAU,MAAM;AACZ,aAAS;AAAA,EACb,GAAG,CAAC,GAAG,MAAM,QAAQ,CAAC;AAEtB,YAAU,MAAM;AACZ,iBAAa,UAAU;AAGvB,UAAM,cAAc,GAAG,KAAK,WAAW,CAAC,UAAyB;AAE7D,UAAI,CAAC,UAAU,WAAW,UAAU,QAAQ,SAAS,MAAM,SAAS,GAAG;AACnE,iBAAS;AAAA,MACb;AAAA,IACJ,CAAC;AAED,WAAO,MAAM;AACT,mBAAa,UAAU;AACvB,kBAAY;AAAA,IAChB;AAAA,EACJ,GAAG,CAAC,IAAI,QAAQ,CAAC;AAEjB,SAAO;AACX;","names":["useCallback","useRef"]}

package/dist/{index.shared-D-fB8Odd.d.ts → types-B1Vn8_DF.d.ts}

@@ -1,5 +1,4 @@
-import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-DRLMKLl5.js';
-import { c as SQLiteVersionConfigurator } from './types-CSbIAfu2.js';
+import { b as StorageTable } from './dexie-B1FuZqDB.js';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -105,7 +104,8 @@ type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
 type SyncApi = {
     enable: (enabled: boolean) => Promise<void>;
     startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
-    getState: () => SyncState;
+    /** Current sync state - use useSyncState() hook for reactive updates in React */
+    readonly state: SyncState;
     resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
     onStateChange: (fn: (state: SyncState) => void) => () => void;
     onMutation: (fn: (event: MutationEvent) => void) => () => void;
@@ -155,85 +155,4 @@ type TableMap<TStoreMap extends Record<string, unknown>> = {
     [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
 };
 
-declare class DyncBase<_TStoreMap = Record<string, any>> {
-    private readonly adapter;
-    private readonly tableCache;
-    private readonly mutationWrappedTables;
-    private readonly syncEnhancedTables;
-    private readonly mutationListeners;
-    private visibilitySubscription?;
-    private openPromise?;
-    private disableSyncPromise?;
-    private disableSyncPromiseResolver?;
-    private sleepAbortController?;
-    private closing;
-    private syncApis;
-    private batchSync?;
-    private syncedTables;
-    private syncOptions;
-    private logger;
-    private syncTimerStarted;
-    private mutationsDuringSync;
-    private state;
-    readonly name: string;
-    /**
-     * Create a new Dync instance.
-     *
-     * Mode 1 - Per-table endpoints:
-     * @param databaseName - Name of the database
-     * @param syncApis - Map of table names to API functions
-     * @param storageAdapter - Storage adapter implementation (required)
-     * @param options - Sync options
-     *
-     * Mode 2 - Batch endpoints:
-     * @param databaseName - Name of the database
-     * @param batchSync - Batch sync config (syncTables, push, pull, firstLoad)
-     * @param storageAdapter - Storage adapter implementation (required)
-     * @param options - Sync options
-     */
-    constructor(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions);
-    constructor(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions);
-    version(versionNumber: number): {
-        stores(schema: Record<string, TableSchemaDefinition>): /*elided*/ any;
-        sqlite(configure: (builder: SQLiteVersionConfigurator) => void): /*elided*/ any;
-    };
-    open(): Promise<void>;
-    close(): Promise<void>;
-    delete(): Promise<void>;
-    query<R>(callback: (ctx: DexieQueryContext | SqliteQueryContext | MemoryQueryContext) => Promise<R>): Promise<R>;
-    table<K extends keyof _TStoreMap>(name: K): StorageTable<_TStoreMap[K]>;
-    table<T = any>(name: string): StorageTable<T>;
-    private withTransaction;
-    private setupEnhancedTables;
-    private injectSyncColumns;
-    private enhanceSyncTable;
-    private syncOnce;
-    private pullAll;
-    private pushAll;
-    private startSyncTimer;
-    private tryStart;
-    private setupVisibilityListener;
-    private handleVisibilityChange;
-    private startFirstLoad;
-    private getSyncState;
-    private resolveConflict;
-    private enableSync;
-    get syncStatus(): SyncStatus;
-    set syncStatus(status: SyncStatus);
-    private onSyncStateChange;
-    private onMutation;
-    private emitMutation;
-    sync: SyncApi;
-}
-type DyncInstance<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncBase<TStoreMap> & TableMap<TStoreMap> & {
-    table<K extends keyof TStoreMap & string>(name: K): StorageTable<TStoreMap[K]>;
-    table(name: string): StorageTable<any>;
-};
-declare const Dync: {
-    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
-    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
-    prototype: DyncInstance<Record<string, unknown>>;
-} & typeof DyncBase;
-type Dync<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncInstance<TStoreMap>;
-
-export { type AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, Dync as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, SyncAction as S, type TableMap as T, type ApiFunctions as a, type BatchPushPayload as b, type BatchPushResult as c, type BatchFirstLoadResult as d, type FirstLoadProgressCallback as e, type MissingRemoteRecordDuringUpdateCallback as f, type MutationEvent as g, type SyncOptions as h, type SyncState as i, type SyncedRecord as j };
+export { type ApiFunctions as A, type BatchSync as B, type ConflictResolutionStrategy as C, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncOptions as S, type TableMap as T, type SyncStatus as a, type SyncApi as b, SyncAction as c, type AfterRemoteAddCallback as d, type BatchPushPayload as e, type BatchPushResult as f, type BatchFirstLoadResult as g, type FirstLoadProgressCallback as h, type MissingRemoteRecordDuringUpdateCallback as i, type MutationEvent as j, type SyncState as k, type SyncedRecord as l };

package/dist/{index.shared-DHuT0l_t.d.cts → types-BgGGLrE9.d.cts}

@@ -1,5 +1,4 @@
-import { d as StorageTable, c as StorageAdapter, T as TableSchemaDefinition, D as DexieQueryContext, b as SqliteQueryContext, a as MemoryQueryContext } from './dexie-BqktVP7s.cjs';
-import { c as SQLiteVersionConfigurator } from './types-CSbIAfu2.cjs';
+import { b as StorageTable } from './dexie-DtgGGM68.cjs';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -105,7 +104,8 @@ type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
 type SyncApi = {
     enable: (enabled: boolean) => Promise<void>;
     startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
-    getState: () => SyncState;
+    /** Current sync state - use useSyncState() hook for reactive updates in React */
+    readonly state: SyncState;
     resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
     onStateChange: (fn: (state: SyncState) => void) => () => void;
     onMutation: (fn: (event: MutationEvent) => void) => () => void;
@@ -155,85 +155,4 @@ type TableMap<TStoreMap extends Record<string, unknown>> = {
     [K in keyof TStoreMap]: StorageTable<TStoreMap[K]>;
 };
 
-declare class DyncBase<_TStoreMap = Record<string, any>> {
-    private readonly adapter;
-    private readonly tableCache;
-    private readonly mutationWrappedTables;
-    private readonly syncEnhancedTables;
-    private readonly mutationListeners;
-    private visibilitySubscription?;
-    private openPromise?;
-    private disableSyncPromise?;
-    private disableSyncPromiseResolver?;
-    private sleepAbortController?;
-    private closing;
-    private syncApis;
-    private batchSync?;
-    private syncedTables;
-    private syncOptions;
-    private logger;
-    private syncTimerStarted;
-    private mutationsDuringSync;
-    private state;
-    readonly name: string;
-    /**
-     * Create a new Dync instance.
-     *
-     * Mode 1 - Per-table endpoints:
-     * @param databaseName - Name of the database
-     * @param syncApis - Map of table names to API functions
-     * @param storageAdapter - Storage adapter implementation (required)
-     * @param options - Sync options
-     *
-     * Mode 2 - Batch endpoints:
-     * @param databaseName - Name of the database
-     * @param batchSync - Batch sync config (syncTables, push, pull, firstLoad)
-     * @param storageAdapter - Storage adapter implementation (required)
-     * @param options - Sync options
-     */
-    constructor(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions);
-    constructor(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions);
-    version(versionNumber: number): {
-        stores(schema: Record<string, TableSchemaDefinition>): /*elided*/ any;
-        sqlite(configure: (builder: SQLiteVersionConfigurator) => void): /*elided*/ any;
-    };
-    open(): Promise<void>;
-    close(): Promise<void>;
-    delete(): Promise<void>;
-    query<R>(callback: (ctx: DexieQueryContext | SqliteQueryContext | MemoryQueryContext) => Promise<R>): Promise<R>;
-    table<K extends keyof _TStoreMap>(name: K): StorageTable<_TStoreMap[K]>;
-    table<T = any>(name: string): StorageTable<T>;
-    private withTransaction;
-    private setupEnhancedTables;
-    private injectSyncColumns;
-    private enhanceSyncTable;
-    private syncOnce;
-    private pullAll;
-    private pushAll;
-    private startSyncTimer;
-    private tryStart;
-    private setupVisibilityListener;
-    private handleVisibilityChange;
-    private startFirstLoad;
-    private getSyncState;
-    private resolveConflict;
-    private enableSync;
-    get syncStatus(): SyncStatus;
-    set syncStatus(status: SyncStatus);
-    private onSyncStateChange;
-    private onMutation;
-    private emitMutation;
-    sync: SyncApi;
-}
-type DyncInstance<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncBase<TStoreMap> & TableMap<TStoreMap> & {
-    table<K extends keyof TStoreMap & string>(name: K): StorageTable<TStoreMap[K]>;
-    table(name: string): StorageTable<any>;
-};
-declare const Dync: {
-    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
-    new <TStoreMap extends Record<string, unknown> = Record<string, unknown>>(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions): DyncInstance<TStoreMap>;
-    prototype: DyncInstance<Record<string, unknown>>;
-} & typeof DyncBase;
-type Dync<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncInstance<TStoreMap>;
-
-export { type AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, Dync as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, SyncAction as S, type TableMap as T, type ApiFunctions as a, type BatchPushPayload as b, type BatchPushResult as c, type BatchFirstLoadResult as d, type FirstLoadProgressCallback as e, type MissingRemoteRecordDuringUpdateCallback as f, type MutationEvent as g, type SyncOptions as h, type SyncState as i, type SyncedRecord as j };
+export { type ApiFunctions as A, type BatchSync as B, type ConflictResolutionStrategy as C, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncOptions as S, type TableMap as T, type SyncStatus as a, type SyncApi as b, SyncAction as c, type AfterRemoteAddCallback as d, type BatchPushPayload as e, type BatchPushResult as f, type BatchFirstLoadResult as g, type FirstLoadProgressCallback as h, type MissingRemoteRecordDuringUpdateCallback as i, type MutationEvent as j, type SyncState as k, type SyncedRecord as l };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anfenn/dync",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "private": false,
   "description": "Write once, run IndexedDB & SQLite with sync anywhere - React, React Native, Expo, Capacitor, Electron & Node.js",
   "keywords": [

package/src/index.shared.ts

@@ -107,6 +107,12 @@ class DyncBase<_TStoreMap = Record<string, any>> {
             storageAdapter: this.adapter,
         });
 
+        // Define state getter on sync object (can't use getter syntax in object literal with proper `this` binding)
+        Object.defineProperty(this.sync, 'state', {
+            get: () => this.getSyncState(),
+            enumerable: true,
+        });
+
         const driverInfo = 'driverType' in this.adapter ? ` (Driver: ${this.adapter.driverType})` : '';
         this.logger.debug(`[dync] Initialized with ${this.adapter.type}${driverInfo}`);
     }
@@ -577,7 +583,7 @@ class DyncBase<_TStoreMap = Record<string, any>> {
     sync: SyncApi = {
         enable: this.enableSync.bind(this),
         startFirstLoad: this.startFirstLoad.bind(this),
-        getState: this.getSyncState.bind(this),
+        state: undefined as unknown as SyncState, // getter in constructor
         resolveConflict: this.resolveConflict.bind(this),
         onStateChange: this.onSyncStateChange.bind(this),
         onMutation: this.onMutation.bind(this),

package/src/react/index.ts

@@ -1,2 +1,3 @@
-export { makeDync } from './useDync';
-export type { BoundUseLiveQuery, MakeDyncConfig, MakeDyncConfigBatch, MakeDyncConfigPerTable, MakeDyncResult, UseDyncValue } from './useDync';
+export { useSyncState } from './useSyncState';
+export { useLiveQuery } from './useLiveQuery';
+export type { DyncLike } from './types';

package/src/react/types.ts

@@ -0,0 +1,6 @@
+import type { SyncApi } from '../types';
+
+/** Minimal database interface for React hooks */
+export interface DyncLike {
+    sync: Pick<SyncApi, 'state' | 'onStateChange' | 'onMutation'>;
+}

package/src/react/useLiveQuery.ts

@@ -0,0 +1,97 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { MutationEvent } from '../types';
+import type { DyncLike } from './types';
+
+/**
+ * React hook that observes database queries and automatically re-runs them when data changes.
+ *
+ * @param db - The Dync database instance
+ * @param querier - Function that returns query result (can be async)
+ * @param deps - Optional React dependency list for re-running the query
+ * @param tables - Optional array of table names to watch for mutations (defaults to all tables)
+ * @returns The query result, or undefined if not yet available
+ *
+ * @example
+ * ```tsx
+ * import { db } from './store';
+ * import { useLiveQuery } from '@anfenn/dync/react';
+ *
+ * function TodoList() {
+ *   const todos = useLiveQuery(db, () => db.todos.toArray());
+ *   return <ul>{todos?.map(t => <li key={t._localId}>{t.title}</li>)}</ul>;
+ * }
+ *
+ * // With dependencies
+ * function FilteredTodos({ filter }: { filter: string }) {
+ *   const todos = useLiveQuery(
+ *     db,
+ *     () => db.todos.where('status').equals(filter).toArray(),
+ *     [filter]
+ *   );
+ *   return <ul>{todos?.map(t => <li key={t._localId}>{t.title}</li>)}</ul>;
+ * }
+ *
+ * // Watch specific tables only
+ * function TodoCount() {
+ *   const count = useLiveQuery(
+ *     db,
+ *     () => db.todos.count(),
+ *     [],
+ *     ['todos']
+ *   );
+ *   return <span>{count ?? 0} todos</span>;
+ * }
+ * ```
+ */
+export function useLiveQuery<T>(db: DyncLike, querier: () => Promise<T> | T, deps: React.DependencyList = [], tables?: string[]): T | undefined {
+    const [result, setResult] = useState<T | undefined>(undefined);
+    const [, setError] = useState<Error | null>(null);
+    const isMountedRef = useRef(true);
+    const queryVersionRef = useRef(0);
+    const querierRef = useRef(querier);
+    const tablesRef = useRef(tables);
+
+    // Keep refs up to date
+    querierRef.current = querier;
+    tablesRef.current = tables;
+
+    const runQuery = useCallback(async () => {
+        const currentVersion = ++queryVersionRef.current;
+        try {
+            const queryResult = await querierRef.current();
+            // Only update if still mounted and this is the latest query
+            if (isMountedRef.current && currentVersion === queryVersionRef.current) {
+                setResult(queryResult);
+                setError(null);
+            }
+        } catch (err) {
+            if (isMountedRef.current && currentVersion === queryVersionRef.current) {
+                setError(err as Error);
+            }
+        }
+    }, []);
+
+    // Re-run query when deps change
+    useEffect(() => {
+        runQuery();
+    }, [...deps, runQuery]);
+
+    useEffect(() => {
+        isMountedRef.current = true;
+
+        // Subscribe to mutation events
+        const unsubscribe = db.sync.onMutation((event: MutationEvent) => {
+            // Only re-run if no tables filter specified, or if the mutation affects a watched table
+            if (!tablesRef.current || tablesRef.current.includes(event.tableName)) {
+                runQuery();
+            }
+        });
+
+        return () => {
+            isMountedRef.current = false;
+            unsubscribe();
+        };
+    }, [db, runQuery]);
+
+    return result;
+}

package/src/react/useSyncState.ts

@@ -0,0 +1,45 @@
+import { useCallback, useRef, useSyncExternalStore } from 'react';
+import type { SyncState } from '../types';
+import type { DyncLike } from './types';
+
+/**
+ * React hook that subscribes to Dync sync state changes.
+ * Returns the current SyncState and re-renders when it changes.
+ *
+ * @param db - The Dync database instance
+ * @returns The current SyncState
+ *
+ * @example
+ * ```tsx
+ * import { db } from './store';
+ * import { useSyncState } from '@anfenn/dync/react';
+ *
+ * function SyncStatus() {
+ *   const syncState = useSyncState(db);
+ *   return <div>Status: {syncState.status}</div>;
+ * }
+ * ```
+ */
+export function useSyncState(db: DyncLike): SyncState {
+    // Use refs to create stable subscribe/getSnapshot functions
+    const cacheRef = useRef<SyncState>(db.sync.state);
+
+    const subscribe = useCallback(
+        (listener: () => void) =>
+            db.sync.onStateChange((nextState) => {
+                cacheRef.current = nextState;
+                listener();
+            }),
+        [db],
+    );
+
+    const getSnapshot = useCallback(() => {
+        const fresh = db.sync.state;
+        if (JSON.stringify(fresh) !== JSON.stringify(cacheRef.current)) {
+            cacheRef.current = fresh;
+        }
+        return cacheRef.current;
+    }, [db]);
+
+    return useSyncExternalStore<SyncState>(subscribe, getSnapshot, getSnapshot);
+}

package/src/types.ts

@@ -134,7 +134,8 @@ export type FirstLoadProgressCallback = (progress: FirstLoadProgress) => void;
 export type SyncApi = {
     enable: (enabled: boolean) => Promise<void>;
     startFirstLoad: (onProgress?: FirstLoadProgressCallback) => Promise<void>;
-    getState: () => SyncState;
+    /** Current sync state - use useSyncState() hook for reactive updates in React */
+    readonly state: SyncState;
     resolveConflict: (localId: string, keepLocal: boolean) => Promise<void>;
     onStateChange: (fn: (state: SyncState) => void) => () => void;
     onMutation: (fn: (event: MutationEvent) => void) => () => void;