@legendapp/state 3.0.0-alpha.0 → 3.0.0-alpha.2

package/src/react-hooks/useObservableNextRouter.ts

@@ -1,137 +0,0 @@
-import { isEmpty, observable, Observable, setSilently } from '@legendapp/state';
-import Router, { NextRouter, useRouter } from 'next/router';
-
-type ParsedUrlQuery = { [key: string]: string | string[] | undefined };
-
-interface TransitionOptions {
-    shallow?: boolean;
-    locale?: string | false;
-    scroll?: boolean;
-    unstable_skipClientCache?: boolean;
-}
-export interface ObservableNextRouterState {
-    pathname: string;
-    hash: string;
-    query: ParsedUrlQuery;
-}
-type RouteInfo = Partial<ObservableNextRouterState>;
-export interface ParamsUseObservableNextRouterBase {
-    transitionOptions?: TransitionOptions;
-    method?: 'push' | 'replace';
-    subscribe?: boolean;
-}
-export interface ParamsUseObservableNextRouter<T extends object> extends ParamsUseObservableNextRouterBase {
-    compute: (value: ObservableNextRouterState) => T;
-    set: (
-        value: T,
-        previous: T,
-        router: NextRouter,
-    ) => RouteInfo & {
-        transitionOptions?: TransitionOptions;
-        method?: 'push' | 'replace';
-    };
-}
-
-function isShallowEqual(query1: ParsedUrlQuery, query2: ParsedUrlQuery) {
-    if (!query1 !== !query2) {
-        return false;
-    }
-    const keys1 = Object.keys(query1);
-    const keys2 = Object.keys(query2);
-
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
-
-    for (const key of keys1) {
-        if (query1[key] !== query2[key]) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-const routes$ = observable({});
-let routeParams = {} as ParamsUseObservableNextRouter<any>;
-let router: NextRouter;
-
-routes$.onChange(({ value, getPrevious }) => {
-    // Only run this if being manually changed by the user
-    let setter = routeParams?.set;
-    if (!setter) {
-        if ((value as any).pathname) {
-            setter = () => value;
-        } else {
-            console.error('[legend-state]: Must provide a set method to useObservableNextRouter');
-        }
-    }
-    const setReturn = setter(value, getPrevious(), router);
-    const { pathname, hash, query } = setReturn;
-    let { transitionOptions, method } = setReturn;
-
-    method = method || routeParams?.method;
-    transitionOptions = transitionOptions || routeParams?.transitionOptions;
-
-    const prevHash = router.asPath.split('#')[1] || '';
-
-    const change: RouteInfo = {};
-    // Only include changes that were meant to be changed. For example the user may have
-    // only changed the hash so we don't need to push a pathname change.
-    if (pathname !== undefined && pathname !== router.pathname) {
-        change.pathname = pathname;
-    }
-    if (hash !== undefined && hash !== prevHash) {
-        change.hash = hash;
-    }
-    if (query !== undefined && !isShallowEqual(query, router.query)) {
-        change.query = query;
-    }
-    // Only push if there are changes
-    if (!isEmpty(change)) {
-        const fn = method === 'replace' ? 'replace' : 'push';
-        router[fn](change, undefined, transitionOptions).catch((e) => {
-            // workaround for https://github.com/vercel/next.js/issues/37362
-            if (!e.cancelled) throw e;
-        });
-    }
-});
-
-export function useObservableNextRouter(): Observable<ObservableNextRouterState>;
-export function useObservableNextRouter<T extends object>(params: ParamsUseObservableNextRouter<T>): Observable<T>;
-export function useObservableNextRouter(
-    params: ParamsUseObservableNextRouterBase,
-): Observable<ObservableNextRouterState>;
-export function useObservableNextRouter<T extends object>(
-    params?: ParamsUseObservableNextRouter<T> | ParamsUseObservableNextRouterBase,
-): Observable<T> | Observable<ObservableNextRouterState> {
-    const { subscribe, compute } = (params as ParamsUseObservableNextRouter<T>) || {};
-
-    try {
-        // Use the useRouter hook if we're on the client side and want to subscribe to changes.
-        // Otherwise use the Router object so that this does not subscribe to router changes.
-        router = typeof window !== 'undefined' && !subscribe ? Router : useRouter();
-    } finally {
-        router = router || useRouter();
-    }
-
-    // Update the local state with the new functions and options. This can happen when being run
-    // on a new page or if the user just changes it on the current page.
-    // It's better for performance than creating new observables or hooks for every use, since there may be
-    // many uses of useObservableRouter in the lifecycle of a page.
-    routeParams = params as ParamsUseObservableNextRouter<T>;
-
-    // Get the pathname and hash
-    const { asPath, pathname, query } = router;
-    const hash = asPath.split('#')[1] || '';
-
-    // Run the compute function to get the value of the object
-    const computeParams = { pathname, hash, query };
-    const obj = compute ? compute(computeParams) : computeParams;
-
-    // Set the object without triggering router.push
-    setSilently(routes$, obj);
-
-    // Return the observable with the computed values
-    return routes$ as any;
-}

package/src/retry.ts

@@ -1,71 +0,0 @@
-import { whenReady } from './when';
-import type { NodeValue } from './observableInterfaces';
-import type { RetryOptions } from './sync/syncTypes';
-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; retry: RetryOptions | undefined },
-    fn: (e: { cancel?: boolean }) => T | Promise<T>,
-): T | Promise<T> {
-    const { waitFor } = node.activationState!;
-    const { retry } = state;
-
-    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

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

@@ -1,128 +0,0 @@
-import type { NodeValue, Observable, UpdateFn } from '@legendapp/state';
-import type {
-    ObservableSyncFunctions,
-    ObservableSyncGetParams,
-    ObservableSyncSetParams,
-    SyncedGetParams,
-    SyncedSetParams,
-} from './syncTypes';
-import type { ObservablePersistState } from './persistTypes';
-import { internal, isFunction, isPromise, mergeIntoObservable, 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, retry } = 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 existingValue = getNodeValue(node);
-                    const value = runWithRetry(node, { attemptNum: 0, retry: retry || params.options?.retry }, () => {
-                        const paramsToGet = {
-                            value:
-                                isFunction(existingValue) || existingValue?.[symbolLinked] ? undefined : existingValue,
-                            lastSync: params.lastSync!,
-                            updateLastSync,
-                            mode: params.mode!,
-                            refresh,
-                        };
-
-                        const ret = get!(paramsToGet);
-                        params.mode = paramsToGet.mode;
-                        return ret;
-                    });
-
-                    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, retry: retry || params.options?.retry };
-                        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 });
-
-            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

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

