@legendapp/state 2.2.0-next.8 → 2.2.0-next.80

package/src/observableTypes.ts

@@ -0,0 +1,226 @@
+import type { GetOptions, ListenerFn, TrackingType } from './observableInterfaces';
+
+type Primitive = string | number | boolean | symbol | bigint | undefined | null | Date;
+type ArrayOverrideFnNames =
+    | 'find'
+    | 'every'
+    | 'some'
+    | 'filter'
+    | 'reduce'
+    | 'reduceRight'
+    | 'forEach'
+    | 'map'
+    | 'sort';
+
+type RemoveIndex<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+
+type BuiltIns = String | Boolean | Number | Date | Error | RegExp | Array<any> | Function | Promise<any>;
+
+type IsUserDefinedObject<T> =
+    // Only objects that are not function or arrays or instances of BuiltIns.
+    T extends Function | BuiltIns | any[] ? false : T extends object ? true : false;
+
+export type RemoveObservables<T> = T extends ImmutableObservableBase<infer t>
+    ? t
+    : IsUserDefinedObject<T> extends true
+    ? {
+          [K in keyof T]: RemoveObservables<T[K]>;
+      }
+    : T;
+
+interface ObservableArray<T, U>
+    extends ObservablePrimitive<T>,
+        Pick<Array<Observable<U>>, ArrayOverrideFnNames>,
+        Omit<RemoveIndex<Array<U>>, ArrayOverrideFnNames> {}
+
+interface ObservableObjectFns<T> {
+    assign(value: Partial<T>): Observable<T>;
+}
+
+interface ObservableObjectFunctions<T = Record<string, any>> extends ObservablePrimitive<T>, ObservableObjectFns<T> {}
+
+type MapKey<T extends Map<any, any> | WeakMap<any, any>> = Parameters<T['has']>[0];
+type MapValue<T extends Map<any, any> | WeakMap<any, any>> = Parameters<T['get']>[0];
+type ObservableMap<T extends Map<any, any> | WeakMap<any, any>> = Omit<T, 'get' | 'size'> &
+    Omit<ObservablePrimitive<T>, 'get' | 'size'> & {
+        get(key: Parameters<T['get']>[0]): Observable<Parameters<T['set']>[1]>;
+        get(): T;
+        size: ImmutableObservableBase<number>;
+        assign(
+            value: Record<MapKey<T>, MapValue<T>> | Map<MapKey<T>, MapValue<T>> | WeakMap<MapKey<T>, MapValue<T>>,
+        ): Observable<T>;
+    };
+
+type ObservableSet<T extends Set<any> | WeakSet<any>> = Omit<T, 'size'> &
+    Omit<ObservablePrimitive<T>, 'size'> & { size: ImmutableObservableBase<number> };
+
+interface ObservableBoolean extends ObservablePrimitive<boolean> {
+    toggle(): void;
+}
+
+interface ObservablePrimitive<T> extends ImmutableObservableBase<T>, MutableObservableBase<T> {}
+type ObservableAny = Partial<ObservableObjectFns<any>> & ObservablePrimitive<any> & Record<string, any>;
+
+interface ImmutableObservableSimple<T> {
+    peek(): T;
+    get(trackingType?: any): any;
+    onChange(cb: ListenerFn<any>, options?: any): () => void;
+}
+interface ImmutableObservableBase<T> extends ImmutableObservableSimple<T> {
+    peek(): RemoveObservables<T>;
+    peek(): T; // This is just to match the Simple base type
+    get(trackingType?: TrackingType | GetOptions): RemoveObservables<T>;
+    onChange(
+        cb: ListenerFn<T>,
+        options?: { trackingType?: TrackingType; initial?: boolean; immediate?: boolean; noArgs?: boolean },
+    ): () => void;
+}
+
+interface MutableObservableSimple {
+    set(value: any): void;
+    delete(): void;
+}
+interface MutableObservableBase<T> extends MutableObservableSimple {
+    set(value: (prev: RemoveObservables<T>) => RemoveObservables<T>): void;
+    set(value: RecursiveValueOrFunction<T>): void;
+    set(value: Promise<RemoveObservables<T>>): void;
+    set(value: RemoveObservables<T>): void;
+    set(value: Observable<RemoveObservables<T>>): void;
+    delete(): void;
+}
+
+type UndefinedIf<T, U> = U extends true ? T | undefined : T;
+
+type IsNullable<T> = undefined extends T ? true : null extends T ? true : false;
+
+type NonObservable = Function | Observable;
+type NonObservableKeys<T> = {
+    [K in keyof T]-?: IsStrictAny<T[K]> extends true
+        ? never
+        : T[K] extends undefined | null
+        ? never
+        : NonNullable<T[K]> extends NonObservable
+        ? K
+        : never;
+}[keyof T];
+type ObservableProps<T> = NonObservableKeys<NonNullable<T>> extends never
+    ? T
+    : RestoreNullability<T, Omit<NonNullable<T>, NonObservableKeys<NonNullable<T>>>>;
+
+type NonObservableProps<T> = RestoreNullability<
+    T,
+    NullablePropsIf<Pick<NonNullable<T>, NonObservableKeys<NonNullable<T>>>, IsNullable<T>>
+>;
+type NullablePropsIf<T, U> = {
+    [K in keyof T]: UndefinedIf<T[K], U>;
+};
+
+type RestoreNullability<Source, Target> = IsNullable<Source> extends true
+    ? Target | Extract<Source, null | undefined>
+    : Target;
+
+type ObservableChildren<T, Nullable = IsNullable<T>> = {
+    [K in keyof T]-?: Observable<UndefinedIf<T[K], Nullable>>;
+};
+type ObservableFunctionChildren<T> = {
+    [K in keyof T]-?: T[K] extends Observable
+        ? T[K]
+        : T[K] extends (key: infer Key extends string) => Promise<infer t> | infer t
+        ? HasOneStringParam<T[K]> extends true
+            ? Observable<Record<Key, t>> & T[K]
+            : t extends void
+            ? T[K]
+            : t extends Observable
+            ? t
+            : Observable<t> & (() => t)
+        : T[K];
+};
+
+type IsStrictAny<T> = 0 extends 1 & T ? true : false;
+
+export interface ObservableState {
+    isLoaded: boolean;
+    error?: Error;
+}
+
+type ObservableObject<T> = ObservableObjectFunctions<ObservableProps<T> & NonObservableProps<T>> &
+    ObservableChildren<ObservableProps<T>> &
+    ObservableFunctionChildren<NonObservableProps<T>>;
+
+type ObservableFunction<T> = T extends () => infer t ? t | (() => t) : T;
+
+// Check if the function type T has one lookup parameter
+type HasOneStringParam<T> = T extends (...args: infer P) => any
+    ? P extends { length: 1 }
+        ? P[0] extends string | ObservablePrimitive<string>
+            ? true
+            : false
+        : false
+    : false;
+
+// : [T] extends [(key: infer K extends string) => infer t]
+// ? // ?  HasParams<T> extends true ? Observable<Record<K, t>>
+type ObservableNode<T, NT = NonNullable<T>> = [NT] extends [never] // means that T is ONLY undefined or null
+    ? ObservablePrimitive<T>
+    : IsStrictAny<T> extends true
+    ? ObservableAny
+    : [T] extends [Promise<infer t>]
+    ? ObservableNode<t>
+    : [T] extends [(key: infer K extends string) => infer t]
+    ? [t] extends [ImmutableObservableBase<any>]
+        ? HasOneStringParam<T> extends true
+            ? Observable<Record<K, t>>
+            : t
+        : HasOneStringParam<T> extends true
+        ? Observable<Record<K, t>> & T
+        : Observable<ObservableFunction<t>>
+    : [NT] extends [ImmutableObservableBase<any>]
+    ? NT
+    : [NT] extends [Primitive]
+    ? [NT] extends [boolean]
+        ? ObservableBoolean
+        : ObservablePrimitive<T>
+    : NT extends Map<any, any> | WeakMap<any, any>
+    ? ObservableMap<NT>
+    : NT extends Set<infer U>
+    ? ObservableSet<Set<UndefinedIf<U, IsNullable<T>>>>
+    : NT extends WeakSet<any>
+    ? ObservableSet<NT> // TODO what to do here with nullable? WeakKey is type object | symbol
+    : NT extends Array<infer U>
+    ? ObservableArray<T, U> & ObservableChildren<T>
+    : ObservableObject<T> & {};
+
+// Note: The {} makes intellisense display observables as Observable instead of all the subtypes
+type Observable<T = any> = ObservableNode<T> & {};
+
+type ObservableParam<T = any> = ImmutableObservableSimple<T> & MutableObservableSimple;
+
+// Allow input types to have functions in them
+type ValueOrFunction<T> = T extends Function ? T : T | ImmutableObservableBase<T> | Promise<T> | (() => T | Promise<T>);
+type ValueOrFunctionKeys<T> = {
+    [K in keyof T]: RecursiveValueOrFunction<T[K]>;
+};
+
+type RecursiveValueOrFunction<T> = T extends Function
+    ? T
+    : T extends object
+    ?
+          | ((key: string) => any)
+          | Promise<ValueOrFunctionKeys<T>>
+          | ValueOrFunctionKeys<T>
+          | ImmutableObservableBase<T>
+          | (() => T | Promise<T> | ValueOrFunctionKeys<T> | Promise<ValueOrFunctionKeys<T>> | Observable<T>)
+    : ValueOrFunction<T>;
+
+export type {
+    // TODO: how to make these internal somehow?
+    ImmutableObservableBase,
+    Observable,
+    ObservableBoolean,
+    ObservableObject,
+    ObservablePrimitive,
+    ObservableParam,
+    RecursiveValueOrFunction,
+};

