@legendapp/state 2.2.0-next.2 → 2.2.0-next.21

package/src/helpers.d.ts

@@ -1,4 +1,5 @@
-import type { ObservableEvent, ObservableObject, ObservableReadable, ObservableWriteable, ObserveEvent, OpaqueObject, Selector, TypeAtPath } from './observableInterfaces';
+import type { ObservableEvent, ObserveEvent, OpaqueObject, Selector, TypeAtPath } from './observableInterfaces';
+import type { ObservableReadable, ObservableWriteable } from './observableTypes';
 export declare function isEvent(obs: any): obs is ObservableEvent;
 export declare function computeSelector<T>(selector: Selector<T>, e?: ObserveEvent<T>, retainObservable?: boolean): any;
 export declare function getObservableIndex(obs: ObservableReadable): number;
@@ -6,7 +7,7 @@ export declare function opaqueObject<T extends object>(value: T): OpaqueObject<T
 export declare function lockObservable(obs: ObservableReadable, value: boolean): void;
 export declare function setAtPath<T extends object>(obj: T, path: string[], pathTypes: TypeAtPath[], value: any, fullObj?: T, restore?: (path: string[], value: any) => void): T;
 export declare function setInObservableAtPath(obs: ObservableWriteable, path: string[], pathTypes: string[], value: any, mode: 'assign' | 'set'): void;
-export declare function mergeIntoObservable<T extends ObservableObject | object>(target: T, ...sources: any[]): T;
+export declare function mergeIntoObservable<T extends ObservableWriteable<Record<string, any>> | object>(target: T, ...sources: any[]): T;
 export declare function constructObjectWithPath(path: string[], pathTypes: TypeAtPath[], value: any): object;
 export declare function deconstructObjectWithPath(path: string[], pathTypes: TypeAtPath[], value: any): object;
 export declare function isObservableValueReady(value: any): boolean;

package/src/history/trackHistory.d.ts

@@ -1,4 +1,4 @@
 import { ObservableReadable, ObservableWriteable } from '@legendapp/state';
 type TimestampAsString = string;
-export declare function trackHistory<T>(obs: ObservableReadable<T>, targetObservable?: ObservableWriteable<Record<TimestampAsString, Partial<T>>>): ObservableWriteable<Record<string, Partial<T>>>;
+export declare function trackHistory<T>(obs: ObservableReadable<T>, targetObservable?: ObservableWriteable<Record<TimestampAsString, Partial<T>>>): ObservableWriteable<Record<TimestampAsString, any>>;
 export {};

package/src/observable.d.ts

@@ -1,16 +1,7 @@
-import type { ComputedParams, ComputedProxyParams, Observable, ObservableComputed, ObservablePrimitive, RecordValue, WithState } from './observableInterfaces';
-type TWithFunctions<T> = T | {
-    [K in keyof T]: ((params: ComputedProxyParams<T[K] | RecordValue<T[K]>>) => TWithFunctions<T[K]> | Promise<TWithFunctions<T[K]>> | void) | TWithFunctions<T[K]>;
-};
-export declare function observable<T>(value: Promise<T>): Observable<T & WithState>;
-export declare function observable<T>(value: () => Observable<T>): Observable<T>;
-export declare function observable<T>(value: () => Promise<T>): Observable<T & WithState>;
-export declare function observable<T>(value: () => T): ObservableComputed<T>;
-export declare function observable<T>(value: (params: ComputedParams) => Observable<T>): Observable<T & WithState>;
-export declare function observable<T>(value: (params: ComputedParams) => Promise<T>): Observable<T & WithState>;
-export declare function observable<T>(value: (params: ComputedParams) => T): Observable<T>;
-export declare function observable<T>(value: (params: ComputedProxyParams<T>) => void): Observable<Record<string, T> & WithState>;
-export declare function observable<T>(value?: TWithFunctions<T>): Observable<T>;
-export declare function observablePrimitive<T>(value: Promise<T>): ObservablePrimitive<T & WithState>;
+import { ObservablePersistState } from './persistTypes';
+import type { Observable, ObservablePrimitive, ObservableReadable, RecursiveValueOrFunction } from './observableTypes';
+export declare function observable<T>(): Observable<T | undefined>;
+export declare function observable<T>(value: Promise<RecursiveValueOrFunction<T>> | RecursiveValueOrFunction<T>): Observable<T>;
+export declare function observablePrimitive<T>(value: Promise<T>): ObservablePrimitive<T>;
 export declare function observablePrimitive<T>(value?: T): ObservablePrimitive<T>;
