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

package/src/config/enableReactNativeComponents.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="react" />
-import { FCReactive, FCReactiveObject } from '@legendapp/state/react';
-import { ActivityIndicator, ActivityIndicatorProps, Button, ButtonProps, FlatList, FlatListProps, Image, ImageProps, Pressable, PressableProps, ScrollView, ScrollViewProps, SectionList, SectionListProps, Switch, SwitchProps, Text, TextInput, TextInputProps, TextProps, TouchableWithoutFeedback, TouchableWithoutFeedbackProps, View, ViewProps } from 'react-native';
-export declare function enableReactNativeComponents(): void;
-declare module '@legendapp/state/react' {
-    interface IReactive extends FCReactiveObject<JSX.IntrinsicElements> {
-        ActivityIndicator: FCReactive<ActivityIndicator, ActivityIndicatorProps>;
-        Button: FCReactive<Button, ButtonProps>;
-        FlatList: FCReactive<FlatList, FlatListProps<any>>;
-        Image: FCReactive<Image, ImageProps>;
-        Pressable: FCReactive<typeof Pressable, PressableProps>;
-        ScrollView: FCReactive<ScrollView, ScrollViewProps>;
-        SectionList: FCReactive<SectionList, SectionListProps<any>>;
-        Switch: FCReactive<Switch, SwitchProps>;
-        Text: FCReactive<Text, TextProps>;
-        TextInput: FCReactive<TextInput, TextInputProps>;
-        TouchableWithoutFeedback: FCReactive<TouchableWithoutFeedback, TouchableWithoutFeedbackProps>;
-        View: FCReactive<View, ViewProps>;
-    }
-}

package/src/config/enableReactTracking.d.ts

@@ -1,15 +0,0 @@
-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/config/enableReactUse.d.ts

@@ -1,7 +0,0 @@
-import { UseSelectorOptions } from '@legendapp/state/react';
-export declare function enableReactUse(): void;
-declare module '@legendapp/state' {
-    interface ObservableBaseFns<T> {
-        use(options?: UseSelectorOptions): T;
-    }
-}

package/src/config.d.ts

@@ -1,8 +0,0 @@
-import type { NodeValue } from './observableInterfaces';
-export declare function configureLegendState({ observableFunctions, observableProperties, }: {
-    observableFunctions?: Record<string, (node: NodeValue, ...args: any[]) => any>;
-    observableProperties?: Record<string, {
-        get: (node: NodeValue) => any;
-        set: (node: NodeValue, value: any) => any;
-    }>;
-}): void;

package/src/createObservable.d.ts

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

package/src/event.d.ts

@@ -1,2 +0,0 @@
-import type { ObservableEvent } from './observableInterfaces';
-export declare function event(): ObservableEvent;

package/src/globals.d.ts

@@ -1,32 +0,0 @@
-import { NodeValue, ObservableComputed, ObservableObject, ObservableReadable, UpdateFn } from './observableInterfaces';
-export declare const symbolToPrimitive: symbol;
-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;
-    isMerging: boolean;
-    isLoadingRemote$: import("./observableInterfaces").ObservablePrimitiveBaseFns<boolean> & import("./observableInterfaces").ObservablePrimitiveBooleanFns<boolean>;
-    activateNode: (node: NodeValue, refresh: () => void, wasPromise: boolean, newValue: any) => {
-        update: UpdateFn;
-    };
-};
-export declare function isObservable(obs: any): obs is ObservableObject;
-export declare function isComputed(obs: any): obs is ObservableComputed;
-export declare function checkActivate(node: NodeValue): void;
-export declare function getNode(obs: ObservableReadable): NodeValue;
-export declare function setNodeValue(node: NodeValue, newValue: any): {
-    prevValue: any;
-    newValue: any;
-    parentValue: any;
-};
-export declare function getNodeValue(node: NodeValue): any;
-export declare const cloneFunction: (originalFunction: Function) => (...args: any[]) => any;
-export declare function getChildNode(node: NodeValue, key: string, asFunction?: Function): NodeValue;
-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;

package/src/helpers/fetch.d.ts

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

package/src/helpers/pageHash.d.ts