package/src/observe.ts

@@ -0,0 +1,89 @@
+import { beginBatch, endBatch } from './batching';
+import { isEvent } from './globals';
+import { isFunction } from './is';
+import { ObserveEvent, ObserveEventCallback, Selector } from './observableInterfaces';
+import { trackSelector } from './trackSelector';
+
+export interface ObserveOptions {
+    immediate?: boolean; // Ignore batching and run immediately
+    /* @internal */
+    fromComputed?: boolean;
+}
+
+export function observe<T>(run: (e: ObserveEvent<T>) => T | void, options?: ObserveOptions): () => void;
+export function observe<T>(
+    selector: Selector<T> | ((e: ObserveEvent<T>) => any),
+    reaction?: (e: ObserveEventCallback<T>) => any,
+    options?: ObserveOptions,
+): () => void;
+export function observe<T>(
+    selectorOrRun: Selector<T> | ((e: ObserveEvent<T>) => any),
+    reactionOrOptions?: ((e: ObserveEventCallback<T>) => any) | ObserveOptions,
+    options?: ObserveOptions,
+) {
+    let reaction: (e: ObserveEventCallback<T>) => any;
+    if (isFunction(reactionOrOptions)) {
+        reaction = reactionOrOptions;
+    } else {
+        options = reactionOrOptions;
+    }
+    let dispose: (() => void) | undefined;
+    const e: ObserveEventCallback<T> = { num: 0 } as ObserveEventCallback<T>;
+    // Wrap it in a function so it doesn't pass all the arguments to run()
+    const update = function () {
+        if (e.onCleanup) {
+            e.onCleanup();
+            e.onCleanup = undefined;
+        }
+
+        // Run in a batch so changes don't happen until we're done tracking here
+        beginBatch();
+
+        // Run the function/selector
+        delete e.value;
+
+        // Dispose listeners from previous run
+        dispose?.();
+
+        const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun as Selector<T>, update, e, options);
+        dispose = _dispose;
+
+        e.value = value;
+        e.nodes = nodes;
+        e.refresh = update;
+
+        if (e.onCleanupReaction) {
+            e.onCleanupReaction();
+            e.onCleanupReaction = undefined;
+        }
+
+        endBatch();
+
+        // Call the reaction if there is one and the value changed
+        if (
+            reaction &&
+            (options?.fromComputed ||
+                ((e.num > 0 || !isEvent(selectorOrRun as any)) &&
+                    (e.previous !== e.value || typeof e.value === 'object')))
+        ) {
+            reaction(e);
+        }
+
+        // Update the previous value
+        e.previous = e.value;
+
+        // Increment the counter
+        e.num++;
+    };
+
+    update();
+
+    // Return function calling dispose because dispose may be changed in update()
+    return () => {
+        e.onCleanup?.();
+        e.onCleanup = undefined;
+        e.onCleanupReaction?.();
+        e.onCleanupReaction = undefined;
+        dispose?.();
+    };
+}

