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

package/src/react-hooks/usePersistedObservable.ts

@@ -0,0 +1,24 @@
+import { Observable, ObservableParam, LegacyPersistOptions, observable } from '@legendapp/state';
+import { persistObservable } from '@legendapp/state/persist';
+import { useMemo } from 'react';
+
+// TODO: Deprecate this
+
+/**
+ * A React hook that creates a new observable and can optionally listen or persist its state.
+ *
+ * @param initialValue The initial value of the observable or a function that returns the initial value
+ * @param options Persistence options for the observable
+ *
+ * @see https://www.legendapp.com/dev/state/react/#useObservable
+ */
+export function usePersistedObservable<T>(params: {
+    options: LegacyPersistOptions<T>;
+    initialValue?: T | (() => T) | (() => Promise<T>);
+}): Observable<T> {
+    // Create the observable from the default value
+    return useMemo(() => {
+        const obs$ = observable<T>(params.initialValue as any);
+        persistObservable<T>(obs$ as ObservableParam<T>, params.options);
+    }, []) as any;
+}

package/src/retry.ts

@@ -0,0 +1,69 @@
+import { whenReady } from './when';
+import type { NodeValue, RetryOptions } from './observableInterfaces';
+import { isPromise } from './is';
+
+function calculateRetryDelay(retryOptions: RetryOptions, attemptNum: number): number | null {
+    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
+    if (infinite || attemptNum < times) {
+        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum), maxDelay);
+        return delayTime;
+    }
+    return null;
+}
+
+function createRetryTimeout(retryOptions: RetryOptions, attemptNum: number, fn: () => void) {
+    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
+    if (delayTime) {
+        return setTimeout(fn, delayTime);
+    }
+}
+
+export function runWithRetry<T>(
+    node: NodeValue,
+    state: { attemptNum: number },
+    fn: (e: { cancel?: boolean }) => T | Promise<T>,
+): T | Promise<T> {
+    const { retry, waitFor } = node.activationState!;
+
+    const e = { cancel: false };
+    let value: any = undefined;
+    if (waitFor) {
+        value = whenReady(waitFor, () => {
+            node.activationState!.waitFor = undefined;
+            return fn(e);
+        });
+    } else {
+        value = fn(e);
+    }
+
+    if (isPromise(value) && retry) {
+        let timeoutRetry: any;
+        return new Promise<any>((resolve) => {
+            const run = () => {
+                (value as Promise<any>)
+                    .then((val: any) => {
+                        node.activationState!.persistedRetry = false;
+                        resolve(val);
+                    })
+                    .catch(() => {
+                        state.attemptNum++;
+                        if (timeoutRetry) {
+                            clearTimeout(timeoutRetry);
+                        }
+                        if (!e.cancel) {
+                            timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
+                                value = fn(e);
+                                run();
+                            });
+                        }
+                    })
+                    .finally(() => {
+                        node.activationState!.persistedRetry = false;
+                    });
+            };
+            run();
+        });
+    }
+
+    return value;
+}

package/src/setupTracking.ts

@@ -0,0 +1,26 @@
+import type { ListenerFn, NodeValue, TrackingNode } from './observableInterfaces';
+import { onChange } from './onChange';
+
+export function setupTracking(
+    nodes: Map<NodeValue, TrackingNode> | undefined,
+    update: ListenerFn,
+    noArgs?: boolean,
+    immediate?: boolean,
+) {
+    let listeners: (() => void)[] | undefined = [];
+
+    // Listen to tracked nodes
+    nodes?.forEach((tracked) => {
+        const { node, track } = tracked;
+        listeners!.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
+    });
+
+    return () => {
+        if (listeners) {
+            for (let i = 0; i < listeners.length; i++) {
+                listeners[i]();
+            }
+            listeners = undefined;
+        }
+    };
+}

package/src/sync/activateSyncedNode.ts