@@ -1,7 +0,0 @@
-import { Observable } from '@legendapp/state';
-interface Options {
-    setter: 'pushState' | 'replaceState' | 'hash';
-}
-declare function configurePageHash(options: Options): void;
-declare const pageHash: Observable<string>;
-export { configurePageHash, pageHash };

package/src/helpers/pageHashParams.d.ts

@@ -1,7 +0,0 @@
-import { Observable } from '@legendapp/state';
-interface Options {
-    setter: 'pushState' | 'replaceState' | 'hash';
-}
-declare function configurePageHashParams(options: Options): void;
-declare const pageHashParams: Observable<Record<string, string>>;
-export { configurePageHashParams, pageHashParams };

package/src/helpers/time.d.ts

@@ -1,3 +0,0 @@
-declare const currentTime: import("@legendapp/state").ObservableObject<Date>;
-declare const currentDay: import("@legendapp/state").ObservableObject<Date>;
-export { currentTime, currentDay };

package/src/helpers.d.ts

@@ -1,13 +0,0 @@
-import type { ObservableEvent, ObservableObject, ObservableReadable, ObservableWriteable, ObserveEvent, OpaqueObject, Selector, TypeAtPath } from './observableInterfaces';
-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;
-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 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/history/trackHistory.d.ts

@@ -1,4 +0,0 @@
-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 {};

package/src/is.d.ts

@@ -1,10 +0,0 @@
-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>;
-export declare function isFunction(obj: unknown): obj is Function;
-export declare function isPrimitive(arg: unknown): arg is string | number | bigint | boolean | symbol;
-export declare function isSymbol(obj: unknown): obj is symbol;
-export declare function isBoolean(obj: unknown): obj is boolean;
-export declare function isPromise<T>(obj: unknown): obj is Promise<T>;
-export declare function isEmpty(obj: object): boolean;

package/src/observable.d.ts

