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

package/sync.d.ts

@@ -1,11 +1,351 @@
-import type { SyncedOptionsGlobal } from './src/sync/syncTypes';
-export { configureObservableSync } from './src/sync/configureObservableSync';
-export * from './src/sync/persistTypes';
-export * from './src/sync/syncHelpers';
-export { mapSyncPlugins, onChangeRemote, syncObservable } from './src/sync/syncObservable';
-export * from './src/sync/syncTypes';
-export { synced } from './src/sync/synced';
-export declare function isInRemoteChange(): boolean;
-export declare const internal: {
+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 { SyncedOptionsGlobal as SyncedOptionsGlobal$1 } from '@legendapp/state/sync';
+import { DatabaseReference, Query } from 'firebase/database';
+
+interface PersistOptions<T = any> {
+    name: string;
+    plugin?: ClassConstructor<ObservablePersistPlugin, T[]>;
+    retrySync?: boolean;
+    transform?: SyncTransform<T>;
+    readonly?: boolean;
+    mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
+    options?: any;
+}
+interface SyncedGetParams {
+    value: any;
+    lastSync: number | undefined;
+    updateLastSync: (lastSync: number) => void;
+    mode: GetMode;
+    refresh: () => void;
+}
+interface SyncedSetParams<T> extends SetParams<T> {
+    node: NodeValue;
+    valuePrevious: T;
+    update: UpdateFn;
+    refresh: () => void;
+    cancelRetry: () => void;
+    retryNum: number;
+    fromSubscribe: boolean | undefined;
+}
+interface SyncedSubscribeParams<T = any> {
+    node: NodeValue;
+    value$: ObservableParam<T>;
+    update: UpdateFn;
+    refresh: () => void;
+}
+interface SyncedOptions<TRemote = any, TLocal = TRemote> extends Omit<LinkedOptions<TRemote>, 'get' | 'set'> {
+    get?: (params: SyncedGetParams) => Promise<TRemote> | TRemote;
+    set?: (params: SyncedSetParams<TRemote>) => void | Promise<any>;
+    subscribe?: (params: SyncedSubscribeParams<TRemote>) => (() => void) | void;
+    retry?: RetryOptions;
+    persist?: PersistOptions<any>;
+    debounceSet?: number;
+    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;
+    onBeforeSet?: () => void;
+    onAfterSet?: () => void;
+    allowSetIfGetError?: boolean;
+}
+interface SyncedOptionsGlobal<T = any> extends Omit<SyncedOptions<T>, 'get' | 'set' | 'persist' | 'initial' | 'waitForSet' | 'waitFor' | 'transform' | 'subscribe'> {
+    persist?: ObservablePersistPluginOptions & Omit<PersistOptions, 'name' | 'transform' | 'options'>;
+}
+interface ObservablePersistPluginOptions {
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    indexedDB?: {
+        databaseName: string;
+        version: number;
+        tableNames: string[];
+    };
+    asyncStorage?: {
+        AsyncStorage: AsyncStorageStatic;
+        preload?: boolean | string[];
+    };
+}
+interface ObservablePersistPlugin {
+    initialize?(config: ObservablePersistPluginOptions): void | Promise<void>;
+    loadTable?(table: string, config: PersistOptions): Promise<any> | void;
+    getTable<T = any>(table: string, init: object, config: PersistOptions): T;
+    set(table: string, changes: Change[], config: PersistOptions): Promise<any> | void;
+    deleteTable(table: string, config: PersistOptions): Promise<any> | void;
+    getMetadata(table: string, config: PersistOptions): PersistMetadata;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions): Promise<any> | void;
+    deleteMetadata(table: string, config: PersistOptions): Promise<any> | void;
+}
+interface PersistMetadata {
+    id?: '__legend_metadata';
+    lastSync?: number;
+    pending?: any;
+}
+type SyncTransformMethod = 'get' | 'set';
+interface SyncTransform<TLocal = any, TSaved = TLocal> {
+    load?: (value: TSaved, method: SyncTransformMethod) => TLocal | Promise<TLocal>;
+    save?: (value: TLocal) => TSaved | Promise<TSaved>;
+}
+interface ObservableSyncSetParams<T> {
+    syncState: Observable<ObservableSyncState>;
+    value$: ObservableParam<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>;
+    set?(params: ObservableSyncSetParams<T>): void | Promise<void | {
+        changes?: object | undefined;
+        dateModified?: number;
+        lastSync?: number;
+    }>;
+}
+interface SubscribeOptions {
+    node: NodeValue;
+    update: UpdateFn;
+    refresh: () => void;
+}
+type Synced<T> = T;
+
+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]>;
+declare type DictKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string ? (T[K] extends Record<string, Record<string, any>> ? K : never) : never;
+}[keyof T]>;
+declare type ArrayKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string | number ? (T[K] extends any[] ? K : never) : never;
+}[keyof T]>;
+declare type FieldTransforms<T> = (T extends Record<string, Record<string, any>> ? {
+    _dict: FieldTransformsInner<RecordValue<T>>;
+} : never) | FieldTransformsInner<T>;
+declare type FieldTransformsInner<T> = {
+    [K in keyof T]: string;
+} & ({
+    [K in keyof ObjectKeys<T> as `${K}_obj`]?: FieldTransforms<T[K]>;
+} | {
+    [K in keyof DictKeys<T> as `${K}_dict`]?: FieldTransforms<RecordValue<T[K]>>;
+}) & {
+    [K in keyof ArrayKeys<T> as `${K}_arr`]?: FieldTransforms<ArrayValue<T[K]>>;
+} & {
+    [K in keyof ArrayKeys<T> as `${K}_val`]?: FieldTransforms<ArrayValue<T[K]>>;
+};
+type QueryByModified<T> = boolean | {
+    [K in keyof T]?: QueryByModified<T[K]>;
+} | {
+    '*'?: boolean;
+};
+
+declare function removeNullUndefined<T extends Record<string, any>>(a: T, recursive?: boolean): T;
+declare function diffObjects<T extends Record<string, any>>(obj1: T, obj2: T, deep?: boolean): Partial<T>;
+declare function deepEqual<T extends Record<string, any> = any>(a: T, b: T, ignoreFields?: string[], nullVsUndefined?: boolean): boolean;
+declare function combineTransforms<T, T2>(...transforms: Partial<SyncTransform<T2, T>>[]): SyncTransform<T2, T>;
+interface TransformStringifyOptions {
+    stringifyIf?: {
+        number?: boolean;
+        object?: boolean;
+        array?: boolean;
+        date?: boolean;
+    };
+    filterArrays?: boolean;
+}
+type TransformStringifyKeys<TRemote, TLocal> = (keyof TRemote | {
+    from: keyof TRemote;
+    to: keyof TLocal;
+})[];
+type StringToDate<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends string ? string | Date : T[K];
+};
+declare function transformStringifyKeys<TRemote extends Record<string, any>, TLocal extends Record<string, any>>(...keys: TransformStringifyKeys<TRemote, TLocal>): SyncTransform<TLocal, TRemote>;
+type TransformStringsToDates<T extends {}, Keys extends keyof T> = {
+    [K in Keys]: Date | Exclude<T[K], string>;
+} & Omit<T, Keys>;
+declare function transformStringifyDates<TRemote extends Record<string, any>, TLocal extends Record<string, any> = TRemote>(): SyncTransform<TLocal, TRemote>;
+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;
+    initialized: Observable<boolean>;
+}>;
+declare function onChangeRemote(cb: () => void): void;
+declare function syncObservable<T>(obs$: ObservableParam<T>, syncOptions: SyncedOptions<T>): Observable<ObservableSyncState>;
+declare function syncObservable<T>(obs$: ObservableParam<T>, syncOptions: Synced<T>): Observable<ObservableSyncState>;
+
+declare function synced<TRemote, TLocal = TRemote>(params: SyncedOptions<TRemote, TLocal> | (() => TRemote)): Synced<TLocal>;
+
+declare function isInRemoteChange(): boolean;
+declare const internal: {
     observableSyncConfiguration: SyncedOptionsGlobal;
 };
+
+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 };