-export {};
+export declare function syncState(obs: ObservableReadable): Observable<ObservablePersistState>;

package/src/observableInterfaces.d.ts

@@ -1,122 +1,24 @@
-import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
 import type { symbolGetNode, symbolOpaque } from './globals';
-import { DatabaseReference, Query } from 'firebase/database';
-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;
-}
-type Nullable<T> = T | null | undefined;
+import type { Observable, ObservableComputed, ObservableComputed as ObservableComputedNew, ObservableComputedTwoWay, Observable as ObservableNew, ObservableReadable, ObservableReadable as ObservableReadableNew } from './observableTypes';
+import type { ObservablePersistState } from './persistTypes';
 export type TrackingType = undefined | true | symbol;
-export interface MapGet<T extends Map<any, any> | WeakMap<any, any>> {
-    get(key: Parameters<T['get']>[0]): ObservableChild<Parameters<T['set']>[1]>;
-    get(): T;
-    size: ObservableChild<number>;
-}
 export interface GetOptions {
     shallow: boolean;
 }
-export interface ObservableBaseFns<T> {
-    peek(): T;
-    get(options?: TrackingType | GetOptions): T;
-    onChange(cb: ListenerFn<T>, options?: {
-        trackingType?: TrackingType;
-        initial?: boolean;
-        immediate?: boolean;
-        noArgs?: boolean;
-    }): ObservableListenerDispose;
-}
-export interface ObservablePrimitiveBaseFns<T> extends ObservableBaseFns<T> {
-    delete(): ObservablePrimitiveBaseFns<T>;
-    set(value: Nullable<T> | CallbackSetter<T> | Promise<T> | Observable<T>): ObservablePrimitiveChild<T>;
-}
-export interface ObservablePrimitiveBooleanFns<T> {
-    toggle(): T;
-}
-export interface ObservableObjectFns<T> extends ObservableBaseFns<T> {
-    set(value: Nullable<T> | CallbackSetter<T> | Promise<T> | Observable<T>): ObservableChild<T>;
-    assign(value: T | Partial<T>): ObservableChild<T>;
-    delete(): ObservableChild<T>;
-}
-export type ObservablePrimitive<T> = [T] extends [boolean] ? ObservablePrimitiveBaseFns<T> & ObservablePrimitiveBooleanFns<T> : ObservablePrimitiveBaseFns<T>;
-export interface ObservablePrimitiveChildFns<T> extends ObservablePrimitiveBaseFns<T> {
-    delete(): ObservablePrimitiveChild<T>;
-}
-type CallbackSetter<T> = {
-    bivarianceHack(prev: T): T;
-}['bivarianceHack'];
 export type OpaqueObject<T> = T & {
     [symbolOpaque]: true;
 };
-type ArrayOverrideFnNames = 'find' | 'every' | 'some' | 'filter' | 'reduce' | 'reduceRight' | 'forEach' | 'map';
-type RemoveIndex<T> = {
-    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
-};
-export type ObservableArrayOverride<T> = Omit<RemoveIndex<Array<T>>, ArrayOverrideFnNames> & Pick<Array<Observable<T>>, ArrayOverrideFnNames> & {
-    [n: number]: Observable<T>;
-};
 export interface ListenerParams<T = any> {
     value: T;
     getPrevious: () => T;
     changes: Change[];
 }
 export type ListenerFn<T = any> = (params: ListenerParams<T>) => void;
