@legendapp/state 1.11.1 → 2.0.0-beta.0

package/src/globals.d.ts

@@ -4,14 +4,10 @@ export declare const symbolGetNode: unique symbol;
 export declare const symbolDelete: unique symbol;
 export declare const symbolOpaque: unique symbol;
 export declare const optimized: unique symbol;
-export declare const extraPrimitiveActivators: Map<string | symbol, boolean>;
-export declare const extraPrimitiveProps: Map<string | symbol, any>;
-export declare const __devExtractFunctionsAndComputedsNodes: Set<unknown> | undefined;
 export declare const globalState: {
     isLoadingLocal: boolean;
     isLoadingRemote: boolean;
     isMerging: boolean;
-    noDepWarn: boolean;
 };
 export declare function checkActivate(node: NodeValue): void;
 export declare function getNode(obs: ObservableReadable): NodeValue;
@@ -20,6 +16,7 @@ export declare function peek(node: NodeValue): any;
 export declare function setNodeValue(node: NodeValue, newValue: any): {
     prevValue: any;
     newValue: any;
+    parentValue: any;
 };
 export declare function getNodeValue(node: NodeValue): any;
 export declare function getChildNode(node: NodeValue, key: string): NodeValue;
@@ -27,4 +24,3 @@ export declare function ensureNodeValue(node: NodeValue): any;
 export declare function findIDKey(obj: unknown | undefined, node: NodeValue): string | ((value: any) => string) | undefined;
 export declare function extractFunction(node: NodeValue, key: string, fnOrComputed: Function, computedChildNode?: never): void;
 export declare function extractFunction(node: NodeValue, key: string, fnOrComputed: ObservableComputed, computedChildNode: NodeValue): void;
-export declare function extractFunctionsAndComputeds(obj: Record<string, any>, node: NodeValue): false | undefined;

package/src/is.d.ts

@@ -1,3 +1,4 @@
+export declare const hasOwnProperty: (v: PropertyKey) => boolean;
 export declare function isArray(obj: unknown): obj is Array<any>;
 export declare function isString(obj: unknown): obj is string;
 export declare function isObject(obj: unknown): obj is Record<any, any>;

package/src/observable.d.ts

@@ -1,3 +1,5 @@
-import type { Observable, ObservablePrimitive } from './observableInterfaces';
-export declare function observable<T>(value?: T | Promise<T>): Observable<T>;
-export declare function observablePrimitive<T>(value?: T | Promise<T>): ObservablePrimitive<T>;
+import type { Observable, ObservablePrimitive, PromiseInfo } from './observableInterfaces';
+export declare function observable<T>(value: Promise<T>): Observable<T & PromiseInfo>;
+export declare function observable<T>(value?: T): Observable<T>;
+export declare function observablePrimitive<T>(value: Promise<T>): ObservablePrimitive<T & PromiseInfo>;
+export declare function observablePrimitive<T>(value?: T): ObservablePrimitive<T>;

package/src/observableInterfaces.d.ts

@@ -1,4 +1,6 @@
+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!
@@ -34,7 +36,7 @@ interface MMKVConfiguration {
     encryptionKey?: string;
 }
 type Nullable<T> = T | null | undefined;
-export type TrackingType = undefined | true | 'shallow' | 'optimize' | symbol;
+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;
@@ -91,7 +93,7 @@ type PrimitiveKeys<T> = Pick<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 Function | Promise<any> ? 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 Recurse<T, K extends keyof T, TRecurse> = T[K] extends ObservableReadable ? T[K] : T[K] extends Promise<infer t> ? Observable<t & PromiseInfo> : 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]>>>;
 };
@@ -109,6 +111,8 @@ export interface ObservableEvent {
 }
 export type QueryByModified<T> = boolean | {
     [K in keyof T]?: QueryByModified<T[K]>;
+} | {
+    '*'?: boolean;
 };
 export type TypeAtPath = 'object' | 'array';
 export interface Change {
@@ -117,12 +121,13 @@ 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;
-    adjustData?: {
-        load?: (value: T) => T | Promise<T>;
-        save?: (value: T) => T | Promise<T>;
-    };
+    transform?: PersistTransform<T>;
     fieldTransforms?: FieldTransforms<T>;
     readonly?: boolean;
     mmkv?: MMKVConfiguration;
@@ -132,36 +137,64 @@ export interface PersistOptionsLocal<T = any> {
     };
     options?: any;
 }
