@legendapp/state 2.0.0 → 2.0.2

package/src/ObservableObject.d.ts

@@ -1,12 +1,12 @@
-import type { NodeValue, TrackingType } from './observableInterfaces';
+import type { GetOptions, NodeValue, ObservableObject, TrackingType } from './observableInterfaces';
 export declare const observableProperties: Map<string, {
     get: (node: NodeValue, ...args: any[]) => any;
     set: (node: NodeValue, value: any) => any;
 }>;
 export declare const observableFns: Map<string, (node: NodeValue, ...args: any[]) => any>;
-export declare function getProxy(node: NodeValue, p?: string): object;
+export declare function getProxy(node: NodeValue, p?: string): ObservableObject;
 export declare function set(node: NodeValue, newValue?: any): any;
 export declare function extractPromise(node: NodeValue, value: Promise<any>): void;
 export declare function extractFunctionOrComputed(node: NodeValue, obj: Record<string, any>, k: string, v: any): true | undefined;
-export declare function get(node: NodeValue, track?: TrackingType): any;
+export declare function get(node: NodeValue, options?: TrackingType | GetOptions): any;
 export declare function peek(node: NodeValue): any;

package/src/config/enableReactDirectRender.d.ts

@@ -0,0 +1,2 @@
+export declare const hasSymbol: false | ((key: string) => symbol);
+export declare function enableReactDirectRender(): void;

package/src/config/enableReactTracking.d.ts

@@ -0,0 +1,15 @@
+import { type TrackingType } from '@legendapp/state';
+interface ReactTrackingOptions {
+    auto?: boolean;
+    warnUnobserved?: boolean;
+}
+export declare function enableReactTracking({ auto, warnUnobserved }: ReactTrackingOptions): void;
+import type { GetOptions } from '@legendapp/state';
+declare module '@legendapp/state' {
+    interface ObservableBaseFns<T> {
+        get(options?: TrackingType | (GetOptions & {
+            suspense?: boolean;
+        })): T;
+    }
+}
+export {};

package/src/createObservable.d.ts

@@ -0,0 +1,2 @@
+import type { ObservableObjectOrArray, ObservablePrimitive } from './observableInterfaces';
+export declare function createObservable<T>(value: T | undefined, makePrimitive: boolean, createObject: Function, createPrimitive?: Function): ObservablePrimitive<T> | ObservableObjectOrArray<T>;

package/src/globals.d.ts

@@ -4,6 +4,8 @@ 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 globalState: {
     isLoadingLocal: boolean;
     isLoadingRemote: boolean;

package/src/helpers.d.ts

@@ -7,9 +7,9 @@ export declare function getObservableIndex(obs: ObservableReadable): number;
 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[], value: any, mode: 'assign' | 'set'): void;
+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 constructObjectWithPath(path: string[], value: any, pathTypes: TypeAtPath[]): object;
-export declare function deconstructObjectWithPath(path: string[], value: any): object;
+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;
 export declare function setSilently(obs: ObservableReadable, newValue: any): any;

package/src/observable.d.ts

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

package/src/observableInterfaces.d.ts

@@ -42,9 +42,12 @@ export interface MapGet<T extends Map<any, any> | WeakMap<any, any>> {
     get(): T;
     size: ObservableChild<number>;
 }