package/src/onChange.ts

@@ -0,0 +1,136 @@
+import { isArray } from './is';
+import { getNodeValue } from './globals';
+import type { ListenerFn, ListenerParams, NodeValue, NodeValueListener, TrackingType } from './observableInterfaces';
+
+export function onChange(
+    node: NodeValue,
+    callback: ListenerFn,
+    options: { trackingType?: TrackingType; initial?: boolean; immediate?: boolean; noArgs?: boolean } = {},
+    fromLinks?: Set<NodeValue>,
+): () => void {
+    const { initial, immediate, noArgs } = options;
+    const { trackingType } = options;
+
+    let listeners = immediate ? node.listenersImmediate : node.listeners;
+    if (!listeners) {
+        listeners = new Set();
+        if (immediate) {
+            node.listenersImmediate = listeners;
+        } else {
+            node.listeners = listeners;
+        }
+    }
+
+    const listener: NodeValueListener = {
+        listener: callback,
+        track: trackingType,
+        noArgs,
+    };
+
+    listeners.add(listener);
+
+    if (initial) {
+        const value = getNodeValue(node);
+        callback({
+            value,
+            loading: true,
+            remote: false,
+            changes: [
+                {
+                    path: [],
+                    pathTypes: [],
+                    prevAtPath: value,
+                    valueAtPath: value,
+                },
+            ],
+            getPrevious: () => undefined,
+        });
+    }
+
+    let extraDisposes: (() => void)[];
+
+    function addLinkedNodeListeners(childNode: NodeValue, cb: ListenerFn = callback, from?: NodeValue) {
+        // Don't add listeners for the same node more than once
+        if (!fromLinks?.has(childNode)) {
+            fromLinks ||= new Set();
+            fromLinks.add(from || node);
+            cb ||= callback;
+            const childOptions: Parameters<typeof onChange>[2] = {
+                trackingType: true,
+                ...options,
+            };
+            // onChange for the linked node
+            extraDisposes = [...(extraDisposes || []), onChange(childNode, cb as ListenerFn, childOptions, fromLinks)];
+        }
+    }
+
+    // Add listeners for linked to nodes
+    if (node.linkedToNode) {
+        addLinkedNodeListeners(node.linkedToNode);
+    }
+
+    // Add listeners for linked from nodes
+    node.linkedFromNodes?.forEach((linkedFromNode) => addLinkedNodeListeners(linkedFromNode));
+
+    // Go up through the parents and add listeners for linked from nodes
+    let parent = node.parent;
+    let pathParent: string[] = [node!.key!];
+    while (parent) {
+        if (parent.linkedFromNodes) {
+            for (const linkedFromNode of parent.linkedFromNodes) {
+                if (!fromLinks?.has(linkedFromNode)) {
+                    const cb = createCb(linkedFromNode, pathParent, callback);
+                    addLinkedNodeListeners(linkedFromNode, cb, parent);
+                }
+            }
+        }
+        pathParent = [parent!.key!, ...pathParent];
+        parent = parent.parent;
+    }
+
+    return () => {
+        listeners!.delete(listener);
+        extraDisposes?.forEach((fn) => fn());
+    };
+}
+
+function createCb(linkedFromNode: NodeValue, path: string[], callback: ListenerFn) {
+    // Create a callback for a path that calls it with the current value at the path
+    let { valueAtPath: prevAtPath } = getValueAtPath(getNodeValue(linkedFromNode), path);
+
+    return function ({ value: valueA, loading, remote }: ListenerParams<any>) {
+        const { valueAtPath, pathTypes } = getValueAtPath(valueA, path);
+        if (valueAtPath !== prevAtPath) {
+            callback({
+                value: valueAtPath,
+                loading,
+                remote,
+                changes: [
+                    {
+                        path,
+                        pathTypes,
+                        prevAtPath,
+                        valueAtPath,
+                    },
+                ],
+                getPrevious: () => prevAtPath,
+            });
+        }
+        prevAtPath = valueAtPath;
+    };
+}
+
+function getValueAtPath(
+    obj: Record<string, any>,
+    path: string[],
+): { valueAtPath: any; pathTypes: ('object' | 'array')[] } {
+    let o: Record<string, any> = obj;
+    const pathTypes: ('object' | 'array')[] = [];
+    for (let i = 0; o && i < path.length; i++) {
+        pathTypes.push(isArray(o) ? 'array' : 'object');
+        const p = path[i];
+        o = (o as any)[p];
+    }
+
+    return { valueAtPath: o, pathTypes };
+}

