@legendapp/state 3.0.0-alpha.3 → 3.0.0-alpha.31

package/sync.d.ts

@@ -1,8 +1,7 @@
 import { MMKVConfiguration } from 'react-native-mmkv';
 import { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
-import { ClassConstructor, GetMode, SetParams, NodeValue, UpdateFn, ObservableParam, LinkedOptions, RetryOptions, Change, Observable, ObservableSyncState, UpdateFnParams, Selector, TypeAtPath, ObservableState, RecordValue, ArrayValue } from '@legendapp/state';
+import { ClassConstructor, NodeInfo, ObservableParam, GetMode, SetParams, UpdateFn, LinkedOptions, RetryOptions, Change, Observable, ObservableSyncState, TypeAtPath, RecordValue, ArrayValue, WaitForSet } from '@legendapp/state';
 import { SyncedOptionsGlobal as SyncedOptionsGlobal$1 } from '@legendapp/state/sync';
-import { DatabaseReference, Query } from 'firebase/database';
 
 interface PersistOptions<T = any> {
     name: string;
@@ -17,30 +16,43 @@ interface PersistOptions<T = any> {
     };
     options?: any;
 }
-interface SyncedGetParams {
+interface SyncedGetSetSubscribeBaseParams<T = any> {
+    node: NodeInfo;
+    value$: ObservableParam<T>;
+    refresh: () => void;
+}
+interface SyncedGetSetBaseParams<T = any> extends SyncedGetSetSubscribeBaseParams<T>, OnErrorRetryParams {
+}
+interface OnErrorRetryParams {
+    retryNum: number;
+    cancelRetry: boolean;
+}
+interface SyncedGetParams<T> extends SyncedGetSetBaseParams<T> {
     value: any;
     lastSync: number | undefined;
     updateLastSync: (lastSync: number) => void;
     mode: GetMode;
-    refresh: () => void;
+    onError: (error: Error) => void;
+    options: SyncedOptions;
 }
-interface SyncedSetParams<T> extends SetParams<T> {
-    node: NodeValue;
-    valuePrevious: T;
-    update: UpdateFn;
-    refresh: () => void;
-    cancelRetry: () => void;
-    retryNum: number;
-    fromSubscribe: boolean | undefined;
+interface SyncedSetParams<T> extends Pick<SetParams<T>, 'changes' | 'value'>, SyncedGetSetBaseParams<T> {
+    update: UpdateFn<T>;
+    onError: (error: Error, retryParams: OnErrorRetryParams) => void;
 }
-interface SyncedSubscribeParams<T = any> {
-    node: NodeValue;
-    value$: ObservableParam<T>;
-    update: UpdateFn;
-    refresh: () => void;
+interface SyncedSubscribeParams<T = any> extends SyncedGetSetSubscribeBaseParams<T> {
+    lastSync: number | undefined;
+    update: UpdateFn<T>;
+    onError: (error: Error) => void;
+}
+interface SyncedErrorParams {
+    getParams?: SyncedGetParams<any>;
+    setParams?: SyncedSetParams<any>;
+    subscribeParams?: SyncedSubscribeParams<any>;
+    source: 'get' | 'set' | 'subscribe';
+    value$: ObservableParam<any>;
 }
 interface SyncedOptions<TRemote = any, TLocal = TRemote> extends Omit<LinkedOptions<TRemote>, 'get' | 'set'> {
-    get?: (params: SyncedGetParams) => Promise<TRemote> | TRemote;
+    get?: (params: SyncedGetParams<TRemote>) => Promise<TRemote> | TRemote;
     set?: (params: SyncedSetParams<TRemote>) => void | Promise<any>;
     subscribe?: (params: SyncedSubscribeParams<TRemote>) => (() => void) | void;
     retry?: RetryOptions;
@@ -49,29 +61,36 @@ interface SyncedOptions<TRemote = any, TLocal = TRemote> extends Omit<LinkedOpti
     syncMode?: 'auto' | 'manual';
     mode?: GetMode;
     transform?: SyncTransform<TLocal, TRemote>;
-    enableSync?: boolean;
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    log?: (message?: any, ...optionalParams: any[]) => void;
+    onGetError?: (error: Error, params: SyncedErrorParams) => void;
+    onSetError?: (error: Error, params: SyncedErrorParams) => void;
+    onBeforeGet?: (params: {
+        value: TRemote;
+        lastSync: number | undefined;
+        pendingChanges: PendingChanges | undefined;
+        clearPendingChanges: () => Promise<void>;
+        resetCache: () => Promise<void>;
+    }) => void;
     onBeforeSet?: () => void;
     onAfterSet?: () => void;
-    allowSetIfGetError?: boolean;
+    log?: (message?: any, ...optionalParams: any[]) => void;
 }
 interface SyncedOptionsGlobal<T = any> extends Omit<SyncedOptions<T>, 'get' | 'set' | 'persist' | 'initial' | 'waitForSet' | 'waitFor' | 'transform' | 'subscribe'> {
     persist?: ObservablePersistPluginOptions & Omit<PersistOptions, 'name' | 'transform' | 'options'>;
 }
+interface ObservablePersistIndexedDBPluginOptions {
+    databaseName: string;
+    version: number;
+    tableNames: string[];
+}
+interface ObservablePersistAsyncStoragePluginOptions {
+    AsyncStorage: AsyncStorageStatic;
+    preload?: boolean | string[];
+}
 interface ObservablePersistPluginOptions {
     onGetError?: (error: Error) => void;
     onSetError?: (error: Error) => void;
-    indexedDB?: {
-        databaseName: string;
-        version: number;
-        tableNames: string[];
-    };
-    asyncStorage?: {
-        AsyncStorage: AsyncStorageStatic;
-        preload?: boolean | string[];
-    };
+    indexedDB?: ObservablePersistIndexedDBPluginOptions;
+    asyncStorage?: ObservablePersistAsyncStoragePluginOptions;
 }
 interface ObservablePersistPlugin {
     initialize?(config: ObservablePersistPluginOptions): void | Promise<void>;
@@ -99,31 +118,9 @@ interface ObservableSyncSetParams<T> {
     options: SyncedOptions<T>;
     changes: Change[];
     value: T;
-    valuePrevious: T;
-}
-interface ObservableSyncGetParams<T> {
-    state: Observable<ObservableSyncState>;
-    value$: ObservableParam<T>;
-    options: SyncedOptions<T>;
-    dateModified?: number;
-    lastSync?: number;
-    mode?: GetMode;
-    onGet: () => void;
-    onError: (error: Error) => void;
-    onChange: (params: UpdateFnParams) => void | Promise<void>;
-}
-type ObservableSyncRemoteGetFnParams<T> = Omit<ObservableSyncGetParams<T>, 'onGet'>;
-interface ObservableSyncClass {
-    get?<T>(params: ObservableSyncGetParams<T>): void;
-    set?<T>(params: ObservableSyncSetParams<T>): void | Promise<void | {
-        changes?: object;
-        dateModified?: number;
-        lastSync?: number;
-        pathStrs?: string[];
-    }>;
 }
 interface ObservableSyncFunctions<T = any> {
-    get?(params: ObservableSyncRemoteGetFnParams<T>): T | Promise<T>;
+    get?(params: SyncedGetParams<T>): T | Promise<T>;
     set?(params: ObservableSyncSetParams<T>): void | Promise<void | {
         changes?: object | undefined;
         dateModified?: number;
@@ -131,151 +128,19 @@ interface ObservableSyncFunctions<T = any> {
     }>;
 }
 interface SubscribeOptions {
-    node: NodeValue;
+    node: NodeInfo;
     update: UpdateFn;
     refresh: () => void;
 }
 type Synced<T> = T;
+type PendingChanges = Record<string, {
+    p: any;
+    v?: any;
+    t: TypeAtPath[];
+}>;
 
 declare function configureObservableSync(options?: SyncedOptionsGlobal$1): void;
 
-interface PersistTransform<TOrig = any, TSaved = TOrig> {
-    load?: (value: TSaved) => TOrig | Promise<TOrig>;
-    save?: (value: TOrig) => TSaved | Promise<TSaved>;
-}
-interface LegacyPersistOptionsLocal<T = any> {
-    name: string;
-    transform?: PersistTransform<T>;
-    fieldTransforms?: FieldTransforms<T>;
-    readonly?: boolean;
-    mmkv?: MMKVConfiguration;
-    indexedDB?: {
-        prefixID?: string;
-        itemID?: string;
-    };
-    options?: any;
-}
-type LegacyPersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
-    readonly?: boolean;
-    waitForGet?: Selector<any>;
-    waitForSet?: LinkedOptions['waitForSet'];
-    manual?: boolean;
-    fieldTransforms?: FieldTransforms<T>;
-    allowSetIfError?: boolean;
-    transform?: PersistTransform<T>;
-    firebase?: {
-        refPath: (uid: string | undefined) => string;
-        query?: (ref: DatabaseReference) => DatabaseReference | Query;
-        queryByModified?: QueryByModified<T>;
-        ignoreKeys?: string[];
-        requireAuth?: boolean;
-        mode?: 'once' | 'realtime';
-    };
-    offlineBehavior?: false | 'retry';
-    changeTimeout?: number;
-    metadataTimeout?: number;
-    retry?: RetryOptions;
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    log?: (message?: any, ...optionalParams: any[]) => void;
-    onBeforeSet?: () => void;
-    onSet?: () => void;
-};
-interface ObservablePersistenceConfigLocalGlobalOptions {
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    indexedDB?: {
-        databaseName: string;
-        version: number;
-        tableNames: string[];
-    };
-    asyncStorage?: {
-        AsyncStorage: AsyncStorageStatic;
-        preload?: boolean | string[];
-    };
-}
-interface ObservablePersistenceConfigRemoteGlobalOptions {
-    debounceSet?: number;
-    dateModifiedKey?: string;
-    offlineBehavior?: false | 'retry';
-    retry?: RetryOptions;
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    log?: (logLevel: 'verbose' | 'warning' | 'error', message: any, ...optionalParams: any[]) => void;
-    onBeforeSet?: () => void;
-    onAfterSet?: () => void;
-}
-interface ObservablePersistenceConfig {
-    pluginLocal?: ClassConstructor<ObservablePersistPlugin>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions;
-    localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
-    remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
-}
-interface LegacyPersistOptions<T = any> {
-    local?: string | LegacyPersistOptionsLocal<T>;
-    remote?: LegacyPersistOptionsRemote<T>;
-    pluginLocal?: ClassConstructor<ObservablePersistPlugin>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
-}
-interface ObservableOnChangeParams {
-    value: unknown;
-    path?: string[];
-    pathTypes?: TypeAtPath[];
-    mode?: GetMode;
-    dateModified?: number | undefined;
-    lastSync?: number | undefined;
-}
-interface ObservablePersistRemoteSetParams<T> {
-    syncState: Observable<ObservablePersistState>;
-    obs: ObservableParam<T>;
-    options: LegacyPersistOptions<T>;
-    changes: Change[];
-    value: T;
-}
-interface ObservablePersistRemoteGetParams<T> {
-    state: Observable<ObservablePersistState>;
-    obs: ObservableParam<T>;
-    options: LegacyPersistOptions<T>;
-    dateModified?: number;
-    lastSync?: number;
-    mode?: GetMode;
-    onGet: () => void;
-    onError: (error: Error) => void;
-    onChange: (params: ObservableOnChangeParams) => void | Promise<void>;
-}
-type ObservablePersistRemoteGetFnParams<T> = Omit<ObservablePersistRemoteGetParams<T>, 'onGet'>;
-interface ObservablePersistRemoteClass {
-    get?<T>(params: ObservablePersistRemoteGetParams<T>): void;
-    set?<T>(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
-        changes?: object;
-        dateModified?: number;
-        lastSync?: number;
-        pathStrs?: string[];
-    }>;
-}
-interface ObservablePersistRemoteFunctions<T = any> {
-    get?(params: ObservablePersistRemoteGetFnParams<T>): T | Promise<T>;
-    set?(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
-        changes?: object | undefined;
-        dateModified?: number;
-        lastSync?: number;
-    }>;
-}
-interface ObservablePersistStateBase {
-    isLoadedLocal: boolean;
-    isEnabledLocal: boolean;
-    isEnabledRemote: boolean;
-    dateModified?: number;
-    lastSync?: number;
-    syncCount?: number;
-    clearLocal: () => Promise<void>;
-    sync: () => Promise<void>;
-    getPendingChanges: () => Record<string, {
-        p: any;
-        v?: any;
-    }> | undefined;
-}
-type ObservablePersistState = ObservableState & ObservablePersistStateBase;
 declare type ObjectKeys<T> = Pick<T, {
     [K in keyof T]-?: K extends string ? T[K] extends Record<string, any> ? T[K] extends any[] ? never : K : never : never;
 }[keyof T]>;
@@ -333,8 +198,8 @@ declare function transformStringifyDates<TRemote extends Record<string, any>, TL
 declare function transformStringifyDates<TRemote extends Record<string, any>, Keys extends keyof TRemote = keyof TRemote>(...args: Keys[]): SyncTransform<TransformStringsToDates<TRemote, Keys>, TRemote>;
 declare function transformStringifyDates<TRemote extends Record<string, any>, TLocal extends Record<string, any> = TRemote>(...args: (keyof TRemote)[]): SyncTransform<TRemote, TLocal>;
 
-declare const mapSyncPlugins: WeakMap<ClassConstructor<ObservablePersistPlugin | ObservableSyncClass>, {
-    plugin: ObservablePersistPlugin | ObservableSyncClass;
+declare const mapSyncPlugins: WeakMap<ClassConstructor<ObservablePersistPlugin>, {
+    plugin: ObservablePersistPlugin;
     initialized: Observable<boolean>;
 }>;
 declare function onChangeRemote(cb: () => void): void;
@@ -343,9 +208,18 @@ declare function syncObservable<T>(obs$: ObservableParam<T>, syncOptions: Synced
 
 declare function synced<TRemote, TLocal = TRemote>(params: SyncedOptions<TRemote, TLocal> | (() => TRemote)): Synced<TLocal>;
 
-declare function isInRemoteChange(): boolean;
+interface SyncedOptionsConfigure extends Omit<SyncedOptions, 'persist'> {
+    persist?: Partial<PersistOptions<any>>;
+}
+type RetType = typeof synced;
+declare function configureSynced<T extends typeof synced>(fn: T, origOptions: SyncedOptionsConfigure): T;
+declare function configureSynced(origOptions: SyncedOptionsConfigure): RetType;
+
+declare function waitForSet(waitForSet: WaitForSet<any>, changes: Change[], value: any, params?: Record<string, any>): Promise<void>;
+
 declare const internal: {
     observableSyncConfiguration: SyncedOptionsGlobal;
+    waitForSet: typeof waitForSet;
 };
 
-export { type FieldTransforms, type FieldTransformsInner, type LegacyPersistOptions, type LegacyPersistOptionsLocal, type LegacyPersistOptionsRemote, type ObservableOnChangeParams, type ObservablePersistPlugin, type ObservablePersistPluginOptions, type ObservablePersistRemoteClass, type ObservablePersistRemoteFunctions, type ObservablePersistRemoteGetFnParams, type ObservablePersistRemoteGetParams, type ObservablePersistRemoteSetParams, type ObservablePersistState, type ObservablePersistStateBase, type ObservablePersistenceConfig, type ObservablePersistenceConfigLocalGlobalOptions, type ObservablePersistenceConfigRemoteGlobalOptions, type ObservableSyncClass, type ObservableSyncFunctions, type ObservableSyncGetParams, type ObservableSyncRemoteGetFnParams, type ObservableSyncSetParams, type PersistMetadata, type PersistOptions, type PersistTransform, type QueryByModified, type StringToDate, type SubscribeOptions, type SyncTransform, type SyncTransformMethod, type Synced, type SyncedGetParams, type SyncedOptions, type SyncedOptionsGlobal, type SyncedSetParams, type SyncedSubscribeParams, type TransformStringifyKeys, type TransformStringifyOptions, type TransformStringsToDates, combineTransforms, configureObservableSync, deepEqual, diffObjects, internal, isInRemoteChange, mapSyncPlugins, onChangeRemote, removeNullUndefined, syncObservable, synced, transformStringifyDates, transformStringifyKeys };
+export { type FieldTransforms, type FieldTransformsInner, type ObservablePersistAsyncStoragePluginOptions, type ObservablePersistIndexedDBPluginOptions, type ObservablePersistPlugin, type ObservablePersistPluginOptions, type ObservableSyncFunctions, type ObservableSyncSetParams, type OnErrorRetryParams, type PendingChanges, type PersistMetadata, type PersistOptions, type QueryByModified, type StringToDate, type SubscribeOptions, type SyncTransform, type SyncTransformMethod, type Synced, type SyncedErrorParams, type SyncedGetParams, type SyncedGetSetBaseParams, type SyncedGetSetSubscribeBaseParams, type SyncedOptions, type SyncedOptionsGlobal, type SyncedSetParams, type SyncedSubscribeParams, type TransformStringifyKeys, type TransformStringifyOptions, type TransformStringsToDates, combineTransforms, configureObservableSync, configureSynced, deepEqual, diffObjects, internal, mapSyncPlugins, onChangeRemote, removeNullUndefined, syncObservable, synced, transformStringifyDates, transformStringifyKeys };