-type PrimitiveKeys<T> = Pick<T, {
-    [K in keyof T]-?: T[K] extends Primitive ? K : never;
-}[keyof T]>;
-type NonPrimitiveKeys<T> = Pick<T, {
-    [K in keyof T]-?: T[K] extends Primitive ? never : K;
-}[keyof T]>;
-type Recurse<T, K extends keyof T, TRecurse> = T[K] extends ObservableReadable ? T[K] : T[K] extends Promise<infer t> ? Observable<t & WithState> : T[K] extends () => infer t ? t extends Observable ? t : Observable<t> & T[K] : T[K] extends (params: ComputedParams) => infer t ? t extends Observable ? t : Observable<t> : T[K] extends (params: ComputedProxyParams<infer t>) => void ? t extends Observable ? Record<string, t> : Observable<Record<string, t>> : T[K] extends Function ? T[K] : T[K] extends ObservableProxyTwoWay<infer t, infer t2> ? ObservableProxyTwoWay<t, t2> : T[K] extends ObservableProxy<infer t> ? ObservableProxy<t> : T[K] extends ObservableProxyLink<infer t> ? ObservableProxyLink<t> : T[K] extends Map<any, any> | WeakMap<any, any> ? ObservableMap<T[K]> : T[K] extends Set<any> | WeakSet<any> ? ObservableSet<T[K]> : T[K] extends Set<any> | WeakSet<any> ? T[K] & ObservablePrimitiveBaseFns<T[K]> : T[K] extends OpaqueObject<T[K]> ? T[K] & ObservablePrimitiveChildFns<T[K]> : T[K] extends Primitive ? ObservablePrimitiveChild<T[K]> : T[K] extends Array<any> ? ObservableObjectFns<T[K]> & ObservableArrayOverride<T[K][number]> : T extends object ? TRecurse : T[K];
-type ObservableFnsRecursiveUnsafe<T> = {
-    [K in keyof T]-?: Recurse<T, K, ObservableObject<NonNullable<T[K]>>>;
-};
-type ObservableFnsRecursiveSafe<T> = {
-    readonly [K in keyof T]-?: Recurse<T, K, ObservableObject<NonNullable<T[K]>>>;
-};
-type ObservableFnsRecursive<T> = ObservableFnsRecursiveSafe<NonPrimitiveKeys<T>> & ObservableFnsRecursiveUnsafe<PrimitiveKeys<T>>;
-type ObservableComputedFnsRecursive<T> = {
-    readonly [K in keyof T]-?: Recurse<T, K, ObservableBaseFns<NonNullable<T[K]>>>;
-};
 export interface ObservableEvent {
     fire(): void;
     on(cb?: () => void): ObservableListenerDispose;
     get(): void;
 }
