@legendapp/state 2.0.0 → 2.0.1

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,32 @@ 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;
+}
+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 +269,9 @@ export interface ObservablePersistState {
         v?: any;
     }> | undefined;
 }
+export interface WithPersistState {
+    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 +337,7 @@ export interface NodeValueListener {
 interface BaseNodeValue {
     children?: Map<string, ChildNodeValue>;
     proxy?: object;
+    isActivatedPrimitive?: boolean;
     root: ObservableRoot;
     listeners?: Set<NodeValueListener>;
     listenersImmediate?: Set<NodeValueListener>;
@@ -339,6 +351,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 +391,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, TypeAtPath, WithPersistState } from '@legendapp/state';
 export declare const mapPersistences: WeakMap<ClassConstructor<ObservablePersistLocal | ObservablePersistRemoteClass>, {
     persist: ObservablePersistLocal | ObservablePersistRemoteClass;
     initialized?: Observable<boolean>;
@@ -21,5 +21,5 @@ 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 declare function persistObservable<T>(observable: ObservableWriteable<T>, persistOptions: PersistOptions<T>): Observable<WithPersistState & T>;
+export declare function persistObservable<T>(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,4 @@
-import { Observable, ObservableObject, ObservablePersistState, PersistOptions } from '@legendapp/state';
+import { Observable, PersistOptions, WithPersistState } 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, 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>(initialValue: T | (() => T) | (() => Promise<T>), options: PersistOptions<T>): Observable<WithPersistState & T>;