-export interface PersistOptionsRemote<T = any> {
+export type PersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
     readonly?: boolean;
-    once?: boolean;
-    requireAuth?: boolean;
-    saveTimeout?: number;
-    waitForLoad?: Promise<any> | ObservableReadable<any>;
-    waitForSave?: Promise<any> | ObservableReadable<any> | ((value: any, path: string[]) => Promise<any>);
+    waitForGet?: Promise<any> | ObservableReadable<any>;
+    waitForSet?: Promise<any> | ObservableReadable<any>;
     manual?: boolean;
     fieldTransforms?: FieldTransforms<T>;
-    allowSaveIfError?: boolean;
-    onLoadError?: (error: Error) => void;
-    onSaveError?: (error: Error) => void;
-    adjustData?: {
-        load?: (value: T) => T | Promise<T>;
-        save?: (value: T) => T | Promise<T>;
-    };
+    allowSetIfError?: boolean;
+    transform?: PersistTransform<T>;
     firebase?: {
-        syncPath: (uid: string) => `/${string}/`;
+        refPath: (uid: string | undefined) => string;
+        query?: (ref: DatabaseReference) => DatabaseReference | Query;
         queryByModified?: QueryByModified<T>;
         ignoreKeys?: string[];
-        dateModifiedKey?: 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[];
     };
-    onBeforeSaveRemote?: () => void;
-    onSaveRemote?: () => void;
+    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> {
+export interface PersistOptions<T = any, TState = {}> {
     local?: string | PersistOptionsLocal<T>;
     remote?: PersistOptionsRemote<T>;
-    persistLocal?: ClassConstructor<ObservablePersistLocal>;
-    persistRemote?: ClassConstructor<ObservablePersistRemote>;
+    pluginLocal?: ClassConstructor<ObservablePersistLocal>;
+    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T, TState>;
 }
 export interface PersistMetadata {
     id?: '__legend_metadata';
@@ -169,45 +202,50 @@ export interface PersistMetadata {
     pending?: any;
 }
 export interface ObservablePersistLocal {
-    initialize?(config: ObservablePersistenceConfig['persistLocalOptions']): void | Promise<void>;
+    initialize?(config: ObservablePersistenceConfigLocalGlobalOptions): void | Promise<void>;
+    loadTable?(table: string, config: PersistOptionsLocal): Promise<any> | void;
     getTable<T = any>(table: string, config: PersistOptionsLocal): T;
-    getTableTransformed?<T = any>(table: string, config: PersistOptionsLocal): T;
-    getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata;
     set(table: string, changes: Change[], config: PersistOptionsLocal): Promise<any> | void;
-    updateMetadata(table: string, metadata: PersistMetadata, 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;
-    loadTable?(table: string, config: PersistOptionsLocal): Promise<any> | void;
 }
-export interface ObservablePersistRemoteSaveParams<T, T2> {
-    state: Observable<ObservablePersistState>;
+export interface ObservablePersistRemoteSetParams<T> {
+    syncState: Observable<ObservablePersistState>;
     obs: Observable<T>;
     options: PersistOptions<T>;
-    path: string[];
-    pathTypes: TypeAtPath[];
-    valueAtPath: T2;
-    prevAtPath: any;
+    changes: Change[];
+    value: T;
 }
-export interface ObservablePersistRemoteListenParams<T> {
-    state: Observable<ObservablePersistState>;
+export interface ObservablePersistRemoteGetParams<T, TState = {}> {
+    state: Observable<ObservablePersistState & TState>;
     obs: ObservableReadable<T>;
-    options: PersistOptions<T>;
+    options: PersistOptions<T, TState>;
     dateModified?: number;
-    onLoad: () => void;
+    onGet: () => void;
     onChange: (params: {
-        value: T;
-        path: string[];
-        pathTypes: TypeAtPath[];
-        mode: 'assign' | 'set' | 'dateModified';
-        dateModified: number | undefined;
+        value: unknown;
+        path?: string[];
+        pathTypes?: TypeAtPath[];
+        mode?: 'assign' | 'set' | 'dateModified';
+        dateModified?: number | undefined;
     }) => void | Promise<void>;
 }
-export interface ObservablePersistRemote {
-    save<T, T2>(params: ObservablePersistRemoteSaveParams<T, T2>): Promise<{
+export interface ObservablePersistRemoteClass<TState = {}> {
+    get<T>(params: ObservablePersistRemoteGetParams<T, TState>): void;
+    set?<T>(params: ObservablePersistRemoteSetParams<T>): Promise<void | {
         changes?: object;
         dateModified?: number;
+        pathStrs?: string[];
+    }>;
+}
+export interface ObservablePersistRemoteFunctions<T = any, TState = {}> {
+    get(params: ObservablePersistRemoteGetParams<T, TState>): T | Promise<T>;
+    set?(params: ObservablePersistRemoteSetParams<T>): Promise<void | {
+        changes?: object | undefined;
+        dateModified?: number;
     }>;
-    listen<T>(params: ObservablePersistRemoteListenParams<T>): void;
 }
 export interface ObservablePersistState {
     isLoadedLocal: boolean;
@@ -255,7 +293,7 @@ export type ObservableListenerDispose = () => void;
 export interface ObservableRoot {
     _: any;
     locked?: boolean;
-    computedChildrenNeedingActivation?: NodeValue[];
+    toActivate?: NodeValue[];
     set?: (value: any) => void;
     activate?: () => void;
 }
@@ -288,11 +326,9 @@ export interface NodeValueListener {
 interface BaseNodeValue {
     children?: Map<string, ChildNodeValue>;
     proxy?: object;
-    isActivatedPrimitive?: boolean;
     root: ObservableRoot;
     listeners?: Set<NodeValueListener>;
     listenersImmediate?: Set<NodeValueListener>;
-    descendantHasListener?: boolean;
     isComputed?: boolean;
     proxyFn?: (key: string) => ObservableReadable;
     isEvent?: boolean;
@@ -300,7 +336,7 @@ interface BaseNodeValue {
     linkedFromNodes?: Set<NodeValue>;
     isSetting?: number;
     isAssigning?: number;
-    computedChildOfNode?: NodeValue;
+    parentOther?: NodeValue;
     functions?: Map<string, Function | ObservableComputed<any>>;
 }
 export interface RootNodeValue extends BaseNodeValue {
@@ -326,22 +362,6 @@ export interface ObserveEventCallback<T> {
     onCleanup?: () => void;
     onCleanupReaction?: () => void;
 }
-export interface ObservablePersistenceConfigLocalOptions {
-    onLoadError?: (error: Error) => void;
-    onSaveError?: (error: Error) => void;
-    indexedDB?: {
-        databaseName: string;
-        version: number;
-        tableNames: string[];
-    };
-}
-export interface ObservablePersistenceConfig {
-    persistLocal?: ClassConstructor<ObservablePersistLocal>;
-    persistRemote?: ClassConstructor<ObservablePersistRemote>;
-    persistLocalOptions?: ObservablePersistenceConfigLocalOptions;
-    saveTimeout?: number;
-    dateModifiedKey?: string;
-}
 export type ObservableProxy<T extends Record<string, any>> = {
     [K in keyof T]: ObservableComputed<T[K]>;
 } & ObservableBaseFns<T> & {
@@ -357,4 +377,8 @@ export type ObservableProxyTwoWay<T extends Record<string, any>, T2> = {
 } & ObservableBaseFns<T> & {
     [symbolGetNode]: NodeValue;
 };
+export type PromiseInfo = {
+    error?: any;
+    status?: 'pending' | 'rejected';
+};
 export {};

package/src/observe.d.ts

@@ -4,4 +4,4 @@ export interface ObserveOptions {
     retainObservable?: boolean;
 }
 export declare function observe<T>(run: (e: ObserveEvent<T>) => T | void, options?: ObserveOptions): () => void;
-export declare function observe<T>(selector: Selector<T>, reaction?: (e: ObserveEventCallback<T>) => any, options?: ObserveOptions): () => void;
+export declare function observe<T>(selector: Selector<T> | ((e: ObserveEvent<T>) => any), reaction?: (e: ObserveEventCallback<T>) => any, options?: ObserveOptions): () => void;

package/src/persist/observablePersistRemoteFunctionsAdapter.d.ts

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

package/src/persist/persistObservable.d.ts

@@ -1,15 +1,13 @@
-import type { ClassConstructor, FieldTransforms, Observable, ObservableObject, ObservablePersistLocal, ObservablePersistRemote, ObservablePersistState, ObservableWriteable, PersistOptions, TypeAtPath } from '@legendapp/state';
-export declare const mapPersistences: WeakMap<ClassConstructor<ObservablePersistLocal | ObservablePersistRemote>, {
-    persist: ObservablePersistLocal | ObservablePersistRemote;
+import type { ClassConstructor, FieldTransforms, Observable, ObservableObject, ObservablePersistLocal, ObservablePersistRemoteClass, ObservablePersistState, ObservableWriteable, PersistOptions, PersistTransform, TypeAtPath } from '@legendapp/state';
+export declare const mapPersistences: WeakMap<ClassConstructor<ObservablePersistLocal | ObservablePersistRemoteClass>, {
+    persist: ObservablePersistLocal | ObservablePersistRemoteClass;
     initialized?: Observable<boolean>;
 }>;
 export declare const persistState: ObservableObject<{
     inRemoteSync: boolean;
 }>;
-export declare function adjustSaveData(value: any, path: string[], pathTypes: TypeAtPath[], { adjustData, fieldTransforms, }: {
-    adjustData?: {
-        save?: (value: any) => any;
-    };
+export declare function transformOutData(value: any, path: string[], pathTypes: TypeAtPath[], { transform, fieldTransforms }: {
+    transform?: PersistTransform;
     fieldTransforms?: FieldTransforms<any>;
 }): {
     value: any;
@@ -18,11 +16,10 @@ export declare function adjustSaveData(value: any, path: string[], pathTypes: Ty
     value: any;
     path: string[];
 }>;
-export declare function adjustLoadData(value: any, { adjustData, fieldTransforms, }: {
+export declare function transformLoadData(value: any, { transform, fieldTransforms }: {
     fieldTransforms?: FieldTransforms<any>;
-    adjustData?: {
-        load?: (value: any) => any;
-    };
-}, doUserAdjustData: boolean): Promise<any> | any;
+    transform?: PersistTransform;
+}, doUserTransform: boolean): Promise<any> | any;
 export declare function onChangeRemote(cb: () => void): void;
-export declare function persistObservable<T>(obs: ObservableWriteable<T>, persistOptions: PersistOptions<T>): ObservableObject<ObservablePersistState>;
+export declare function persistObservable<T, TState = {}>(observable: ObservableWriteable<T>, persistOptions: PersistOptions<T, TState>): [Observable<T>, ObservableObject<ObservablePersistState & TState>];
+export declare function persistObservable<T, TState = {}>(initial: T | (() => T) | (() => Promise<T>), persistOptions: PersistOptions<T, TState>): [Observable<T>, ObservableObject<ObservablePersistState & TState>];

package/src/persist-plugins/async-storage.d.ts

@@ -0,0 +1,14 @@
+import type { Change, ObservablePersistLocal, ObservablePersistenceConfigLocalGlobalOptions, PersistMetadata } from '@legendapp/state';
+export declare class ObservablePersistAsyncStorage implements ObservablePersistLocal {
+    private data;
+    initialize(config: ObservablePersistenceConfigLocalGlobalOptions): Promise<void>;
+    loadTable(table: string): void | Promise<void>;
+    getTable(table: string): any;
+    getMetadata(table: string): PersistMetadata;
+    set(table: string, changes: Change[]): Promise<void>;
+    setMetadata(table: string, metadata: PersistMetadata): Promise<void>;
+    deleteTable(table: string): Promise<void>;
+    deleteMetadata(table: string): Promise<void>;
+    private setValue;
+    private save;
+}

package/src/persist-plugins/fetch.d.ts

@@ -0,0 +1,10 @@
+import { ObservablePersistRemoteFunctions } from '@legendapp/state';
+interface PersistFetchProps {
+    get: string | RequestInfo;
+    set?: string | RequestInfo;
+    getInit?: RequestInit;
+    setInit?: RequestInit;
+    valueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text';
+}
+export declare function persistPluginFetch({ get, set, getInit, setInit, valueType, }: PersistFetchProps): ObservablePersistRemoteFunctions;
+export {};

package/src/persist-plugins/firebase.d.ts

@@ -0,0 +1,51 @@
+import { ObservablePersistRemoteClass, ObservablePersistRemoteGetParams, ObservablePersistRemoteSetParams } from '@legendapp/state';
+import { type User } from 'firebase/auth';
+import type { DataSnapshot } from 'firebase/database';
+import { DatabaseReference } from 'firebase/database';
+interface FirebaseFns {
+    isInitialized: () => boolean;
+    getCurrentUser: () => string | undefined;
+    ref: (path: string) => DatabaseReference;
+    orderByChild: (ref: any, child: string, startAt: number) => any;
+    once: (query: any, callback: (snapshot: DataSnapshot) => unknown, onError: (error: Error) => void) => () => void;
+    onChildAdded: (query: any, callback: (snapshot: DataSnapshot) => unknown, cancelCallback?: (error: Error) => unknown) => () => void;
+    onChildChanged: (query: any, callback: (snapshot: DataSnapshot) => unknown, cancelCallback?: (error: Error) => unknown) => () => void;
+    serverTimestamp: () => any;
+    update: (object: object) => Promise<void>;
+    onAuthStateChanged: (cb: (user: User | null) => void) => void;
+}
+declare class ObservablePersistFirebaseBase implements ObservablePersistRemoteClass {
+    protected _batch: Record<string, any>;
+    protected fns: FirebaseFns;
+    private _pathsLoadStatus;
+    private SaveTimeout;
+    private user;
+    private listenErrors;
+    private saveStates;
+    constructor(fns: FirebaseFns);
+    get<T>(params: ObservablePersistRemoteGetParams<T>): Promise<void>;
+    private iterateListen;
+    private retryListens;
+    private _listen;
+    private _updatePendingSave;
+    set<T>({ options, changes, obs }: ObservablePersistRemoteSetParams<T>): Promise<{
+        changes?: object;
+        dateModified?: number;
+        pathStrs?: string[];
+    } | undefined>;
+    private _constructBatch;
+    private _constructBatchesForSave;
+    private _onTimeoutSave;
+    private _saveBatch;
+    private _convertFBTimestamps;
+    private _onceValue;
+    private _onChange;
+    private insertDateToObject;
+    private insertDatesToSaveObject;
+    private insertDatesToSave;
+    private addValuesToPendingSaves;
+}
+export declare class ObservablePersistFirebase extends ObservablePersistFirebaseBase {
+    constructor();
+}
+export {};

package/src/persist-plugins/indexeddb.d.ts

@@ -8,12 +8,11 @@ export declare class ObservablePersistIndexedDB implements ObservablePersistLoca
     private pendingSaves;
     private promisesQueued;
     constructor();
-    initialize(config: ObservablePersistenceConfig['persistLocalOptions']): Promise<void>;
+    initialize(config: ObservablePersistenceConfig['localOptions']): Promise<void>;
     loadTable(table: string, config: PersistOptionsLocal): void | Promise<void>;
     getTable(table: string, config: PersistOptionsLocal): any;
-    getTableTransformed<T = any>(table: string, config: PersistOptionsLocal<any>): T;
     getMetadata(table: string, config: PersistOptionsLocal): any;
-    updateMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<IDBRequest<IDBValidKey>>;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<IDBRequest<IDBValidKey>>;
     deleteMetadata(table: string, config: PersistOptionsLocal): Promise<void>;
     set(table: string, changes: Change[], config: PersistOptionsLocal): Promise<void>;
     private doSave;

package/src/persist-plugins/local-storage.d.ts

@@ -5,9 +5,8 @@ declare class ObservablePersistLocalStorageBase implements ObservablePersistLoca
     constructor(storage: Storage | undefined);
     getTable(table: string): any;
     getMetadata(table: string): PersistMetadata;
-    get(table: string, id: string): any;
     set(table: string, changes: Change[]): void;
-    updateMetadata(table: string, metadata: PersistMetadata): void;
+    setMetadata(table: string, metadata: PersistMetadata): void;
     deleteTable(table: string): undefined;
     deleteMetadata(table: string): void;
     private setValue;

package/src/persist-plugins/mmkv.d.ts

@@ -4,10 +4,10 @@ export declare class ObservablePersistMMKV implements ObservablePersistLocal {
     private storages;
     getTable<T = any>(table: string, config: PersistOptionsLocal): T;
     getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata;
-    set(table: string, changes: Change[], config: PersistOptionsLocal): Promise<void>;
-    updateMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<void>;
-    deleteTable(table: string, config: PersistOptionsLocal): Promise<void>;
-    deleteMetadata(table: string, config: PersistOptionsLocal): Promise<void>;
+    set(table: string, changes: Change[], config: PersistOptionsLocal): void;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<void>;
+    deleteTable(table: string, config: PersistOptionsLocal): void;
+    deleteMetadata(table: string, config: PersistOptionsLocal): void;
     private getStorage;
     private setValue;
     private save;

package/src/persist-plugins/query.d.ts

@@ -0,0 +1,20 @@
+import { ObservablePersistRemoteFunctions } from '@legendapp/state';
+import { QueryClient, QueryKey, UseBaseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+type ObservableQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey> = Omit<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryKey'> & {
+    queryKey?: TQueryKey | (() => TQueryKey);
+};
+type Params<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey> = {
+    query: ObservableQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    mutation?: UseMutationOptions<TData, TError, void>;
+    type?: 'Query' | 'Infinite';
+} & ({
+    queryClient: QueryClient;
+    useContext?: false | undefined | never;
+} | {
+    queryClient?: QueryClient;
+    useContext?: true;
+});
+export declare function persistPluginQuery<TObs, TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>({ query: options, mutation: mutationOptions, type, queryClient, useContext, }: Params<TQueryFnData, TError, TData, TQueryData, TQueryKey>): ObservablePersistRemoteFunctions<TObs, {
+    query: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+}>;
+export {};

package/src/react/For.d.ts

@@ -1,6 +1,6 @@
 import type { Observable, ObservableReadable } from '@legendapp/state';
 import { FC, ReactElement } from 'react';
-export declare function For<T, TProps>({ each, eachValues, optimized: isOptimized, item, itemProps, sortValues, children, }: {
+export declare function For<T, TProps>({ each, optimized: isOptimized, item, itemProps, sortValues, children, }: {
     each?: ObservableReadable<T[] | Record<any, T> | Map<any, T>>;
     eachValues?: ObservableReadable<Record<any, T> | Map<any, T>>;
     optimized?: boolean;

package/src/react/react-globals.d.ts

@@ -0,0 +1,3 @@
+export declare const reactGlobals: {
+    inObserver: boolean;
+};

package/src/react/reactInterfaces.d.ts

@@ -17,5 +17,5 @@ export type FCReactive<P, P2> = P & FC<ShapeWithNew$<P2> & {
     ref?: LegacyRef<P> | undefined;
 }>;
 export interface UseSelectorOptions {
-    suspend?: boolean;
+    suspense?: boolean;
 }

package/src/react/reactive-observer.d.ts

@@ -1,10 +1,7 @@
 import { Selector } from '@legendapp/state';
 import { FC } from 'react';
 import type { BindKeys } from './reactInterfaces';
-type ShapeWithOld$<T, T2 extends keyof T = keyof T> = {
-    [K in T2 as K extends `${string & K}$` ? K : `${string & K}$`]?: Selector<T[K]>;
-};
-export type ShapeWith$<T, T2 extends keyof T = keyof T> = Partial<T> & ShapeWithOld$<T, T2> & {
+export type ShapeWith$<T, T2 extends keyof T = keyof T> = Partial<T> & {
     [K in T2 as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
 };
 export type ObjectShapeWith$<T> = {
@@ -15,4 +12,3 @@ export declare function observer<P = object>(component: FC<P>): FC<P>;
 export declare function reactive<P = object, P2 extends keyof P = keyof P>(component: FC<P>, bindKeys?: BindKeys<P>): FC<ShapeWith$<P, P2>>;
 export declare function reactiveObserver<P = object>(component: FC<P>, bindKeys?: BindKeys<P>): FC<ShapeWith$<P, keyof P>>;
 export declare function reactiveComponents<P extends Record<string, FC>>(components: P): ObjectShapeWith$<P>;
-export {};

package/src/react/useObservableState.d.ts

@@ -0,0 +1,2 @@
+import { type Observable } from '@legendapp/state';
+export declare function useObservableState<T>(initialValue?: T | (() => T) | (() => Promise<T>)): [Observable<T>, T];

package/src/react/useSelector.d.ts

@@ -1,3 +1,3 @@
 import { Selector } from '@legendapp/state';
-import { UseSelectorOptions } from 'src/react/reactInterfaces';
+import type { UseSelectorOptions } from './reactInterfaces';
 export declare function useSelector<T>(selector: Selector<T>, options?: UseSelectorOptions): T;

package/src/react/useWhen.d.ts

@@ -0,0 +1,3 @@
+import { Selector } from '@legendapp/state';
+export declare function useWhen<T>(predicate: Selector<T>, effect: (value: T) => any | (() => any)): Promise<T>;
+export declare function useWhenReady<T>(predicate: Selector<T>, effect: (value: T) => any | (() => any)): Promise<T>;

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

@@ -1,4 +1,4 @@
-import { Observable, PersistOptions } from '@legendapp/state';
+import { Observable, ObservableObject, ObservablePersistState, PersistOptions } from '@legendapp/state';
 /**
  * A React hook that creates a new observable and can optionally listen or persist its state.
  *
@@ -7,4 +7,4 @@ import { Observable, PersistOptions } from '@legendapp/state';
  *
  * @see https://www.legendapp.com/dev/state/react/#useObservable
  */
-export declare function usePersistedObservable<T>(initialValue?: T | (() => T) | (() => Promise<T>), options?: PersistOptions<T>): Observable<T>;
+export declare function usePersistedObservable<T>(initialValue: T | (() => T) | (() => Promise<T>), options: PersistOptions<T>): [Observable<T>, ObservableObject<ObservablePersistState>];

package/src/trackSelector.d.ts

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

package/src/tracking.d.ts

@@ -6,9 +6,8 @@ interface TrackingState {
 }
 export declare const tracking: {
     current: TrackingState | undefined;
-    inRender: boolean | undefined;
 };
-export declare function beginTracking(inRender?: boolean): void;
-export declare function endTracking(fromRender?: boolean): void;
+export declare function beginTracking(): void;
+export declare function endTracking(): void;
 export declare function updateTracking(node: NodeValue, track?: TrackingType): void;
 export {};

package/config/disableDeprecationWarnings.d.ts

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

package/config/disableDeprecationWarnings.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var state = require('@legendapp/state');
-
-function disableDeprecationWarnings() {
-    state.internal.globalState.noDepWarn = true;
-}
-
-exports.disableDeprecationWarnings = disableDeprecationWarnings;
-//# sourceMappingURL=disableDeprecationWarnings.js.map

package/config/disableDeprecationWarnings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"disableDeprecationWarnings.js","sources":["../../../../src/config/disableDeprecationWarnings.ts"],"sourcesContent":[null],"names":["internal"],"mappings":";;;;SAEgB,0BAA0B,GAAA;AACtC,IAAAA,cAAQ,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC;AAC1C;;;;"}

package/config/disableDeprecationWarnings.mjs

@@ -1,8 +0,0 @@
-import { internal } from '@legendapp/state';
-
-function disableDeprecationWarnings() {
-    internal.globalState.noDepWarn = true;
-}
-
-export { disableDeprecationWarnings };
-//# sourceMappingURL=disableDeprecationWarnings.mjs.map

package/config/disableDeprecationWarnings.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"disableDeprecationWarnings.mjs","sources":["../../../../src/config/disableDeprecationWarnings.ts"],"sourcesContent":[null],"names":[],"mappings":";;SAEgB,0BAA0B,GAAA;AACtC,IAAA,QAAQ,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC;AAC1C;;;;"}