@@ -1,16 +0,0 @@
-import type { ActivateParams, ActivateProxyParams, Observable, ObservableComputed, ObservablePrimitive, RecordValue, WithState } from './observableInterfaces';
-type TWithFunctions<T> = T | {
-    [K in keyof T]: ((params: ActivateProxyParams<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: ActivateParams) => Observable<T>): Observable<T & WithState>;
-export declare function observable<T>(value: (params: ActivateParams) => Promise<T>): Observable<T & WithState>;
-export declare function observable<T>(value: (params: ActivateParams) => T): Observable<T>;
-export declare function observable<T>(value: (params: ActivateProxyParams<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>;
-export declare function observablePrimitive<T>(value?: T): ObservablePrimitive<T>;
-export {};

package/src/observableInterfaces.d.ts

@@ -1,456 +0,0 @@
-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;
-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: ActivateParams) => infer t ? t extends Observable ? t : Observable<t> : T[K] extends (params: ActivateProxyParams<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[];
-    pathTypes: TypeAtPath[];
-    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;
-    metadataTimeout?: number;
-    retry?: RetryOptions;
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    log?: (message?: any, ...optionalParams: any[]) => void;
-    onBeforeSet?: () => void;
-    onSet?: () => void;
-};
-export interface ObservablePersistenceConfigLocalGlobalOptions {
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    indexedDB?: {
-        databaseName: string;
-        version: number;
-        tableNames: string[];
-    };
-    asyncStorage?: {
-        AsyncStorage: AsyncStorageStatic;
-        preload?: boolean | string[];
-    };
-}
-export interface ObservablePersistenceConfigRemoteGlobalOptions {
-    saveTimeout?: number;
-    dateModifiedKey?: string;
-    offlineBehavior?: false | 'retry';
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    log?: (logLevel: 'verbose' | 'warning' | 'error', message: any, ...optionalParams: any[]) => void;
-    onBeforeSet?: () => void;
-    onSet?: () => void;
-}
-export interface ObservablePersistenceConfig {
-    pluginLocal?: ClassConstructor<ObservablePersistLocal>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions;
-    localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
-    remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
-}
-export interface PersistOptions<T = any> {
-    local?: string | PersistOptionsLocal<T>;
-    remote?: PersistOptionsRemote<T>;
-    pluginLocal?: ClassConstructor<ObservablePersistLocal>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
-}
-export interface PersistMetadata {
-    id?: '__legend_metadata';
-    modified?: number;
-    pending?: any;
-}
-export interface ObservablePersistLocal {
-    initialize?(config: ObservablePersistenceConfigLocalGlobalOptions): void | Promise<void>;
-    loadTable?(table: string, config: PersistOptionsLocal): Promise<any> | void;
-    getTable<T = any>(table: string, config: PersistOptionsLocal): T;
-    set(table: string, changes: Change[], config: PersistOptionsLocal): Promise<any> | void;
-    deleteTable(table: string, config: PersistOptionsLocal): Promise<any> | void;
-    getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata;
-    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<any> | void;
-    deleteMetadata(table: string, config: PersistOptionsLocal): Promise<any> | void;
-}
-export interface ObservableOnChangeParams {
-    value: unknown;
-    path?: string[];
-    pathTypes?: TypeAtPath[];
-    mode?: 'assign' | 'set' | 'dateModified';
-    dateModified?: number | undefined;
-}
-export interface ObservablePersistRemoteSetParams<T> {
-    syncState: Observable<ObservablePersistState>;
-    obs: Observable<T>;
-    options: PersistOptions<T>;
-    changes: Change[];
-    value: T;
-}
-export interface ObservablePersistRemoteGetParams<T> {
-    state: Observable<ObservablePersistState>;
-    obs: ObservableReadable<T>;
-    options: PersistOptions<T>;
-    dateModified?: number;
-    onGet: () => void;
-    onError: (error: Error) => void;
-    onChange: (params: ObservableOnChangeParams) => void | Promise<void>;
-}
-export type ObservablePersistRemoteGetFnParams<T> = Omit<ObservablePersistRemoteGetParams<T>, 'onGet'>;
-export interface ObservablePersistRemoteClass {
-    get?<T>(params: ObservablePersistRemoteGetParams<T>): void;
-    set?<T>(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
-        changes?: object;
-        dateModified?: number;
-        pathStrs?: string[];
-    }>;
-}
-export interface ObservablePersistRemoteFunctions<T = any> {
-    get?(params: ObservablePersistRemoteGetFnParams<T>): T | Promise<T>;
-    set?(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
-        changes?: object | undefined;
-        dateModified?: number;
-    }>;
-}
-export interface ObservableState {
-    isLoaded: boolean;
-    error?: Error;
-}
-export interface WithState {
-    state?: ObservableState;
-    _state?: ObservableState;
-}
-export interface ObservablePersistStateBase {
-    isLoadedLocal: boolean;
-    isEnabledLocal: boolean;
-    isEnabledRemote: boolean;
-    dateModified?: number;
-    syncCount?: number;
-    clearLocal: () => Promise<void>;
-    sync: () => Promise<void>;
-    getPendingChanges: () => Record<string, {
-        p: any;
-        v?: any;
-    }> | undefined;
-}
-export type ObservablePersistState = ObservableState & ObservablePersistStateBase;
-export type ObservablePersistStateInternal = ObservablePersistState & {
-    refreshNum: number;
-};
-export interface WithPersistState {
-    state?: ObservablePersistState;
-    _state?: ObservablePersistState;
-}
-export 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 ClassConstructor<I, Args extends any[] = any[]> = new (...args: Args) => I;
-export type ObservableListenerDispose = () => void;
-export interface ObservableRoot {
-    _: any;
-    locked?: boolean;
-    toActivate?: NodeValue[];
-    set?: (value: any) => void;
-    activate?: () => void;
-}
-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;
-    listener: ListenerFn;
-}
-interface BaseNodeValue {
-    children?: Map<string, ChildNodeValue>;
-    proxy?: object;
-    isActivatedPrimitive?: boolean;
-    root: ObservableRoot;
-    listeners?: Set<NodeValueListener>;
-    listenersImmediate?: Set<NodeValueListener>;
-    isComputed?: boolean;
-    proxyFn?: (key: string) => ObservableReadable;
-    isEvent?: boolean;
-    linkedToNode?: NodeValue;
-    linkedFromNodes?: Set<NodeValue>;
-    isSetting?: number;
-    isAssigning?: number;
-    parentOther?: NodeValue;
-    functions?: Map<string, Function | ObservableComputed<any>>;
-    lazy?: boolean | Function;
-    state?: Observable<ObservablePersistState>;
-    activated?: boolean;
-    proxyFn2?: (key: string, params: ActivateParams) => any;
-    activationState?: {
-        onSetFn?: (value: ListenerParams<any>, extra: OnSetExtra) => void | Promise<any>;
-        update?: UpdateFn;
-        subscriber?: (params: SubscribeOptions) => void;
-        retryOptions?: RetryOptions;
-        lastSync: {
-            value?: number;
-        };
-        cacheOptions?: CacheOptions;
-    };
-}
-export interface RootNodeValue extends BaseNodeValue {
-    parent?: undefined;
-    key?: undefined;
-}
-export interface ChildNodeValue extends BaseNodeValue {
-    parent: NodeValue;
-    key: string;
-}
-export type NodeValue = RootNodeValue | ChildNodeValue;
-export interface ObserveEvent<T> {
-    num: number;
-    previous?: T | undefined;
-    cancel?: boolean;
-    onCleanup?: () => void;
-}
-export interface ObserveEventCallback<T> {
-    num: number;
-    previous?: T | undefined;
-    value?: T;
-    cancel?: boolean;
-    onCleanup?: () => void;
-    onCleanupReaction?: () => void;
-}
-export type ObservableProxy<T extends Record<string, any>> = {
-    [K in keyof T]: ObservableComputed<T[K]>;
-} & ObservableBaseFns<T> & {
-    [symbolGetNode]: NodeValue;
-};
-export type ObservableProxyLink<T extends Record<string, any>> = {
-    [K in keyof T]: Observable<T[K]>;
-} & ObservableBaseFns<T> & {
-    [symbolGetNode]: NodeValue;
-};
-export type ObservableProxyTwoWay<T extends Record<string, any>, T2> = {
-    [K in keyof T]: ObservableComputedTwoWay<T[K], T2>;
-} & ObservableBaseFns<T> & {
-    [symbolGetNode]: NodeValue;
-};
-export interface CacheOptions<T = any> {
-    local: string | PersistOptionsLocal<T>;
-    pluginLocal?: ClassConstructor<ObservablePersistLocal, T[]>;
-}
-export interface ActivateParams<T = any> {
-    obs$: Observable<T>;
-    onSet: (fn: (params: ListenerParams<T>, extra: OnSetExtra) => void | Promise<any>) => void;
-    subscribe: (fn: (params: {
-        update: UpdateFn;
-        refresh: () => void;
-    }) => void) => void;
-}
-export interface ActivateProxyParams<T = any> extends ActivateParams {
-    proxy: (fn: (key: string, params: ActivateParams<T>) => T | Promise<T>) => void;
-}
-export type UpdateFn = (params: {
-    value: unknown;
-    mode?: 'assign' | 'set' | 'dateModified';
-    dateModified?: number | undefined;
-}) => void;
-export interface RetryOptions {
-    infinite?: boolean;
-    times?: number;
-    delay?: number;
-    backoff?: 'constant' | 'exponential';
-    maxDelay?: number;
-}
-export interface OnSetExtra {
-    update: UpdateFn;
-}
-export interface SubscribeOptions {
-    update: UpdateFn;
-    refresh: () => void;
-}
-export interface CacheReturnValue {
-    dateModified: number;
-    value: any;
-}
-export {};

package/src/observe.d.ts

@@ -1,6 +0,0 @@
-import { ObserveEvent, ObserveEventCallback, Selector } from './observableInterfaces';
-export interface ObserveOptions {
-    immediate?: 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/onChange.d.ts

@@ -1,7 +0,0 @@
-import type { ListenerFn, NodeValue, TrackingType } from './observableInterfaces';
-export declare function onChange(node: NodeValue, callback: ListenerFn, options?: {
-    trackingType?: TrackingType;
-    initial?: boolean;
-    immediate?: boolean;
-    noArgs?: boolean;
-}): () => void;

package/src/persist/configureObservablePersistence.d.ts

@@ -1,3 +0,0 @@
-import type { ObservablePersistenceConfig } from '@legendapp/state';
-export declare const observablePersistConfiguration: ObservablePersistenceConfig;
-export declare function configureObservablePersistence(options?: ObservablePersistenceConfig): void;