@legendapp/state 2.2.0-next.7 → 2.2.0-next.9

package/src/persistTypes.d.ts

@@ -0,0 +1,224 @@
+import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
+import type { DatabaseReference, Query } from 'firebase/database';
+import { ArrayValue, Change, ClassConstructor, RecordValue, RetryOptions, TypeAtPath } from './observableInterfaces';
+import { Observable, ObservableReadable, ObservableState } from './observableTypes';
+export interface PersistTransform<T = any> {
+    in?: (value: T) => T | Promise<T>;
+    out?: (value: T) => T | Promise<T>;
+}
+export interface PersistOptionsLocal<T = any> {
+    name: string;
+    transform?: PersistTransform<T>;
+    fieldTransforms?: FieldTransforms<T>;
+    readonly?: boolean;
+    mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
+    options?: any;
+}
+export type PersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
+    readonly?: boolean;
+    waitForGet?: Promise<any> | ObservableReadable<any>;
+    waitForSet?: Promise<any> | ObservableReadable<any>;
+    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;
+};
+export interface ObservablePersistenceConfigLocalGlobalOptions {
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    indexedDB?: {
+        databaseName: string;
+        version: number;
+        tableNames: string[];
+    };
+    asyncStorage?: {
+        AsyncStorage: AsyncStorageStatic;
+        preload?: boolean | string[];
+    };
+}
+export interface ObservablePersistenceConfigRemoteGlobalOptions {
+    saveTimeout?: number;
+    dateModifiedKey?: string;
+    offlineBehavior?: false | 'retry';
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    log?: (logLevel: 'verbose' | 'warning' | 'error', message: any, ...optionalParams: any[]) => void;
+    onBeforeSet?: () => void;
+    onSet?: () => void;
+}
+export interface ObservablePersistenceConfig {
+    pluginLocal?: ClassConstructor<ObservablePersistLocal>;
+    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions;
+    localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
+    remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
+}
+export interface PersistOptions<T = any> {
+    local?: string | PersistOptionsLocal<T>;
+    remote?: PersistOptionsRemote<T>;
+    pluginLocal?: ClassConstructor<ObservablePersistLocal>;
+    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
+}
+export interface PersistMetadata {
+    id?: '__legend_metadata';
+    modified?: number;
+    pending?: any;
+}
+export interface ObservablePersistLocal {
+    initialize?(config: ObservablePersistenceConfigLocalGlobalOptions): void | Promise<void>;
+    loadTable?(table: string, config: PersistOptionsLocal): Promise<any> | void;
+    getTable<T = any>(table: string, config: PersistOptionsLocal): T;
+    set(table: string, changes: Change[], config: PersistOptionsLocal): Promise<any> | void;
+    deleteTable(table: string, config: PersistOptionsLocal): Promise<any> | void;
+    getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<any> | void;
+    deleteMetadata(table: string, config: PersistOptionsLocal): Promise<any> | void;
+}
+export interface ObservableOnChangeParams {
+    value: unknown;
+    path?: string[];
+    pathTypes?: TypeAtPath[];
+    mode?: 'assign' | 'set' | 'dateModified';
+    dateModified?: number | undefined;
+}
+export interface ObservablePersistRemoteSetParams<T> {
+    syncState: Observable<ObservablePersistState>;
+    obs: Observable<T>;
+    options: PersistOptions<T>;
+    changes: Change[];
+    value: T;
+}
+export interface ObservablePersistRemoteGetParams<T> {
+    state: Observable<ObservablePersistState>;
+    obs: ObservableReadable<T>;
+    options: PersistOptions<T>;
+    dateModified?: number;
+    mode?: 'assign' | 'set' | 'dateModified';
+    onGet: () => void;
+    onError: (error: Error) => void;
+    onChange: (params: ObservableOnChangeParams) => void | Promise<void>;
+}
+export type ObservablePersistRemoteGetFnParams<T> = Omit<ObservablePersistRemoteGetParams<T>, 'onGet'>;
+export interface ObservablePersistRemoteClass {
+    get?<T>(params: ObservablePersistRemoteGetParams<T>): void;
+    set?<T>(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
+        changes?: object;
+        dateModified?: number;
+        pathStrs?: string[];
+    }>;
+}
+export interface ObservablePersistRemoteFunctions<T = any> {
+    get?(params: ObservablePersistRemoteGetFnParams<T>): T | Promise<T>;
+    set?(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
+        changes?: object | undefined;
+        dateModified?: number;
+    }>;
+}
+export interface ObservablePersistStateBase {
+    isLoadedLocal: boolean;
+    isEnabledLocal: boolean;
+    isEnabledRemote: boolean;
+    dateModified?: number;
+    syncCount?: number;
+    clearLocal: () => Promise<void>;
+    sync: () => Promise<void>;
+    getPendingChanges: () => Record<string, {
+        p: any;
+        v?: any;
+    }> | undefined;
+}
+export type ObservablePersistState = ObservableState & ObservablePersistStateBase;
+export type ObservablePersistStateInternal = ObservablePersistState & {
+    refreshNum: number;
+};
+export interface WithPersistState {
+    state?: ObservablePersistState;
+    _state?: ObservablePersistState;
+}
+export interface CacheOptions<T = any> {
+    local: string | PersistOptionsLocal<T>;
+    pluginLocal?: ClassConstructor<ObservablePersistLocal, T[]>;
+}
+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]>;
+export declare type FieldTransforms<T> = (T extends Record<string, Record<string, any>> ? {
+    _dict: FieldTransformsInner<RecordValue<T>>;
+} : never) | FieldTransformsInner<T>;
+export 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]>>;
+};
+export type QueryByModified<T> = boolean | {
+    [K in keyof T]?: QueryByModified<T[K]>;
+} | {
+    '*'?: boolean;
+};
+interface MMKVConfiguration {
+    /**
+     * The MMKV instance's ID. If you want to use multiple instances, make sure to use different IDs!
+     *
+     * @example
+     * ```ts
+     * const userStorage = new MMKV({ id: `user-${userId}-storage` })
+     * const globalStorage = new MMKV({ id: 'global-app-storage' })
+     * ```
+     *
+     * @default 'mmkv.default'
+     */
+    id: string;
+    /**
+     * The MMKV instance's root path. By default, MMKV stores file inside `$(Documents)/mmkv/`. You can customize MMKV's root directory on MMKV initialization:
+     *
+     * @example
+     * ```ts
+     * const temporaryStorage = new MMKV({ path: '/tmp/' })
+     * ```
+     */
+    path?: string;
+    /**
+     * The MMKV instance's encryption/decryption key. By default, MMKV stores all key-values in plain text on file, relying on iOS's sandbox to make sure the file is encrypted. Should you worry about information leaking, you can choose to encrypt MMKV.
+     *
+     * Encryption keys can have a maximum length of 16 bytes.
+     *
+     * @example
+     * ```ts
+     * const secureStorage = new MMKV({ encryptionKey: 'my-encryption-key!' })
+     * ```
+     */
+    encryptionKey?: string;
+}
+export {};