-export type QueryByModified<T> = boolean | {
-    [K in keyof T]?: QueryByModified<T[K]>;
-} | {
-    '*'?: boolean;
-};
 export type TypeAtPath = 'object' | 'array';
 export interface Change {
     path: string[];
@@ -124,185 +26,10 @@ export interface Change {
     valueAtPath: any;
     prevAtPath: any;
 }
-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;
-    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;
-    onGet: () => 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 ObservableState {
-    isLoaded: boolean;
-    error?: Error;
-}
-export interface WithState {
-    state?: ObservableState;
-    _state?: ObservableState;
-}
-export interface ObservablePersistState extends ObservableState {
-    isLoadedLocal: boolean;
-    isEnabledLocal: boolean;
-    isEnabledRemote: boolean;
-    dateModified?: number;
-    clearLocal: () => Promise<void>;
-    sync: () => Promise<void>;
-    getPendingChanges: () => Record<string, {
-        p: any;
-        v?: any;
-    }> | undefined;
-}
-export interface WithPersistState {
-    state?: ObservablePersistState;
-    _state?: ObservablePersistState;
-}
 export type RecordValue<T> = T extends Record<string, infer t> ? t : never;
 export type ArrayValue<T> = T extends Array<infer t> ? t : never;
 export type ObservableValue<T> = T extends Observable<infer t> ? t : never;
-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 Selector<T> = ObservableReadable<T> | ObservableEvent | (() => T) | T;
+export type Selector<T> = ObservableReadableNew<T> | ObservableEvent | (() => T) | T;
 export type ClassConstructor<I, Args extends any[] = any[]> = new (...args: Args) => I;
 export type ObservableListenerDispose = () => void;
 export interface ObservableRoot {
@@ -314,25 +41,6 @@ export interface ObservableRoot {
 }
 export type Primitive = boolean | string | number | Date;
 export type NotPrimitive<T> = T extends Primitive ? never : T;
-export type ObservableMap<T extends Map<any, any> | WeakMap<any, any>> = Omit<T, 'get' | 'size'> & Omit<ObservablePrimitiveBaseFns<T>, 'get' | 'size'> & MapGet<T>;
-export type ObservableSet<T extends Set<any> | WeakSet<any>> = Omit<T, 'size'> & Omit<ObservablePrimitiveBaseFns<T>, 'size'> & {
-    size: ObservablePrimitiveChild<number>;
-};
-export type ObservableMapIfMap<T> = T extends Map<any, any> | WeakMap<any, any> ? ObservableMap<T> : never;
-export type ObservableArray<T extends any[]> = ObservableObjectFns<T> & ObservableArrayOverride<T[number]>;
-export type ObservableObject<T = any> = ObservableFnsRecursive<T> & ObservableObjectFns<T>;
-export type ObservableChild<T = any> = [T] extends [Primitive] ? ObservablePrimitiveChild<T> : ObservableObject<T>;
-export type ObservablePrimitiveChild<T = any> = [T] extends [boolean] ? ObservablePrimitiveChildFns<T> & ObservablePrimitiveBooleanFns<T> : ObservablePrimitiveChildFns<T>;
-export type ObservableObjectOrArray<T> = T extends Map<any, any> | WeakMap<any, any> ? ObservableMap<T> : T extends Set<any> | WeakSet<any> ? ObservableSet<T> : T extends any[] ? ObservableArray<T> : ObservableObject<T>;
-export type ObservableComputed<T = any> = ObservableBaseFns<T> & ObservableComputedFnsRecursive<T>;
-export type ObservableComputedTwoWay<T = any, T2 = T> = ObservableComputed<T> & ObservablePrimitiveBaseFns<T2>;
-type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-export type Observable<T = any> = Equals<T, any> extends true ? ObservableObject<any> : [T] extends [object] ? ObservableObjectOrArray<T> : ObservablePrimitive<T>;
-export type ObservableReadable<T = any> = ObservableBaseFns<T> | ObservablePrimitiveBaseFns<T> | ObservablePrimitiveChildFns<T> | ObservableObjectFns<T> | ObservableMapIfMap<T>;
-export type ObservableWriteable<T = any> = ObservableReadable<T> & {
-    set(value: Nullable<T> | CallbackSetter<T> | Promise<T>): any;
-    delete?: () => any;
-};
 export interface NodeValueListener {
     track: TrackingType;
     noArgs?: boolean;
@@ -353,11 +61,15 @@ interface BaseNodeValue {
     isSetting?: number;
     isAssigning?: number;
     parentOther?: NodeValue;
-    functions?: Map<string, Function | ObservableComputed<any>>;
+    functions?: Map<string, Function | ObservableComputedNew<any>>;
     lazy?: boolean | Function;
-    state?: Observable<ObservablePersistState>;
+    state?: ObservableNew<ObservablePersistState>;
     activated?: boolean;
-    proxyFn2?: (key: string, params: ComputedParams) => any;
+    activationState?: ActivateParams & {
+        onError?: () => void;
+        persistedRetry?: boolean;
+    };
+    dirtyFn?: () => void;
 }
 export interface RootNodeValue extends BaseNodeValue {
     parent?: undefined;
@@ -368,6 +80,11 @@ export interface ChildNodeValue extends BaseNodeValue {
     key: string;
 }
 export type NodeValue = RootNodeValue | ChildNodeValue;
+export interface TrackingNode {
+    node: NodeValue;
+    track: TrackingType;
+    num: number;
+}
 export interface ObserveEvent<T> {
     num: number;
     previous?: T | undefined;
@@ -378,39 +95,75 @@ export interface ObserveEventCallback<T> {
     num: number;
     previous?: T | undefined;
     value?: T;
-    cancel?: boolean;
+    cancel: boolean;
+    nodes: Map<NodeValue, TrackingNode> | undefined;
+    refresh: () => void;
     onCleanup?: () => void;
     onCleanupReaction?: () => void;
 }
 export type ObservableProxy<T extends Record<string, any>> = {
     [K in keyof T]: ObservableComputed<T[K]>;
-} & ObservableBaseFns<T> & {
+} & Observable<T> & {
     [symbolGetNode]: NodeValue;
 };
 export type ObservableProxyLink<T extends Record<string, any>> = {
     [K in keyof T]: Observable<T[K]>;
-} & ObservableBaseFns<T> & {
+} & Observable<T> & {
     [symbolGetNode]: NodeValue;
 };
 export type ObservableProxyTwoWay<T extends Record<string, any>, T2> = {
     [K in keyof T]: ObservableComputedTwoWay<T[K], T2>;
-} & ObservableBaseFns<T> & {
+} & Observable<T> & {
     [symbolGetNode]: NodeValue;
 };
-export interface CacheOptions<T = any> {
-    local: string | PersistOptionsLocal<T>;
-    pluginLocal?: ClassConstructor<ObservablePersistLocal, T[]>;
-}
-export interface ComputedParams<T = any> {
-    onSet: (fn: (params: ListenerParams<T>) => void) => void;
-    subscribe: (fn: (params: {
-        update: (props: ObservableOnChangeParams) => void;
-    }) => void) => void;
-    cache: (cacheOptions: CacheOptions<T> | (() => CacheOptions<T>)) => void;
+export type OnSetParams<T> = ListenerParams<T extends Promise<infer t> ? t : T> & OnSetExtra;
+export interface ActivateGetParams {
     updateLastSync: (lastSync: number) => void;
+    setMode: (mode: 'assign' | 'set') => void;
+}
+export interface ActivateParams<T = any> {
+    onSet?: (params: OnSetParams<T>) => void | Promise<any>;
+    subscribe?: (params: {
+        node: NodeValue;
+        update: UpdateFn;
+        refresh: () => void;
+    }) => void;
+    waitFor?: Selector<any>;
+    initial?: T extends Promise<infer t> ? t : T;
+    get?: (params: ActivateGetParams) => T;
+    retry?: RetryOptions;
+    offlineBehavior?: false | 'retry';
 }
-export interface ComputedProxyParams<T = any> extends ComputedParams {
-    proxy: (fn: (key: string, params: ComputedParams<T>) => T | Promise<T>) => void;
+export interface ActivateParamsWithLookup<T extends Record<string, any> = Record<string, any>> extends ActivateParams<T> {
+    lookup: (key: string) => Promise<RecordValue<T>> | Observable<RecordValue<T>> | RecordValue<T>;
+}
+export type Activated<T> = T;
+export type UpdateFn = (params: {
+    value: unknown;
+    mode?: 'assign' | 'set' | 'lastSync' | 'dateModified' | 'merge';
+    dateModified?: number | undefined;
+    lastSync?: number | undefined;
+}) => void;
+export interface RetryOptions {
+    infinite?: boolean;
+    times?: number;
+    delay?: number;
+    backoff?: 'constant' | 'exponential';
+    maxDelay?: number;
+}
+export interface OnSetExtra {
+    node: NodeValue;
+    update: UpdateFn;
+    refresh: () => void;
+    fromSubscribe: boolean | undefined;
+}
+export interface SubscribeOptions {
+    node: NodeValue;
+    update: UpdateFn;
+    refresh: () => void;
+}
+export interface CacheReturnValue {
+    lastSync: number;
+    value: any;
 }
-export type UpdateFn = (params: ObservableOnChangeParams) => void;
 export {};

package/src/observableTypes.d.ts

@@ -0,0 +1,93 @@
+import type { GetOptions, ListenerFn, TrackingType } from './observableInterfaces';
+type Primitive = string | number | boolean | symbol | bigint | undefined | null | Date;
+type ArrayOverrideFnNames = 'find' | 'every' | 'some' | 'filter' | 'reduce' | 'reduceRight' | 'forEach' | 'map' | 'sort';
+type ObservableComputed<T = any> = Readonly<ObservableNode<T>>;
+type ObservableComputedTwoWay<T, T2> = Observable<T> & MutableObservableBase<T2>;
+type MakeReadonlyInner<T> = Omit<T, keyof MutableObservableBase<any>>;
+type Readonly<T> = MakeReadonlyInner<T> & {
+    [K in keyof MakeReadonlyInner<T>]: T extends Observable ? T[K] : Readonly<T[K]>;
+};
+type RemoveIndex<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+type BuiltIns = String | Boolean | Number | Date | Error | RegExp | Array<any> | Function | Promise<any>;
+type IsUserDefinedObject<T> = T extends Function | BuiltIns | any[] ? false : T extends object ? true : false;
+export type RemoveObservables<T> = T extends ImmutableObservableBase<infer t> ? t : IsUserDefinedObject<T> extends true ? {
+    [K in keyof T]: RemoveObservables<T[K]>;
+} : T;
+interface ObservableArray<T, U> extends ObservablePrimitive<T>, Pick<Array<Observable<U>>, ArrayOverrideFnNames>, Omit<RemoveIndex<Array<U>>, ArrayOverrideFnNames> {
+}
+interface ObservableObjectFns<T> {
+    assign(value: Partial<T>): Observable<T>;
+}
+interface ObservableObjectFunctions<T = Record<string, any>> extends ObservablePrimitive<T>, ObservableObjectFns<T> {
+}
+type ObservableMap<T extends Map<any, any> | WeakMap<any, any>> = Omit<T, 'get' | 'size'> & Omit<ObservablePrimitive<T>, 'get' | 'size'> & {
+    get(key: Parameters<T['get']>[0]): Observable<Parameters<T['set']>[1]>;
+    get(): T;
+    size: ImmutableObservableBase<number>;
+};
+type ObservableSet<T extends Set<any> | WeakSet<any>> = Omit<T, 'size'> & Omit<ObservablePrimitive<T>, 'size'> & {
+    size: ImmutableObservableBase<number>;
+};
+interface ObservableBoolean extends ObservablePrimitive<boolean> {
+    toggle(): boolean;
+}
+interface ObservablePrimitive<T> extends ImmutableObservableBase<T>, MutableObservableBase<T> {
+}
+type ObservableAny = Partial<ObservableObjectFns<any>> & ObservablePrimitive<any> & Record<string, any>;
+interface ImmutableObservableBase<T> {
+    peek(): RemoveObservables<T>;
+    get(trackingType?: TrackingType | GetOptions): RemoveObservables<T>;
+    onChange(cb: ListenerFn<T>, options?: {
+        trackingType?: TrackingType;
+        initial?: boolean;
+        immediate?: boolean;
+        noArgs?: boolean;
+    }): () => void;
+}
+interface MutableObservableBase<T> {
+    set(value: (prev: RemoveObservables<T>) => RemoveObservables<T>): Observable<T>;
+    set(value: RecursiveValueOrFunction<T>): Observable<T>;
+    set(value: Promise<RemoveObservables<T>>): Observable<T>;
+    set(value: RemoveObservables<T>): Observable<T>;
+    set(value: Observable<RemoveObservables<T>>): Observable<T>;
+    delete(): void;
+}
+type UndefinedIf<T, U> = U extends true ? T | undefined : T;
+type IsNullable<T> = undefined extends T ? true : null extends T ? true : false;
+type NonObservable = Function | Observable;
+type NonObservableKeys<T> = {
+    [K in keyof T]-?: IsStrictAny<T[K]> extends true ? never : T[K] extends undefined | null ? never : NonNullable<T[K]> extends NonObservable ? K : never;
+}[keyof T];
+type ObservableProps<T> = RestoreNullability<T, Simplify<Omit<NonNullable<T>, NonObservableKeys<NonNullable<T>>>>>;
+type NonObservableProps<T> = RestoreNullability<T, Simplify<NullablePropsIf<Pick<NonNullable<T>, NonObservableKeys<NonNullable<T>>>, IsNullable<T>>>>;
+type NullablePropsIf<T, U> = {
+    [K in keyof T]: UndefinedIf<T[K], U>;
+};
+type RestoreNullability<Source, Target> = IsNullable<Source> extends true ? Target | Extract<Source, null | undefined> : Target;
+type ObservableChildren<T, Nullable = IsNullable<T>> = {
+    [K in keyof T]-?: Observable<UndefinedIf<T[K], Nullable>>;
+};
+type ObservableFunctionChildren<T> = {
+    [K in keyof T]-?: T[K] extends Observable ? T[K] : T[K] extends () => Promise<infer t> | infer t ? t extends void ? T[K] : ObservableComputed<t> & T[K] : T[K];
+};
+type IsStrictAny<T> = 0 extends 1 & T ? true : false;
+export interface ObservableState {
+    isLoaded: boolean;
+    error?: Error;
+}
+type ObservableObject<T> = ObservableObjectFunctions<ObservableProps<T> & NonObservableProps<T>> & ObservableChildren<ObservableProps<T>> & ObservableFunctionChildren<NonObservableProps<T>>;
+type ObservableNode<T, NT = NonNullable<T>> = [NT] extends [never] ? ObservablePrimitive<T> : IsStrictAny<T> extends true ? ObservableAny : [T] extends [() => infer t] ? t extends Observable ? t : ObservableComputed<t> : [NT] extends [ImmutableObservableBase<any>] ? NT : [NT] extends [Primitive] ? [NT] extends [boolean] ? ObservableBoolean : ObservablePrimitive<T> : NT extends Map<any, any> | WeakMap<any, any> ? ObservableMap<NT> : NT extends Set<infer U> ? ObservableSet<Set<UndefinedIf<U, IsNullable<T>>>> : NT extends WeakSet<any> ? ObservableSet<NT> : NT extends Array<infer U> ? ObservableArray<T, U> & ObservableChildren<T> : ObservableObject<T>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Observable<T = any> = ObservableNode<T> & {};
+type ObservableReadable<T = any> = ImmutableObservableBase<T>;
+type ObservableWriteable<T = any> = ObservableReadable<T> & MutableObservableBase<T>;
+type ValueOrFunction<T> = T extends Function ? T : T | (() => T | Promise<T>);
+type ValueOrFunctionKeys<T> = {
+    [K in keyof T]: RecursiveValueOrFunction<T[K]>;
+};
+type RecursiveValueOrFunction<T> = T extends Function ? T : T extends object ? Promise<ValueOrFunctionKeys<T>> | ValueOrFunctionKeys<T> | (() => T | Promise<T> | ValueOrFunctionKeys<T> | Promise<ValueOrFunctionKeys<T>> | Observable<T>) : ValueOrFunction<T>;
+export type { ObservableComputed, ObservableComputedTwoWay, Observable, ObservableBoolean, ObservableObject, ObservablePrimitive, ObservableReadable, ObservableWriteable, ImmutableObservableBase, RecursiveValueOrFunction, };

package/src/persist/observablePersistRemoteFunctionsAdapter.d.ts

@@ -1,2 +1,2 @@
-import type { ObservablePersistRemoteClass, ObservablePersistRemoteFunctions } from '@legendapp/state';
+import { type ObservablePersistRemoteClass, type ObservablePersistRemoteFunctions } from '@legendapp/state';
 export declare function observablePersistRemoteFunctionsAdapter<T = {}>({ get, set, }: ObservablePersistRemoteFunctions<T>): ObservablePersistRemoteClass;

package/src/persist/persistActivateNode.d.ts

@@ -0,0 +1 @@
+export declare function persistActivateNode(): void;

package/src/persist/persistHelpers.d.ts

@@ -1 +1 @@
-export declare function removeNullUndefined<T extends Record<string, any>>(val: T): T | null;
+export declare function removeNullUndefined<T extends Record<string, any>>(val: T): T;

package/src/persist/persistObservable.d.ts

@@ -1,8 +1,9 @@
-import type { ClassConstructor, FieldTransforms, Observable, ObservablePersistLocal, ObservablePersistRemoteClass, ObservableWriteable, PersistOptions, PersistTransform, Primitive, TypeAtPath, WithPersistState } from '@legendapp/state';
+import type { ClassConstructor, FieldTransforms, Observable, ObservablePersistLocal, ObservablePersistRemoteClass, ObservablePersistState, ObservableWriteable, PersistOptions, PersistTransform, Primitive, TypeAtPath } from '@legendapp/state';
 export declare const mapPersistences: WeakMap<ClassConstructor<ObservablePersistLocal | ObservablePersistRemoteClass>, {
     persist: ObservablePersistLocal | ObservablePersistRemoteClass;
     initialized?: Observable<boolean>;
 }>;
+export declare function onChangeRemote(cb: () => void): void;
 export declare function transformOutData(value: any, path: string[], pathTypes: TypeAtPath[], { transform, fieldTransforms }: {
     transform?: PersistTransform;
     fieldTransforms?: FieldTransforms<any>;
@@ -20,5 +21,4 @@ export declare function transformLoadData(value: any, { transform, fieldTransfor
 export type WithoutState = any[] | Primitive | (Record<string, any> & {
     _state?: never;
 });
-export declare function persistObservable<T extends WithoutState>(observable: ObservableWriteable<T>, persistOptions: PersistOptions<T>): Observable<WithPersistState & T>;
-export declare function persistObservable<T extends WithoutState>(initial: T | (() => T) | (() => Promise<T>), persistOptions: PersistOptions<T>): Observable<WithPersistState & T>;
+export declare function persistObservable<T>(obs: ObservableWriteable<T>, persistOptions: PersistOptions<T>): Observable<ObservablePersistState>;