@@ -0,0 +1,146 @@
+import type {
+    GetMode,
+    NodeValue,
+    Observable,
+    ObservableOnChangeParams,
+    ObservablePersistState,
+    ObservableSyncFunctions,
+    ObservableSyncGetParams,
+    ObservableSyncSetParams,
+    SyncedGetParams,
+    SyncedSetParams,
+    UpdateFn,
+} from '@legendapp/state';
+import { internal, isFunction, isPromise, mergeIntoObservable, when, whenReady } from '@legendapp/state';
+import { syncObservable } from './syncObservable';
+const { getProxy, globalState, runWithRetry, symbolLinked, setNodeValue, getNodeValue } = internal;
+
+export function enableActivateSyncedNode() {
+    globalState.activateSyncedNode = function activateSyncedNode(node: NodeValue, newValue: any) {
+        const obs$ = getProxy(node);
+        if (node.activationState) {
+            // If it is a Synced
+            const { get, initial, set, subscribe } = node.activationState!;
+
+            let onChange: UpdateFn | undefined = undefined;
+            const pluginRemote: ObservableSyncFunctions = {};
+            let promiseReturn: any = undefined;
+
+            // Not sure why this disable is needed, but it's needed to make the linter happy
+            // eslint-disable-next-line prefer-const
+            let syncState: Observable<ObservablePersistState>;
+            const refresh = () => syncState?.sync();
+
+            if (get) {
+                pluginRemote.get = (params: ObservableSyncGetParams<any>) => {
+                    onChange = params.onChange;
+                    const updateLastSync = (lastSync: number) => (params.lastSync = lastSync);
+                    const setMode = (mode: GetMode) => (params.mode = mode);
+
+                    const existingValue = getNodeValue(node);
+                    const value = runWithRetry(node, { attemptNum: 0 }, () => {
+                        return get!({
+                            value:
+                                isFunction(existingValue) || existingValue?.[symbolLinked] ? undefined : existingValue,
+                            lastSync: params.lastSync!,
+                            updateLastSync,
+                            setMode,
+                            refresh,
+                        });
+                    });
+
+                    promiseReturn = value;
+
+                    return value;
+                };
+            }
+            if (set) {
+                // TODO: Work out these types better
+                pluginRemote.set = async (params: ObservableSyncSetParams<any>) => {
+                    if (node.state?.isLoaded.get()) {
+                        const retryAttempts = { attemptNum: 0 };
+                        return runWithRetry(node, retryAttempts, async (retryEvent) => {
+                            let changes = {};
+                            let maxModified = 0;
+                            if (!node.state!.isLoaded.peek()) {
+                                await whenReady(node.state!.isLoaded);
+                            }
+
+                            const cancelRetry = () => {
+                                retryEvent.cancel = true;
+                            };
+
+                            await set({
+                                ...(params as unknown as SyncedSetParams<any>),
+                                node,
+                                update: (params) => {
+                                    const { value, lastSync } = params;
+                                    maxModified = Math.max(lastSync || 0, maxModified);
+                                    changes = mergeIntoObservable(changes, value);
+                                },
+                                retryNum: retryAttempts.attemptNum,
+                                cancelRetry,
+                                refresh,
+                                fromSubscribe: false,
+                            });
+                            return { changes, lastSync: maxModified || undefined };
+                        });
+                    }
+                };
+            }
+
+            const nodeVal = getNodeValue(node);
+            if (promiseReturn !== undefined) {
+                newValue = promiseReturn;
+            } else if (nodeVal !== undefined && !isFunction(nodeVal)) {
+                newValue = nodeVal;
+            } else {
+                newValue = initial;
+            }
+            setNodeValue(node, promiseReturn ? undefined : newValue);
+
+            // @ts-expect-error TODO fix these types
+            syncState = syncObservable(obs$, { ...node.activationState, ...pluginRemote });
+
+            if (subscribe) {
+                when(promiseReturn || true, () => {
+                    subscribe({
+                        node,
+                        update: (params: ObservableOnChangeParams) => {
+                            if (!onChange) {
+                                // TODO: Make this message better
+                                console.log('[legend-state] Cannot update immediately before the first return');
+                            } else {
+                                onChange(params);
+                            }
+                        },
+                        refresh,
+                    });
+                });
+            }
+
+            return { update: onChange!, value: newValue };
+        } else {
+            // If it is not a Synced
+
+            let update: UpdateFn | undefined = undefined;
+            const get = async (params: SyncedGetParams) => {
+                update = params.refresh;
+                if (isPromise(newValue)) {
+                    try {
+                        newValue = await newValue;
+                    } catch {
+                        // TODO Once we have global retry settings this should retry
+                    }
+                }
+                return newValue;
+            };
+
+            syncObservable(obs$, {
+                get,
+            });
+
+            return { update: update!, value: newValue };
+        }
+    };
+}

package/src/sync/configureObservableSync.ts

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

package/src/sync/syncHelpers.ts

@@ -0,0 +1,15 @@
+import { isObject } from '@legendapp/state';
+
+export function removeNullUndefined<T extends Record<string, any>>(val: T) {
+    if (val) {
+        Object.keys(val).forEach((key) => {
+            const v = val[key];
+            if (v === null || v === undefined) {
+                delete val[key];
+            } else if (isObject(v)) {
+                removeNullUndefined(v);
+            }
+        });
+    }
+    return val;
+}