package/src/proxy.d.ts

@@ -1,4 +1,5 @@
-import { ObservableProxy, ObservableProxyLink, ObservableProxyTwoWay, Observable as ObservableWriteable } from './observableInterfaces';
+import { ObservableWriteable } from './observableTypes';
+import { ObservableProxy, ObservableProxyLink, ObservableProxyTwoWay } from './observableInterfaces';
 export declare function proxy<T, T2 = T>(get: (key: string) => T, set: (key: string, value: T2) => void): ObservableProxyTwoWay<Record<string, T>, T2>;
 export declare function proxy<T extends Record<string, any>>(get: <K extends keyof T>(key: K) => ObservableWriteable<T[K]>): ObservableProxyLink<T>;
 export declare function proxy<T>(get: (key: string) => ObservableWriteable<T>): ObservableProxyLink<Record<string, T>>;

package/src/react/Computed.d.ts

@@ -1,5 +1,5 @@
 import { ReactElement, ReactNode } from 'react';
-import type { ObservableReadable } from '../observableInterfaces';
+import type { ObservableReadable } from '../observableTypes';
 export declare function Computed({ children }: {
     children: ObservableReadable | (() => ReactNode);
 }): ReactElement;

package/src/react/reactInterfaces.d.ts

@@ -1,5 +1,6 @@
 import type { FC, LegacyRef, ReactNode } from 'react';
-import type { Observable, Selector } from '../observableInterfaces';
+import type { Observable } from '../observableTypes';
+import type { Selector } from '../observableInterfaces';
 export type ShapeWithNew$<T> = Partial<Omit<T, 'children'>> & {
     [K in keyof T as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
 } & {

package/src/react/usePauseProvider.d.ts

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
-export declare const PauseContext: import("react").Context<import("@legendapp/state").ObservablePrimitiveBaseFns<boolean> & import("@legendapp/state").ObservablePrimitiveBooleanFns<boolean>>;
+export declare const PauseContext: import("react").Context<import("../observableTypes").ObservableBoolean>;
 export declare function usePauseProvider(): {
     PauseProvider: ({ children }: {
         children: ReactNode;
-    }) => import("react").FunctionComponentElement<import("react").ProviderProps<import("@legendapp/state").ObservablePrimitiveBaseFns<boolean> & import("@legendapp/state").ObservablePrimitiveBooleanFns<boolean>>>;
-    isPaused$: import("@legendapp/state").ObservablePrimitiveBaseFns<boolean> & import("@legendapp/state").ObservablePrimitiveBooleanFns<boolean>;
+    }) => import("react").FunctionComponentElement<import("react").ProviderProps<import("../observableTypes").ObservableBoolean>>;
+    isPaused$: import("../observableTypes").ObservableBoolean;
 };

package/src/react-hooks/useFetch.d.ts

@@ -1,6 +1,7 @@
-export declare function useFetch<T>(input: RequestInfo | URL, init?: RequestInit, valueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text'): import("@legendapp/state").ObservableObject<{
-    data?: T | undefined;
+import { Observable } from '@legendapp/state';
+export declare function useFetch<T>(input: RequestInfo | URL, init?: RequestInit, valueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text'): Observable<{
+    data?: T;
     error?: any;
-    errorStr?: string | undefined;
+    errorStr?: string;
     loading: boolean;
 }>;

package/src/trackSelector.d.ts

@@ -2,6 +2,6 @@ import type { ListenerParams, ObservableListenerDispose, ObserveEvent, Selector
 import type { ObserveOptions } from './observe';
 export declare function trackSelector<T>(selector: Selector<T>, update: (params: ListenerParams) => void, observeEvent?: ObserveEvent<T>, observeOptions?: ObserveOptions, createResubscribe?: boolean): {
     value: any;
-    dispose: ObservableListenerDispose | undefined;
+    dispose: (() => void) | undefined;
     resubscribe: ObservableListenerDispose | undefined;
 };