package/src/persist/configureObservablePersistence.ts

@@ -0,0 +1,7 @@
+import type { ObservablePersistenceConfig } from '@legendapp/state/sync';
+
+export const observablePersistConfiguration: ObservablePersistenceConfig = {};
+
+export function configureObservablePersistence(options?: ObservablePersistenceConfig) {
+    Object.assign(observablePersistConfiguration, options);
+}

package/src/persist/fieldTransformer.ts

@@ -0,0 +1,149 @@
+import {
+    constructObjectWithPath,
+    deconstructObjectWithPath,
+    isArray,
+    isObject,
+    isString,
+    TypeAtPath,
+    internal,
+} from '@legendapp/state';
+import type { FieldTransforms } from '@legendapp/state/sync';
+
+const { initializePathType, symbolDelete } = internal;
+
+let validateMap: (map: Record<string, any>) => void;
+
+export function transformPath(path: string[], pathTypes: TypeAtPath[], map: Record<string, any>): string[] {
+    const data: Record<string, any> = {};
+    let d: Record<string, any> | null = data;
+    for (let i = 0; i < path.length; i++) {
+        d = d![path[i]] = i === path.length - 1 ? null : initializePathType(pathTypes[i]);
+    }
+    let value = transformObject(data, map);
+    const pathOut = [];
+    for (let i = 0; i < path.length; i++) {
+        const key = Object.keys(value)[0];
+        pathOut.push(key);
+        value = value[key];
+    }
+    return pathOut;
+}
+
+export function transformObject(dataIn: Record<string, any>, map: Record<string, any>) {
+    if (process.env.NODE_ENV === 'development') {
+        validateMap(map);
+    }
+    let ret = dataIn;
+    if (dataIn) {
+        if ((dataIn as unknown) === symbolDelete) return dataIn;
+        if (isString(dataIn)) {
+            return map[dataIn];
+        }
+
+        ret = {};
+
+        const dict = Object.keys(map).length === 1 && map['_dict'];
+
+        for (const key in dataIn) {
+            let v = dataIn[key];
+
+            if (dict) {
+                ret[key] = transformObject(v, dict);
+            } else {
+                const mapped = map[key];
+                if (mapped === undefined) {
+                    // Don't transform dateModified if user doesn't want it
+                    if (key !== '@') {
+                        ret[key] = v;
+                        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+                            console.error('A fatal field transformation error has occurred', key, dataIn, map);
+                        }
+                    }
+                } else if (mapped !== null) {
+                    if (v !== undefined && v !== null) {
+                        if (map[key + '_val']) {
+                            const mapChild = map[key + '_val'];
+                            if (isArray(v)) {
+                                v = v.map((vChild) => mapChild[vChild]);
+                            } else {
+                                v = mapChild[v];
+                            }
+                        } else if (map[key + '_arr'] && isArray(v)) {
+                            const mapChild = map[key + '_arr'];
+                            v = v.map((vChild) => transformObject(vChild, mapChild));
+                        } else if (isObject(v)) {
+                            if (map[key + '_obj']) {
+                                v = transformObject(v, map[key + '_obj']);
+                            } else if (map[key + '_dict']) {
+                                const mapChild = map[key + '_dict'];
+                                const out: Record<string, any> = {};
+                                for (const keyChild in v) {
+                                    out[keyChild] = transformObject(v[keyChild], mapChild);
+                                }
+                                v = out;
+                            }
+                        }
+                    }
+                    ret[mapped] = v;
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+export function transformObjectWithPath(
+    obj: object,
+    path: string[],
+    pathTypes: TypeAtPath[],
+    fieldTransforms: FieldTransforms<any>,
+) {
+    const constructed = constructObjectWithPath(path, pathTypes, obj);
+    const transformed = transformObject(constructed, fieldTransforms);
+    const transformedPath = transformPath(path as string[], pathTypes, fieldTransforms);
+    return { path: transformedPath, obj: deconstructObjectWithPath(transformedPath, pathTypes, transformed) };
+}
+
+const invertedMaps = new WeakMap();
+
+export function invertFieldMap(obj: Record<string, any>) {
+    const existing = invertedMaps.get(obj);
+    if (existing) return existing;
+
+    const target: Record<string, any> = {} as any;
+
+    for (const key in obj) {
+        const val = obj[key];
+        if (key === '_dict') {
+            target[key] = invertFieldMap(val);
+        } else if (key.endsWith('_obj') || key.endsWith('_dict') || key.endsWith('_arr') || key.endsWith('_val')) {
+            const keyMapped = obj[key.replace(/_obj|_dict|_arr|_val$/, '')];
+            const suffix = key.match(/_obj|_dict|_arr|_val$/)![0];
+            target[keyMapped + suffix] = invertFieldMap(val);
+        } else if (typeof val === 'string') {
+            target[val] = key;
+        }
+    }
+    invertedMaps.set(obj, target);
+
+    return target;
+}
+
+if (process.env.NODE_ENV === 'development') {
+    validateMap = function (record: Record<string, any>) {
+        const values = Object.values(record).filter((value) => {
+            if (isObject(value)) {
+                validateMap(value);
+            } else {
+                return isString(value);
+            }
+        });
+
+        const uniques = Array.from(new Set(values));
+        if (values.length !== uniques.length) {
+            console.error('Field transform map has duplicate values', record, values.length, uniques.length);
+        }
+        return record;
+    };
+}

package/src/persist/observablePersistRemoteFunctionsAdapter.ts

@@ -0,0 +1,39 @@
+import { isPromise } from '@legendapp/state';
+import {
+    type ObservablePersistRemoteClass,
+    type ObservablePersistRemoteFunctions,
+    type ObservablePersistRemoteGetParams,
+} from '@legendapp/state/sync';
+
+export function observablePersistRemoteFunctionsAdapter<T = {}>({
+    get,
+    set,
+}: ObservablePersistRemoteFunctions<T>): ObservablePersistRemoteClass {
+    const ret: ObservablePersistRemoteClass = {};
+
+    if (get) {
+        ret.get = (async (params: ObservablePersistRemoteGetParams<T>) => {
+            try {
+                let value = get(params);
+                if (isPromise(value)) {
+                    value = await value;
+                }
+
+                params.onChange({
+                    value,
+                    dateModified: params.dateModified,
+                    lastSync: params.lastSync,
+                    mode: params.mode,
+                });
+                params.onGet();
+                // eslint-disable-next-line no-empty
+            } catch {}
+        }) as ObservablePersistRemoteClass['get'];
+    }
+
+    if (set) {
+        ret.set = set as ObservablePersistRemoteClass['set'];
+    }
+
+    return ret;
+}