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

package/src/sync/syncObservableAdapter.ts

@@ -0,0 +1,30 @@
+import { ObservableSyncGetParams, SyncedOptions, isPromise, type ObservableSyncClass } from '@legendapp/state';
+
+export function syncObservableAdapter<T = {}>({ get, set }: SyncedOptions<T>): ObservableSyncClass {
+    const ret: ObservableSyncClass = {};
+
+    if (get) {
+        ret.get = (async (params: ObservableSyncGetParams<T>) => {
+            try {
+                let value = get(params as any);
+                if (isPromise(value)) {
+                    value = await value;
+                }
+
+                params.onChange({
+                    value,
+                    lastSync: params.lastSync,
+                    mode: params.mode!,
+                });
+                params.onGet();
+                // eslint-disable-next-line no-empty
+            } catch {}
+        }) as ObservableSyncClass['get'];
+    }
+
+    if (set) {
+        ret.set = set as unknown as ObservableSyncClass['set'];
+    }
+
+    return ret;
+}

package/src/sync/synced.ts

@@ -0,0 +1,20 @@
+import type { Synced, SyncedOptions } from '@legendapp/state';
+import { internal } from '@legendapp/state';
+import { enableActivateSyncedNode } from './activateSyncedNode';
+
+const { symbolLinked } = internal;
+
+export function synced<T>(params: SyncedOptions<T>): Synced<T> {
+    installPersistActivateNode();
+    return (() => ({
+        [symbolLinked]: { ...params, synced: true },
+    })) as any;
+}
+
+let didInstall = false;
+function installPersistActivateNode() {
+    if (!didInstall) {
+        enableActivateSyncedNode();
+        didInstall = true;
+    }
+}

package/src/sync-plugins/fetch.ts

@@ -0,0 +1,42 @@
+import { Synced, SyncedOptions, SyncedSetParams, isString } from '@legendapp/state';
+import { synced } from '@legendapp/state/persist';
+
+export interface SyncedFetchProps extends Omit<SyncedOptions, 'get' | 'set'> {
+    get: string | RequestInfo;
+    set?: string | RequestInfo;
+    getInit?: RequestInit;
+    setInit?: RequestInit;
+    valueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text';
+    onSetValueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text';
+    onSet?: (params: SyncedSetParams<any>) => void;
+}
+
+export function syncedFetch<T>({
+    get,
+    set,
+    getInit,
+    setInit,
+    valueType,
+    onSet,
+    onSetValueType,
+}: SyncedFetchProps): Synced<T> {
+    const ret: SyncedOptions = {
+        get: () => fetch(get, getInit).then((response) => response[valueType || 'json']()),
+    };
+
+    if (set) {
+        ret.set = async (params: SyncedSetParams<any>) => {
+            const requestInfo = isString(set) ? ({ url: set } as RequestInfo) : set;
+            const response = await fetch(
+                Object.assign({ method: 'POST' }, requestInfo, { body: JSON.stringify(params.value) }),
+                setInit,
+            );
+            if (onSet) {
+                params.value = response[onSetValueType || valueType || 'json']();
+                onSet(params);
+            }
+        };
+    }
+
+    return synced(ret);
+}

package/src/syncTypes.ts