package/src/sync/persistTypes.ts

@@ -1,216 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-ignore
-import type { MMKVConfiguration } from 'react-native-mmkv';
-// @ts-ignore
-import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
-// @ts-ignore
-import type { DatabaseReference, Query } from 'firebase/database';
-
-import type {
-    ArrayValue,
-    Change,
-    ClassConstructor,
-    GetMode,
-    LinkedOptions,
-    RecordValue,
-    Selector,
-    TypeAtPath,
-} from '../observableInterfaces';
-import type { Observable, ObservableParam, ObservableState } from '../observableTypes';
-import type { ObservablePersistPlugin, RetryOptions } from './syncTypes';
-
-export interface PersistTransform<TOrig = any, TSaved = TOrig> {
-    load?: (value: TSaved) => TOrig | Promise<TOrig>;
-    save?: (value: TOrig) => TSaved | Promise<TSaved>;
-}
-
-export interface LegacyPersistOptionsLocal<T = any> {
-    name: string;
-    transform?: PersistTransform<T>;
-    fieldTransforms?: FieldTransforms<T>;
-    readonly?: boolean;
-    mmkv?: MMKVConfiguration;
-    indexedDB?: {
-        prefixID?: string;
-        itemID?: string;
-    };
-    options?: any;
-}
-export type LegacyPersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
-    readonly?: boolean;
-    waitForGet?: Selector<any>;
-    waitForSet?: LinkedOptions['waitForSet'];
-    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 {
-    debounceSet?: number;
-    dateModifiedKey?: string;
-    offlineBehavior?: false | 'retry';
-    retry?: RetryOptions;
-    onGetError?: (error: Error) => void;
-    onSetError?: (error: Error) => void;
-    log?: (logLevel: 'verbose' | 'warning' | 'error', message: any, ...optionalParams: any[]) => void;
-    onBeforeSet?: () => void;
-    onAfterSet?: () => void;
-}
-export interface ObservablePersistenceConfig {
-    pluginLocal?: ClassConstructor<ObservablePersistPlugin>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions;
-    localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
-    remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
-}
-export interface LegacyPersistOptions<T = any> {
-    local?: string | LegacyPersistOptionsLocal<T>;
-    remote?: LegacyPersistOptionsRemote<T>;
-    pluginLocal?: ClassConstructor<ObservablePersistPlugin>;
-    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
-}
-
-export interface ObservableOnChangeParams {
-    value: unknown;
-    path?: string[]; // TODOv4 remove
-    pathTypes?: TypeAtPath[]; // TODOv4 remove
-    mode?: GetMode;
-    dateModified?: number | undefined; // TODOv4 remove
-    lastSync?: number | undefined;
-}
-export interface ObservablePersistRemoteSetParams<T> {
-    syncState: Observable<ObservablePersistState>;
-    obs: ObservableParam<T>;
-    options: LegacyPersistOptions<T>;
-    changes: Change[];
-    value: T;
-}
-export interface ObservablePersistRemoteGetParams<T> {
-    state: Observable<ObservablePersistState>;
-    obs: ObservableParam<T>;
-    options: LegacyPersistOptions<T>;
-    dateModified?: number;
-    lastSync?: number;
-    mode?: GetMode;
-    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; lastSync?: 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; lastSync?: number }>;
-}
-
-export interface ObservablePersistStateBase {
-    isLoadedLocal: boolean;
-    isEnabledLocal: boolean;
-    isEnabledRemote: boolean;
-    dateModified?: number;
-    lastSync?: number;
-    syncCount?: number;
-    clearLocal: () => Promise<void>;
-    sync: () => Promise<void>;
-    getPendingChanges: () =>
-        | Record<
-              string,
-              {
-                  p: any;
-                  v?: any;
-              }
-          >
-        | undefined;
-}
-export type ObservablePersistState = ObservableState & ObservablePersistStateBase;
-
-// This converts the state object's shape to the field transformer's shape
-// TODO: FieldTransformer and this shape can likely be refactored to be simpler
-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 QueryByModified<T> =
-    | boolean
-    | {
-          [K in keyof T]?: QueryByModified<T[K]>;
-      }
-    | {
-          '*'?: boolean;
-      };