@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.3

package/src/onChange.ts

@@ -1,146 +0,0 @@
-import { getNodeValue } from './globals';
-import { isArray } from './is';
-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
-    node.numListenersRecursive++;
-    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);
-                }
-            }
-        }
-        parent.numListenersRecursive++;
-
-        pathParent = [parent!.key!, ...pathParent];
-        parent = parent.parent;
-    }
-
-    return () => {
-        listeners!.delete(listener);
-        extraDisposes?.forEach((fn) => fn());
-
-        let parent = node;
-        while (parent) {
-            parent.numListenersRecursive--;
-
-            parent = parent.parent!;
-        }
-    };
-}
-
-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 } = 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

@@ -1,7 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

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