@@ -0,0 +1,163 @@
+/* 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';
+
+import {
+    Change,
+    ClassConstructor,
+    LinkedOptions,
+    NodeValue,
+    RetryOptions,
+    SetParams,
+    UpdateFn,
+    UpdateFnParams,
+} from './observableInterfaces';
+import { Observable, ObservableParam, ObservableState } from './observableTypes';
+
+export interface PersistOptions<T = any> {
+    name: string;
+    plugin?: ClassConstructor<ObservablePersistPlugin, T[]>;
+    transform?: SyncTransform<T>;
+    readonly?: boolean;
+    mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
+    options?: any;
+}
+
+export interface SyncedGetParams {
+    value: any;
+    lastSync: number | undefined;
+    updateLastSync: (lastSync: number) => void;
+    setMode: (mode: GetMode) => void;
+    refresh: () => void;
+}
+
+export type SyncedSetParams<T> = SetParams<T> & {
+    node: NodeValue;
+    valuePrevious: T;
+    update: UpdateFn;
+    refresh: () => void;
+    cancelRetry: () => void;
+    retryNum: number;
+    fromSubscribe: boolean | undefined;
+};
+
+export type GetMode = 'set' | 'assign' | 'merge' | 'append' | 'prepend';
+
+export interface SyncedOptions<T = any> extends Omit<LinkedOptions<T>, 'get' | 'set'> {
+    get?: (params: SyncedGetParams) => Promise<T> | T;
+    set?: (params: SyncedSetParams<T>) => void | Promise<any>;
+    subscribe?: (params: { node: NodeValue; update: UpdateFn; refresh: () => void }) => void;
+    retry?: RetryOptions;
+    offlineBehavior?: false | 'retry';
+    persist?: PersistOptions<any>;
+    debounceSet?: number;
+    syncMode?: 'auto' | 'manual';
+    mode?: GetMode;
+    transform?: SyncTransform<T>;
+    // Not implemented yet
+    enableSync?: boolean;
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    log?: (message?: any, ...optionalParams: any[]) => void;
+    onBeforeSet?: () => void;
+    onAfterSet?: () => void;
+    allowSetIfGetError?: boolean;
+}
+
+export interface SyncedOptionsGlobal<T = any> extends Omit<SyncedOptions<T>, 'get' | 'set' | 'persist'> {
+    persist?: ObservablePersistPluginOptions & { plugin?: ClassConstructor<ObservablePersistPlugin, T[]> };
+}
+
+export interface ObservablePersistPluginOptions {
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    indexedDB?: {
+        databaseName: string;
+        version: number;
+        tableNames: string[];
+    };
+    asyncStorage?: {
+        AsyncStorage: AsyncStorageStatic;
+        preload?: boolean | string[];
+    };
+}
+export interface ObservablePersistPlugin {
+    initialize?(config: ObservablePersistPluginOptions): void | Promise<void>;
+    loadTable?(table: string, config: PersistOptions): Promise<any> | void;
+    getTable<T = any>(table: string, init: object, config: PersistOptions): T;
+    set(table: string, changes: Change[], config: PersistOptions): Promise<any> | void;
+    deleteTable(table: string, config: PersistOptions): Promise<any> | void;
+    getMetadata(table: string, config: PersistOptions): PersistMetadata;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions): Promise<any> | void;
+    deleteMetadata(table: string, config: PersistOptions): Promise<any> | void;
+}
+export interface PersistMetadata {
+    id?: '__legend_metadata';
+    // modified ?: number;
+    lastSync?: number;
+    pending?: any;
+}
+export interface SyncTransform<TOrig = any, TSaved = TOrig> {
+    load?: (value: TSaved) => TOrig | Promise<TOrig>;
+    save?: (value: TOrig) => TSaved | Promise<TSaved>;
+}
+export interface ObservableSyncStateBase {
+    isPersistLoaded: boolean;
+    isPersistEnabled: boolean;
+    isEnabledRemote: boolean;
+    lastSync?: number;
+    syncCount?: number;
+    clearPersist: () => Promise<void>;
+    sync: () => Promise<void>;
+    getPendingChanges: () =>
+        | Record<
+              string,
+              {
+                  p: any;
+                  v?: any;
+              }
+          >
+        | undefined;
+}
+export type ObservableSyncState = ObservableState & ObservableSyncStateBase;
+
+export interface ObservableSyncSetParams<T> {
+    syncState: Observable<ObservableSyncState>;
+    obs: ObservableParam<T>;
+    options: SyncedOptions<T>;
+    changes: Change[];
+    value: T;
+    valuePrevious: T;
+}
+export interface ObservableSyncGetParams<T> {
+    state: Observable<ObservableSyncState>;
+    obs: ObservableParam<T>;
+    options: SyncedOptions<T>;
+    dateModified?: number;
+    lastSync?: number;
+    mode?: GetMode;
+    onGet: () => void;
+    onError: (error: Error) => void;
+    onChange: (params: UpdateFnParams) => void | Promise<void>;
+}
+export type ObservableSyncRemoteGetFnParams<T> = Omit<ObservableSyncGetParams<T>, 'onGet'>;
+
+export interface ObservableSyncClass {
+    get?<T>(params: ObservableSyncGetParams<T>): void;
+    set?<T>(
+        params: ObservableSyncSetParams<T>,
+    ): void | Promise<void | { changes?: object; dateModified?: number; lastSync?: number; pathStrs?: string[] }>;
+}
+
+export interface ObservableSyncFunctions<T = any> {
+    get?(params: ObservableSyncRemoteGetFnParams<T>): T | Promise<T>;
+    set?(
+        params: ObservableSyncSetParams<T>,
+    ): void | Promise<void | { changes?: object | undefined; dateModified?: number; lastSync?: number }>;
+}

package/src/trace/traceHelpers.ts

@@ -0,0 +1,11 @@
+import type { NodeValue } from '@legendapp/state';
+
+export function getNodePath(node: NodeValue) {
+    const arr: (string | number)[] = [];
+    let n = node;
+    while (n?.key !== undefined) {
+        arr.splice(0, 0, n.key);
+        n = n.parent;
+    }
+    return arr.join('.');
+}

package/src/trace/useTraceListeners.ts

@@ -0,0 +1,34 @@
+import { NodeValue, internal, TrackingNode } from '@legendapp/state';
+import { getNodePath } from './traceHelpers';
+const { optimized, tracking } = internal;
+
+export function useTraceListeners(this: any, name?: string) {
+    if (process.env.NODE_ENV === 'development' && tracking.current) {
+        tracking.current.traceListeners = traceNodes.bind(this, name);
+    }
+}
+
+function traceNodes(name: string | undefined, nodes: Map<NodeValue, TrackingNode>) {
+    if (process.env.NODE_ENV === 'development' && tracking.current) {
+        tracking.current.traceListeners = undefined;
+        const arr: string[] = [];
+        if (nodes) {
+            for (const tracked of nodes.values()) {
+                const { node, track } = tracked;
+                const shallow = track === true;
+                const isOptimized = track === optimized;
+                arr.push(
+                    `${arr.length + 1}: ${getNodePath(node)}${shallow ? ' (shallow)' : ''}${
+                        isOptimized ? ' (optimized)' : ''
+                    }`,
+                );
+            }
+        }
+
+        console.log(
+            `[legend-state] ${name ? name + ' ' : ''}tracking ${arr.length} observable${
+                arr.length !== 1 ? 's' : ''
+            }:\n${arr.join('\n')}`,
+        );
+    }
+}

package/src/trace/useTraceUpdates.ts

@@ -0,0 +1,24 @@
+import { ListenerParams, internal } from '@legendapp/state';
+const { tracking } = internal;
+
+export function useTraceUpdates(name?: string) {
+    if (process.env.NODE_ENV === 'development' && tracking.current) {
+        tracking.current.traceUpdates = replaceUpdateFn.bind(undefined, name);
+    }
+}
+
+function replaceUpdateFn(name: string | undefined, updateFn: Function) {
+    return onChange.bind(undefined, name, updateFn);
+}
+
+function onChange(name: string | undefined, updateFn: Function, params: ListenerParams<any>) {
+    const { changes } = params;
+    if (process.env.NODE_ENV === 'development') {
+        changes.forEach(({ path, valueAtPath, prevAtPath }) => {
+            console.log(`[legend-state] Rendering ${name ? name + ' ' : ''}because "${path}" changed:
+from: ${JSON.stringify(prevAtPath)}
+to: ${JSON.stringify(valueAtPath)}`);
+        });
+        return updateFn();
+    }
+}

package/src/trace/useVerifyNotTracking.ts

@@ -0,0 +1,33 @@
+import { internal, NodeValue, TrackingNode } from '@legendapp/state';
+import { getNodePath } from './traceHelpers';
+const { optimized, tracking } = internal;
+
+export function useVerifyNotTracking(this: any, name?: string) {
+    if (process.env.NODE_ENV === 'development') {
+        tracking.current!.traceListeners = traceNodes.bind(this, name);
+    }
+}
+
+function traceNodes(name: string | undefined, nodes: Map<NodeValue, TrackingNode>) {
+    if (process.env.NODE_ENV === 'development') {
+        tracking.current!.traceListeners = undefined;
+        const arr: string[] = [];
+        if (nodes) {
+            for (const tracked of nodes.values()) {
+                const { node, track } = tracked;
+                const shallow = track === true;
+                const isOptimized = track === optimized;
+                arr.push(
+                    `${arr.length + 1}: ${getNodePath(node)}${shallow ? ' (shallow)' : ''}${
+                        isOptimized ? ' (optimized)' : ''
+                    }`,
+                );
+            }
+            console.error(
+                `[legend-state] ${name ? name + ' ' : ''}tracking ${arr.length} observable${
+                    arr.length !== 1 ? 's' : ''
+                } when it should not be:\n${arr.join('\n')}`,
+            );
+        }
+    }
+}

package/src/trace/useVerifyOneRender.ts

@@ -0,0 +1,10 @@
+import { useRef } from 'react';
+
+export function useVerifyOneRender(name?: string) {
+    if (process.env.NODE_ENV === 'development') {
+        const numRenders = ++useRef(0).current;
+        if (numRenders > 1) {
+            console.error(`[legend-state] ${name ? name + ' ' : ''}Component rendered more than once`);
+        }
+    }
+}

package/src/trackSelector.ts

@@ -0,0 +1,52 @@
+import { computeSelector } from './helpers';
+import type { ListenerParams, ObserveEvent, Selector } from './observableInterfaces';
+import type { ObserveOptions } from './observe';
+import { setupTracking } from './setupTracking';
+import { beginTracking, endTracking, tracking } from './tracking';
+
+export function trackSelector<T>(
+    selector: Selector<T>,
+    update: (params: ListenerParams) => void,
+    observeEvent?: ObserveEvent<T>,
+    observeOptions?: ObserveOptions,
+    createResubscribe?: boolean,
+) {
+    let dispose: undefined | (() => void);
+    let resubscribe: (() => () => void) | undefined;
+    let updateFn = update;
+
+    beginTracking();
+    const value = selector ? computeSelector(selector, observeEvent, observeOptions?.fromComputed) : selector;
+    const tracker = tracking.current;
+    const nodes = tracker!.nodes;
+    endTracking();
+
+    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {
+        tracker.traceListeners?.(nodes);
+        if (tracker.traceUpdates) {
+            updateFn = tracker.traceUpdates(update) as () => void;
+        }
+        // Clear tracing so it doesn't leak to other components
+        tracker.traceListeners = undefined;
+        tracker.traceUpdates = undefined;
+    }
+
+    if (!observeEvent?.cancel) {
+        // Do tracing if it was requested
+
+        // useSyncExternalStore doesn't subscribe until after the component mount.
+        // We want to subscribe immediately so we don't miss any updates
+        dispose = setupTracking(nodes, updateFn, false, observeOptions?.immediate);
+        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+            resubscribe = createResubscribe
+                ? () => {
+                      dispose?.();
+                      dispose = setupTracking(nodes, updateFn);
+                      return dispose;
+                  }
+                : undefined;
+        }
+    }
+
+    return { nodes, value, dispose, resubscribe };
+}

package/src/tracking.ts

@@ -0,0 +1,43 @@
+import type { NodeValue, TrackingState, TrackingType } from './observableInterfaces';
+
+let trackCount = 0;
+const trackingQueue: (TrackingState | undefined)[] = [];
+
+export const tracking = {
+    current: undefined as TrackingState | undefined,
+};
+
+export function beginTracking() {
+    // Keep a copy of the previous tracking context so it can be restored
+    // when this context is complete
+    trackingQueue.push(tracking.current);
+    trackCount++;
+    tracking.current = {};
+}
+export function endTracking() {
+    // Restore the previous tracking context
+    trackCount--;
+    if (trackCount < 0) {
+        trackCount = 0;
+    }
+    tracking.current = trackingQueue.pop();
+}
+
+export function updateTracking(node: NodeValue, track?: TrackingType) {
+    if (trackCount) {
+        const tracker = tracking.current;
+        if (tracker) {
+            if (!tracker.nodes) {
+                tracker.nodes = new Map();
+            }
+
+            const existing = tracker.nodes.get(node);
+            if (existing) {
+                existing.track = existing.track || track;
+                existing.num++;
+            } else {
+                tracker.nodes.set(node, { node, track, num: 1 });
+            }
+        }
+    }
+}

package/src/types/babel.d.ts

@@ -0,0 +1,12 @@
+import type { ObservableParam } from '@legendapp/state';
+import { ReactNode } from 'react';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { Computed, Memo } from '@legendapp/state/react';
+declare module '@legendapp/state/react' {
+    export declare const Computed: (props: {
+        children: ObservableParam | (() => ReactNode) | ReactNode;
+    }) => React.ReactElement;
+    export declare const Memo: (props: {
+        children: ObservableParam | (() => ReactNode) | ReactNode;
+    }) => React.ReactElement;
+}

package/src/when.ts

@@ -0,0 +1,70 @@
+import { computeSelector, isObservableValueReady } from './helpers';
+import { isPromise } from './is';
+import type { ObserveEvent, Selector } from './observableInterfaces';
+import { observe } from './observe';
+
+function _when<T, T2>(predicate: Selector<T>, effect?: (value: T) => T2, checkReady?: boolean): any {
+    // If predicate is a regular Promise skip all the observable stuff
+    if (isPromise<T>(predicate)) {
+        return effect ? predicate.then(effect) : (predicate as any);
+    }
+
+    let value: T | undefined;
+    let effectValue: T2 | undefined;
+
+    // Create a wrapping fn that calls the effect if predicate returns true
+    function run(e: ObserveEvent<T>) {
+        const ret = computeSelector(predicate);
+
+        if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
+            value = ret;
+
+            // Set cancel so that observe does not track anymore
+            e.cancel = true;
+        }
+
+        return value;
+    }
+    function doEffect() {
+        // If value is truthy then run the effect
+        effectValue = effect?.(value!);
+    }
+    // Run in an observe
+    observe(run, doEffect);
+
+    // If first run resulted in a truthy value just return it.
+    // It will have set e.cancel so no need to dispose
+    if (isPromise<T>(value)) {
+        return effect ? value.then(effect) : (value as any);
+    } else if (value !== undefined) {
+        return effect ? effectValue : Promise.resolve(value);
+    } else {
+        // Wrap it in a promise
+        const promise = new Promise<T2>((resolve) => {
+            if (effect) {
+                const originalEffect = effect;
+                effect = ((value: T) => {
+                    const effectValue = originalEffect(value);
+                    resolve(isPromise(effectValue) ? effectValue.then((value) => value as T2) : effectValue);
+                }) as any;
+            } else {
+                effect = resolve as any;
+            }
+        });
+
+        return promise;
+    }
+}
+
+export function when<T, T2>(predicate: Promise<T>, effect: (value: T) => T2): Promise<T2>;
+export function when<T, T2>(predicate: Selector<T>, effect: (value: T) => T2): Promise<T2>;
+export function when<T>(predicate: Selector<T>): Promise<T>;
+export function when<T, T2>(predicate: Selector<T>, effect?: (value: T) => T2): Promise<T | T2> {
+    return _when<T, T2>(predicate, effect, false);
+}
+export function whenReady<T, T2>(predicate: Promise<T>, effect: (value: T) => T2): Promise<T2>;
+export function whenReady<T, T2>(predicate: Selector<T>, effect: (value: T) => T2): Promise<T2>;
+export function whenReady<T>(predicate: Selector<T>): Promise<T>;
+export function whenReady<T, T2>(predicate: Selector<T>, effect?: (value: T) => T2): Promise<T | T2> {
+    return _when<T, T2>(predicate, effect, true);
+}

package/sync-plugins/fetch.d.ts

@@ -0,0 +1,11 @@
+import { Synced, SyncedOptions, SyncedSetParams } from '@legendapp/state';
+export interface SyncedFetchProps extends Omit<SyncedOptions, 'get' | 'set'> {
+    get: string | RequestInfo;
+    set?: string | RequestInfo;
+    getInit?: RequestInit;
+    setInit?: RequestInit;
+    valueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text';
+    onSetValueType?: 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text';
+    onSet?: (params: SyncedSetParams<any>) => void;
+}
+export declare function syncedFetch<T>({ get, set, getInit, setInit, valueType, onSet, onSetValueType, }: SyncedFetchProps): Synced<T>;

package/sync-plugins/fetch.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var state = require('@legendapp/state');
+var persist = require('@legendapp/state/persist');
+
+function syncedFetch({ get, set, getInit, setInit, valueType, onSet, onSetValueType, }) {
+    const ret = {
+        get: () => fetch(get, getInit).then((response) => response[valueType || 'json']()),
+    };
+    if (set) {
+        ret.set = async (params) => {
+            const requestInfo = state.isString(set) ? { url: set } : set;
+            const response = await fetch(Object.assign({ method: 'POST' }, requestInfo, { body: JSON.stringify(params.value) }), setInit);
+            if (onSet) {
+                params.value = response[onSetValueType || valueType || 'json']();
+                onSet(params);
+            }
+        };
+    }
+    return persist.synced(ret);
+}
+
+exports.syncedFetch = syncedFetch;
+//# sourceMappingURL=fetch.js.map

package/sync-plugins/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.js","sources":["../src/sync-plugins/fetch.ts"],"sourcesContent":[null],"names":["isString","synced"],"mappings":";;;;;SAagB,WAAW,CAAI,EAC3B,GAAG,EACH,GAAG,EACH,OAAO,EACP,OAAO,EACP,SAAS,EACT,KAAK,EACL,cAAc,GACC,EAAA;AACf,IAAA,MAAM,GAAG,GAAkB;QACvB,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,SAAS,IAAI,MAAM,CAAC,EAAE,CAAC;KACrF,CAAC;IAEF,IAAI,GAAG,EAAE;AACL,QAAA,GAAG,CAAC,GAAG,GAAG,OAAO,MAA4B,KAAI;AAC7C,YAAA,MAAM,WAAW,GAAGA,cAAQ,CAAC,GAAG,CAAC,GAAI,EAAE,GAAG,EAAE,GAAG,EAAkB,GAAG,GAAG,CAAC;AACxE,YAAA,MAAM,QAAQ,GAAG,MAAM,KAAK,CACxB,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EACtF,OAAO,CACV,CAAC;YACF,IAAI,KAAK,EAAE;AACP,gBAAA,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC,cAAc,IAAI,SAAS,IAAI,MAAM,CAAC,EAAE,CAAC;gBACjE,KAAK,CAAC,MAAM,CAAC,CAAC;aACjB;AACL,SAAC,CAAC;KACL;AAED,IAAA,OAAOC,cAAM,CAAC,GAAG,CAAC,CAAC;AACvB;;;;"}

package/sync-plugins/fetch.mjs

@@ -0,0 +1,22 @@
+import { isString } from '@legendapp/state';
+import { synced } from '@legendapp/state/persist';
+
+function syncedFetch({ get, set, getInit, setInit, valueType, onSet, onSetValueType, }) {
+    const ret = {
+        get: () => fetch(get, getInit).then((response) => response[valueType || 'json']()),
+    };
+    if (set) {
+        ret.set = async (params) => {
+            const requestInfo = isString(set) ? { url: set } : set;
+            const response = await fetch(Object.assign({ method: 'POST' }, requestInfo, { body: JSON.stringify(params.value) }), setInit);
+            if (onSet) {
+                params.value = response[onSetValueType || valueType || 'json']();
+                onSet(params);
+            }
+        };
+    }
+    return synced(ret);
+}
+
+export { syncedFetch };
+//# sourceMappingURL=fetch.mjs.map

package/sync-plugins/fetch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.mjs","sources":["../src/sync-plugins/fetch.ts"],"sourcesContent":[null],"names":[],"mappings":";;;SAagB,WAAW,CAAI,EAC3B,GAAG,EACH,GAAG,EACH,OAAO,EACP,OAAO,EACP,SAAS,EACT,KAAK,EACL,cAAc,GACC,EAAA;AACf,IAAA,MAAM,GAAG,GAAkB;QACvB,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,SAAS,IAAI,MAAM,CAAC,EAAE,CAAC;KACrF,CAAC;IAEF,IAAI,GAAG,EAAE;AACL,QAAA,GAAG,CAAC,GAAG,GAAG,OAAO,MAA4B,KAAI;AAC7C,YAAA,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAI,EAAE,GAAG,EAAE,GAAG,EAAkB,GAAG,GAAG,CAAC;AACxE,YAAA,MAAM,QAAQ,GAAG,MAAM,KAAK,CACxB,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EACtF,OAAO,CACV,CAAC;YACF,IAAI,KAAK,EAAE;AACP,gBAAA,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC,cAAc,IAAI,SAAS,IAAI,MAAM,CAAC,EAAE,CAAC;gBACjE,KAAK,CAAC,MAAM,CAAC,CAAC;aACjB;AACL,SAAC,CAAC;KACL;AAED,IAAA,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AACvB;;;;"}

package/sync.d.ts

@@ -0,0 +1,8 @@
+import type { SyncedOptionsGlobal } from '@legendapp/state';
+export { configureObservableSync } from './src/sync/configureObservableSync';
+export { mapSyncPlugins, syncObservable } from './src/sync/syncObservable';
+export { synced } from './src/sync/synced';
+export declare function isInRemoteChange(): boolean;
+export declare const internal: {
+    observableSyncConfiguration: SyncedOptionsGlobal;
+};