+export interface GetOptions {
+    shallow: boolean;
+}
 export interface ObservableBaseFns<T> {
     peek(): T;
-    get(trackingType?: TrackingType): T;
+    get(options?: TrackingType | GetOptions): T;
     onChange(cb: ListenerFn<T>, options?: {
         trackingType?: TrackingType;
         initial?: boolean;
@@ -93,7 +96,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 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 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 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]>>>;
 };
@@ -190,11 +193,11 @@ export interface ObservablePersistenceConfig {
     localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
     remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
 }
-export interface PersistOptions<T = any, TState = {}> {
+export interface PersistOptions<T = any> {
     local?: string | PersistOptionsLocal<T>;
     remote?: PersistOptionsRemote<T>;
     pluginLocal?: ClassConstructor<ObservablePersistLocal>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T, TState>;
+    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
 }
 export interface PersistMetadata {
     id?: '__legend_metadata';
@@ -218,10 +221,10 @@ export interface ObservablePersistRemoteSetParams<T> {
     changes: Change[];
     value: T;
 }
-export interface ObservablePersistRemoteGetParams<T, TState = {}> {
-    state: Observable<ObservablePersistState & TState>;
+export interface ObservablePersistRemoteGetParams<T> {
+    state: Observable<ObservablePersistState>;
     obs: ObservableReadable<T>;
-    options: PersistOptions<T, TState>;
+    options: PersistOptions<T>;
     dateModified?: number;
     onGet: () => void;
     onChange: (params: {
@@ -232,27 +235,33 @@ export interface ObservablePersistRemoteGetParams<T, TState = {}> {
         dateModified?: number | undefined;
     }) => void | Promise<void>;
 }
-export interface ObservablePersistRemoteClass<TState = {}> {
-    get<T>(params: ObservablePersistRemoteGetParams<T, TState>): void;
+export interface ObservablePersistRemoteClass {
+    get<T>(params: ObservablePersistRemoteGetParams<T>): 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>;
+export interface ObservablePersistRemoteFunctions<T = any> {
+    get(params: ObservablePersistRemoteGetParams<T>): T | Promise<T>;
     set?(params: ObservablePersistRemoteSetParams<T>): Promise<void | {
         changes?: object | undefined;
         dateModified?: number;
     }>;
 }
-export interface ObservablePersistState {
+export interface ObservableState {
+    isLoaded: boolean;
+    error?: Error;
+}
+export interface WithState {
+    state?: ObservableState;
+    _state?: ObservableState;
+}
+export interface ObservablePersistState extends ObservableState {
     isLoadedLocal: boolean;
-    isLoadedRemote: boolean;
     isEnabledLocal: boolean;
     isEnabledRemote: boolean;
-    remoteError?: Error;
     dateModified?: number;
     clearLocal: () => Promise<void>;
     sync: () => Promise<void>;
@@ -261,6 +270,10 @@ export interface ObservablePersistState {
         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;
@@ -326,6 +339,7 @@ export interface NodeValueListener {
 interface BaseNodeValue {
     children?: Map<string, ChildNodeValue>;
     proxy?: object;
+    isActivatedPrimitive?: boolean;
     root: ObservableRoot;
     listeners?: Set<NodeValueListener>;
     listenersImmediate?: Set<NodeValueListener>;
@@ -339,6 +353,7 @@ interface BaseNodeValue {
     parentOther?: NodeValue;
     functions?: Map<string, Function | ObservableComputed<any>>;
     lazy?: boolean;
+    state?: Observable<ObservableState>;
 }
 export interface RootNodeValue extends BaseNodeValue {
     parent?: undefined;
@@ -378,8 +393,4 @@ 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

@@ -1,7 +1,6 @@
 import { ObserveEvent, ObserveEventCallback, Selector } from './observableInterfaces';
 export interface ObserveOptions {
     immediate?: boolean;
-    retainObservable?: boolean;
 }
 export declare function observe<T>(run: (e: ObserveEvent<T>) => T | void, 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

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

package/src/persist/persistObservable.d.ts

@@ -1,4 +1,4 @@
-import type { ClassConstructor, FieldTransforms, Observable, ObservableObject, ObservablePersistLocal, ObservablePersistRemoteClass, ObservablePersistState, ObservableWriteable, PersistOptions, PersistTransform, TypeAtPath } from '@legendapp/state';
+import type { ClassConstructor, FieldTransforms, Observable, ObservableObject, ObservablePersistLocal, ObservablePersistRemoteClass, ObservableWriteable, PersistOptions, PersistTransform, Primitive, TypeAtPath, WithPersistState } from '@legendapp/state';
 export declare const mapPersistences: WeakMap<ClassConstructor<ObservablePersistLocal | ObservablePersistRemoteClass>, {
     persist: ObservablePersistLocal | ObservablePersistRemoteClass;
     initialized?: Observable<boolean>;
@@ -21,5 +21,8 @@ export declare function transformLoadData(value: any, { transform, fieldTransfor
     transform?: PersistTransform;
 }, doUserTransform: boolean): Promise<any> | any;
 export declare function onChangeRemote(cb: () => void): void;
-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>];
+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>;

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

@@ -14,7 +14,5 @@ type Params<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>
     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 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>;
 export {};

package/src/react/For.d.ts

@@ -1,13 +1,15 @@
 import type { Observable, ObservableReadable } from '@legendapp/state';
 import { FC, ReactElement } from 'react';
+type ForItemProps<T, TProps = {}> = {
+    item$: Observable<T>;
+    id?: string;
+} & TProps;
 export declare function For<T, TProps>({ each, optimized: isOptimized, item, itemProps, sortValues, children, }: {
     each?: ObservableReadable<T[] | Record<any, T> | Map<any, T>>;
     optimized?: boolean;
-    item?: FC<{
-        item: Observable<T>;
-        id?: string;
-    } & TProps>;
+    item?: FC<ForItemProps<T, TProps>>;
     itemProps?: TProps;
     sortValues?: (A: T, B: T, AKey: string, BKey: string) => number;
-    children?: (value: Observable<T>) => ReactElement;
+    children?: (value: Observable<T>, id: string | undefined) => ReactElement;
 }): ReactElement | null;
+export {};

package/src/react/useMount.d.ts

@@ -1,3 +1,2 @@
-import type { EffectCallback } from 'react';
-export declare function useMount(fn: EffectCallback): void;
+export declare function useMount(fn: () => (void | (() => void)) | Promise<void>): void;
 export declare const useMountOnce: (effect: () => void | (() => void)) => void;

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

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