@anfenn/dync 1.0.25 → 1.0.27

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-BLw25Wlc.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 { d as StorageAdapter, a as StorageTable } from './dexie-BFPA0JU2.js';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -95,6 +94,38 @@ interface SyncOptions {
     onAfterMissingRemoteRecordDuringUpdate?: MissingRemoteRecordDuringUpdateCallback;
     conflictResolutionStrategy?: ConflictResolutionStrategy;
 }
+/**
+ * Configuration options for creating a Dync instance.
+ *
+ * @example Per-table sync mode
+ * ```ts
+ * const db = new Dync<Store>({
+ *     databaseName: 'my-app',
+ *     storageAdapter: new SQLiteAdapter(driver),
+ *     sync: { todos: todoSyncApi },
+ * });
+ * ```
+ *
+ * @example Batch sync mode
+ * ```ts
+ * const db = new Dync<Store>({
+ *     databaseName: 'my-app',
+ *     storageAdapter: new SQLiteAdapter(driver),
+ *     sync: { syncTables: ['todos'], push, pull },
+ * });
+ * ```
+ */
+interface DyncOptions<TStoreMap extends Record<string, any> = Record<string, any>> {
+    databaseName: string;
+    storageAdapter: StorageAdapter;
+    /**
+     * Sync configuration - either per-table APIs or batch sync.
+     * Per-table: `{ tableName: { add, update, remove, list } }`
+     * Batch: `{ syncTables: [...], push, pull }`
+     */
+    sync: Partial<Record<keyof TStoreMap, ApiFunctions>> | BatchSync;
+    options?: SyncOptions;
+}
 interface FirstLoadProgress {
     table: string;
     inserted: number;
@@ -105,7 +136,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;
@@ -151,89 +183,8 @@ interface FieldConflict {
     localValue: any;
     remoteValue: any;
 }
-type TableMap<TStoreMap extends Record<string, unknown>> = {
+type TableMap<TStoreMap extends Record<string, any>> = {
     [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 AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, type DyncOptions as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncStatus as S, type TableMap as T, type SyncApi as a, SyncAction as b, type ApiFunctions as c, type BatchPushPayload as d, type BatchPushResult as e, type BatchFirstLoadResult as f, type FirstLoadProgressCallback as g, type MissingRemoteRecordDuringUpdateCallback as h, type MutationEvent as i, type SyncOptions as j, type SyncState as k, type SyncedRecord as l };

package/dist/{index.shared-DHuT0l_t.d.cts → types-yJuzCcux.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 { d as StorageAdapter, a as StorageTable } from './dexie-T9m1mP1h.cjs';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -95,6 +94,38 @@ interface SyncOptions {
     onAfterMissingRemoteRecordDuringUpdate?: MissingRemoteRecordDuringUpdateCallback;
     conflictResolutionStrategy?: ConflictResolutionStrategy;
 }
+/**
+ * Configuration options for creating a Dync instance.
+ *
+ * @example Per-table sync mode
+ * ```ts
+ * const db = new Dync<Store>({
+ *     databaseName: 'my-app',
+ *     storageAdapter: new SQLiteAdapter(driver),
+ *     sync: { todos: todoSyncApi },
+ * });
+ * ```
+ *
+ * @example Batch sync mode
+ * ```ts
+ * const db = new Dync<Store>({
+ *     databaseName: 'my-app',
+ *     storageAdapter: new SQLiteAdapter(driver),
+ *     sync: { syncTables: ['todos'], push, pull },
+ * });
+ * ```
+ */
+interface DyncOptions<TStoreMap extends Record<string, any> = Record<string, any>> {
+    databaseName: string;
+    storageAdapter: StorageAdapter;
+    /**
+     * Sync configuration - either per-table APIs or batch sync.
+     * Per-table: `{ tableName: { add, update, remove, list } }`
+     * Batch: `{ syncTables: [...], push, pull }`
+     */
+    sync: Partial<Record<keyof TStoreMap, ApiFunctions>> | BatchSync;
+    options?: SyncOptions;
+}
 interface FirstLoadProgress {
     table: string;
     inserted: number;
@@ -105,7 +136,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;
@@ -151,89 +183,8 @@ interface FieldConflict {
     localValue: any;
     remoteValue: any;
 }
-type TableMap<TStoreMap extends Record<string, unknown>> = {
+type TableMap<TStoreMap extends Record<string, any>> = {
     [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 AfterRemoteAddCallback as A, type BatchSync as B, type ConflictResolutionStrategy as C, type DyncOptions as D, type FirstLoadProgress as F, type MissingRemoteRecordStrategy as M, type SyncStatus as S, type TableMap as T, type SyncApi as a, SyncAction as b, type ApiFunctions as c, type BatchPushPayload as d, type BatchPushResult as e, type BatchFirstLoadResult as f, type FirstLoadProgressCallback as g, type MissingRemoteRecordDuringUpdateCallback as h, type MutationEvent as i, type SyncOptions 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.27",
   "private": false,
   "description": "Write once, run IndexedDB & SQLite with sync anywhere - React, React Native, Expo, Capacitor, Electron & Node.js",
   "keywords": [

package/src/index.native.ts

@@ -16,6 +16,7 @@ export type {
     BatchPushResult,
     BatchFirstLoadResult,
     ConflictResolutionStrategy,
+    DyncOptions,
     FirstLoadProgress,
     FirstLoadProgressCallback,
     MissingRemoteRecordStrategy,

package/src/index.shared.ts

@@ -3,6 +3,7 @@ import { sleep } from './helpers';
 import {
     type ApiFunctions,
     type BatchSync,
+    type DyncOptions,
     type SyncOptions,
     type SyncState,
     type SyncedRecord,
@@ -36,7 +37,7 @@ const DEFAULT_MIN_LOG_LEVEL: LogLevel = 'debug';
 const DEFAULT_MISSING_REMOTE_RECORD_STRATEGY: MissingRemoteRecordStrategy = 'insert-remote-record';
 const DEFAULT_CONFLICT_RESOLUTION_STRATEGY: ConflictResolutionStrategy = 'try-shallow-merge';
 
-class DyncBase<_TStoreMap = Record<string, any>> {
+class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
     private readonly adapter: StorageAdapter;
     private readonly tableCache = new Map<string, StorageTable<any>>();
     private readonly mutationWrappedTables = new Set<string>();
@@ -63,31 +64,35 @@ class DyncBase<_TStoreMap = Record<string, any>> {
     /**
      * 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
+     * @example Per-table sync mode
+     * ```ts
+     * const db = new Dync<Store>({
+     *     databaseName: 'my-app',
+     *     storageAdapter: new SQLiteAdapter(driver),
+     *     sync: { todos: todoSyncApi },
+     * });
+     * ```
      *
-     * 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
+     * @example Batch sync mode
+     * ```ts
+     * const db = new Dync<Store>({
+     *     databaseName: 'my-app',
+     *     storageAdapter: new SQLiteAdapter(driver),
+     *     sync: { syncTables: ['todos'], push, pull },
+     * });
+     * ```
      */
-    constructor(databaseName: string, syncApis: Record<string, ApiFunctions>, storageAdapter: StorageAdapter, options?: SyncOptions);
-    constructor(databaseName: string, batchSync: BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions);
-    constructor(databaseName: string, syncApisOrBatchSync: Record<string, ApiFunctions> | BatchSync, storageAdapter: StorageAdapter, options?: SyncOptions) {
-        // Detect mode based on whether the second arg has sync API shape (has 'list' function)
-        const isBatchMode = typeof (syncApisOrBatchSync as BatchSync).push === 'function';
+    constructor(config: DyncOptions<_TStoreMap>) {
+        const { databaseName, storageAdapter, sync: syncConfig, options } = config;
+
+        // Detect mode based on whether sync config has batch sync shape
+        const isBatchMode = typeof (syncConfig as BatchSync).push === 'function' && typeof (syncConfig as BatchSync).pull === 'function';
 
         if (isBatchMode) {
-            // Batch mode: (databaseName, batchSync, options?)
-            this.batchSync = syncApisOrBatchSync as BatchSync;
+            this.batchSync = syncConfig as BatchSync;
             this.syncedTables = new Set(this.batchSync.syncTables);
         } else {
-            // Per-table mode: (databaseName, syncApis, options?)
-            this.syncApis = syncApisOrBatchSync as Record<string, ApiFunctions>;
+            this.syncApis = syncConfig as Record<string, ApiFunctions>;
             this.syncedTables = new Set(Object.keys(this.syncApis));
         }
 
@@ -107,6 +112,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}`);
     }
@@ -171,6 +182,19 @@ class DyncBase<_TStoreMap = Record<string, any>> {
                 self.adapter.defineSchema(versionNumber, fullSchema, schemaOptions);
                 self.setupEnhancedTables(Object.keys(schema));
 
+                // Define getters for direct table access (e.g., db.todos)
+                for (const tableName of Object.keys(schema)) {
+                    if (!(tableName in self)) {
+                        Object.defineProperty(self, tableName, {
+                            get() {
+                                return self.table(tableName);
+                            },
+                            enumerable: true,
+                            configurable: false,
+                        });
+                    }
+                }
+
                 return builder;
             },
             sqlite(configure: (builder: SQLiteVersionConfigurator) => void) {
@@ -577,34 +601,23 @@ 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),
     };
 }
 
-type DyncInstance<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncBase<TStoreMap> &
+type DyncInstance<TStoreMap extends Record<string, any> = Record<string, any>> = DyncBase<TStoreMap> &
     TableMap<TStoreMap> & {
         table<K extends keyof TStoreMap & string>(name: K): StorageTable<TStoreMap[K]>;
         table(name: string): StorageTable<any>;
     };
 
-const DyncConstructor = DyncBase as unknown as {
-    prototype: DyncInstance<Record<string, unknown>>;
-    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>;
-} & typeof DyncBase;
-
-export const Dync = DyncConstructor;
-export type Dync<TStoreMap extends Record<string, unknown> = Record<string, unknown>> = DyncInstance<TStoreMap>;
+// Export Dync as a class-like constructor with proper typing for direct table access
+export const Dync = DyncBase as unknown as {
+    <TStoreMap extends Record<string, any> = Record<string, any>>(config: DyncOptions<TStoreMap>): DyncInstance<TStoreMap>;
+    new <TStoreMap extends Record<string, any> = Record<string, any>>(config: DyncOptions<TStoreMap>): DyncInstance<TStoreMap>;
+};
+
+export type Dync<TStoreMap extends Record<string, any> = Record<string, any>> = DyncInstance<TStoreMap>;

package/src/index.ts

@@ -16,6 +16,7 @@ export type {
     BatchPushResult,
     BatchFirstLoadResult,
     ConflictResolutionStrategy,
+    DyncOptions,
     FirstLoadProgress,
     FirstLoadProgressCallback,
     MissingRemoteRecordStrategy,

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'>;
+}