@legendapp/state 3.0.0-beta.0 → 3.0.0-beta.11

package/sync.mjs

@@ -637,8 +637,11 @@ async function doChangeRemote(changeInfo) {
       );
       let didError = false;
       if (isPromise$1(savedPromise)) {
-        await savedPromise.catch(() => {
+        await savedPromise.catch((error) => {
           didError = true;
+          if (!syncOptions.retry) {
+            onError(error);
+          }
         });
       }
       if (!didError) {
@@ -738,9 +741,20 @@ async function loadLocal(value$, syncOptions, syncState$, localState) {
       await when(initialized$);
     }
     if (persistPlugin.loadTable) {
-      const promise = persistPlugin.loadTable(table, config);
-      if (promise) {
-        await promise;
+      try {
+        const promise = persistPlugin.loadTable(table, config);
+        if (promise) {
+          await promise;
+        }
+      } catch (err) {
+        if (process.env.NODE_ENV === "development") {
+          console.error(
+            "[legend-state] Error loading local cache. This would be a crashing error in production.",
+            err
+          );
+        } else {
+          throw err;
+        }
       }
     }
     const prevValue = getNodeValue(node);
@@ -843,7 +857,8 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       localState.isApplyingPending = false;
     }
   };
-  if (syncOptions.get) {
+  const { get, subscribe } = syncOptions;
+  if (get || subscribe) {
     sync = async () => {
       var _a;
       if (isSynced && (!getNodeValue(getNode(syncState$)).isSyncEnabled || shouldIgnoreUnobserved(node, sync))) {
@@ -856,8 +871,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
       const pending = localState.pendingChanges;
-      const get = syncOptions.get;
-      if (get) {
+      if (get || subscribe) {
         const { waitFor } = syncOptions;
         const runGet = () => {
           var _a2;
@@ -950,7 +964,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             node.activationState.onChange = onChange;
           }
           if (!isSubscribed && syncOptions.subscribe) {
-            const subscribe = syncOptions.subscribe;
+            const subscribe2 = syncOptions.subscribe;
             isSubscribed = true;
             const doSubscribe = () => {
               const subscribeParams = {
@@ -958,17 +972,27 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                 value$: obs$,
                 lastSync,
                 update: (params) => {
-                  when(syncState$.isLoaded, () => {
-                    when(waitFor || true, () => {
-                      params.mode || (params.mode = syncOptions.mode || "merge");
-                      onChange(params);
-                    });
-                  });
+                  when(
+                    () => !get || syncState$.isLoaded.get(),
+                    () => {
+                      when(waitFor || true, () => {
+                        params.mode || (params.mode = syncOptions.mode || "merge");
+                        onChange(params);
+                        if (!syncState$.isLoaded.peek()) {
+                          syncState$.assign({
+                            isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                            error: void 0,
+                            isGetting: syncStateValue.numPendingGets > 0
+                          });
+                        }
+                      });
+                    }
+                  );
                 },
                 refresh: () => when(syncState$.isLoaded, sync),
                 onError: (error) => onGetError(error, { source: "subscribe", subscribeParams })
               };
-              unsubscribe = subscribe(subscribeParams);
+              unsubscribe = subscribe2(subscribeParams);
             };
             if (waitFor) {
               whenReady(waitFor, doSubscribe);
@@ -977,85 +1001,87 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             }
           }
           const existingValue = getNodeValue(node);
-          const onError = (error) => onGetError(error, { getParams, source: "get" });
-          const getParams = {
-            node,
-            value$: obs$,
-            value: isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
-            mode: syncOptions.mode,
-            refresh: sync,
-            options: syncOptions,
-            lastSync,
-            updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
-            onError,
-            retryNum: 0,
-            cancelRetry: false
-          };
-          let modeBeforeReset = void 0;
-          const beforeGetParams = {
-            value: getParams.value,
-            lastSync,
-            pendingChanges: pending && !isEmpty(pending) ? pending : void 0,
-            clearPendingChanges: async () => {
-              localState.pendingChanges = {};
-              await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
-                pending: localState.pendingChanges
-              });
-            },
-            resetCache: () => {
-              var _a3;
-              modeBeforeReset = getParams.mode;
-              getParams.mode = "set";
-              return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
-            },
-            cancel: false
-          };
-          (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
-          if (!beforeGetParams.cancel) {
-            syncState$.assign({
-              numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
-              isGetting: true
-            });
-            const got = runWithRetry(
-              getParams,
-              syncOptions.retry,
-              (retryEvent) => {
-                const params = getParams;
-                params.cancelRetry = retryEvent.cancelRetry;
-                params.retryNum = retryEvent.retryNum;
-                return get(params);
-              },
-              onError
-            );
-            const numGets = node.numGets = (node.numGets || 0) + 1;
-            const handle = (value) => {
-              syncState$.numPendingGets.set((v) => v - 1);
-              if (isWaitingForLoad) {
-                isWaitingForLoad = false;
-                syncStateValue.numPendingRemoteLoads--;
-              }
-              if (numGets >= (node.getNumResolved || 0)) {
-                node.getNumResolved = node.numGets;
-                onChange({
-                  value,
-                  lastSync: getParams.lastSync,
-                  mode: getParams.mode
+          if (get) {
+            const onError = (error) => onGetError(error, { getParams, source: "get" });
+            const getParams = {
+              node,
+              value$: obs$,
+              value: isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
+              mode: syncOptions.mode,
+              refresh: sync,
+              options: syncOptions,
+              lastSync,
+              updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
+              onError,
+              retryNum: 0,
+              cancelRetry: false
+            };
+            let modeBeforeReset = void 0;
+            const beforeGetParams = {
+              value: getParams.value,
+              lastSync,
+              pendingChanges: pending && !isEmpty(pending) ? pending : void 0,
+              clearPendingChanges: async () => {
+                localState.pendingChanges = {};
+                await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                  pending: localState.pendingChanges
                 });
-              }
-              if (modeBeforeReset) {
-                getParams.mode = modeBeforeReset;
-                modeBeforeReset = void 0;
-              }
+              },
+              resetCache: () => {
+                var _a3;
+                modeBeforeReset = getParams.mode;
+                getParams.mode = "set";
+                return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
+              },
+              cancel: false
+            };
+            (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
+            if (!beforeGetParams.cancel) {
               syncState$.assign({
-                isLoaded: syncStateValue.numPendingRemoteLoads < 1,
-                error: void 0,
-                isGetting: syncStateValue.numPendingGets > 0
+                numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
+                isGetting: true
               });
-            };
-            if (isPromise$1(got)) {
-              got.then(handle).catch(onError);
-            } else {
-              handle(got);
+              const got = runWithRetry(
+                getParams,
+                syncOptions.retry,
+                (retryEvent) => {
+                  const params = getParams;
+                  params.cancelRetry = retryEvent.cancelRetry;
+                  params.retryNum = retryEvent.retryNum;
+                  return get(params);
+                },
+                onError
+              );
+              const numGets = node.numGets = (node.numGets || 0) + 1;
+              const handle = (value) => {
+                syncState$.numPendingGets.set((v) => v - 1);
+                if (isWaitingForLoad) {
+                  isWaitingForLoad = false;
+                  syncStateValue.numPendingRemoteLoads--;
+                }
+                if (numGets >= (node.getNumResolved || 0)) {
+                  node.getNumResolved = node.numGets;
+                  onChange({
+                    value,
+                    lastSync: getParams.lastSync,
+                    mode: getParams.mode
+                  });
+                }
+                if (modeBeforeReset) {
+                  getParams.mode = modeBeforeReset;
+                  modeBeforeReset = void 0;
+                }
+                syncState$.assign({
+                  isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                  error: void 0,
+                  isGetting: syncStateValue.numPendingGets > 0
+                });
+              };
+              if (isPromise$1(got)) {
+                got.then(handle).catch(onError);
+              } else {
+                handle(got);
+              }
             }
           }
         };
@@ -1127,7 +1153,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     return true;
   };
   when(onAllPersistLoaded, function() {
-    if (syncOptions.get && syncOptions.syncMode === "auto") {
+    if ((syncOptions.get || syncOptions.subscribe) && syncOptions.syncMode === "auto") {
       sync();
     }
     if ((syncOptions == null ? void 0 : syncOptions.set) || (syncOptions == null ? void 0 : syncOptions.persist)) {

package/trace.js

@@ -19,13 +19,12 @@ function getNodePath(node) {
 // src/trace/useTraceListeners.ts
 var { optimized, tracking } = state.internal;
 function useTraceListeners(name) {
-  if (process.env.NODE_ENV === "development" && tracking.current) {
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && tracking.current) {
     tracking.current.traceListeners = traceNodes.bind(this, name);
   }
 }
 function traceNodes(name, nodes) {
-  if (process.env.NODE_ENV === "development" && tracking.current) {
-    tracking.current.traceListeners = void 0;
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && nodes.size) {
     const arr = [];
     if (nodes) {
       for (const tracked of nodes.values()) {
@@ -45,7 +44,7 @@ ${arr.join("\n")}`
 }
 var { tracking: tracking2 } = state.internal;
 function useTraceUpdates(name) {
-  if (process.env.NODE_ENV === "development" && tracking2.current) {
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && tracking2.current) {
     tracking2.current.traceUpdates = replaceUpdateFn.bind(void 0, name);
   }
 }
@@ -54,13 +53,13 @@ function replaceUpdateFn(name, updateFn) {
 }
 function onChange(name, updateFn, params) {
   const { changes } = params;
-  if (process.env.NODE_ENV === "development") {
+  if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
     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();
+    return updateFn(params);
   }
 }
 var { optimized: optimized2, tracking: tracking3 } = state.internal;

package/trace.mjs

@@ -17,13 +17,12 @@ function getNodePath(node) {
 // src/trace/useTraceListeners.ts
 var { optimized, tracking } = internal;
 function useTraceListeners(name) {
-  if (process.env.NODE_ENV === "development" && tracking.current) {
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && tracking.current) {
     tracking.current.traceListeners = traceNodes.bind(this, name);
   }
 }
 function traceNodes(name, nodes) {
-  if (process.env.NODE_ENV === "development" && tracking.current) {
-    tracking.current.traceListeners = void 0;
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && nodes.size) {
     const arr = [];
     if (nodes) {
       for (const tracked of nodes.values()) {
@@ -43,7 +42,7 @@ ${arr.join("\n")}`
 }
 var { tracking: tracking2 } = internal;
 function useTraceUpdates(name) {
-  if (process.env.NODE_ENV === "development" && tracking2.current) {
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && tracking2.current) {
     tracking2.current.traceUpdates = replaceUpdateFn.bind(void 0, name);
   }
 }
@@ -52,13 +51,13 @@ function replaceUpdateFn(name, updateFn) {
 }
 function onChange(name, updateFn, params) {
   const { changes } = params;
-  if (process.env.NODE_ENV === "development") {
+  if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
     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();
+    return updateFn(params);
   }
 }
 var { optimized: optimized2, tracking: tracking3 } = internal;

package/types/reactive-native.d.ts

@@ -0,0 +1,19 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { IReactive } from '@legendapp/state/react';
+
+declare module '@legendapp/state/react' {
+    interface IReactive {
+        ActivityIndicator: FCReactive<ActivityIndicator, ActivityIndicatorProps>;
+        Button: FCReactive<Button, ButtonProps>;
+        FlatList: FCReactive<FlatList, FlatListProps<any>>;
+        Image: FCReactive<Image, ImageProps>;
+        Pressable: FCReactive<typeof Pressable, PressableProps>;
+        ScrollView: FCReactive<ScrollView, ScrollViewProps>;
+        SectionList: FCReactive<SectionList, SectionListProps<any>>;
+        Switch: FCReactive<Switch, SwitchProps>;
+        Text: FCReactive<Text, TextProps>;
+        TextInput: FCReactive<TextInput, TextInputProps>;
+        TouchableWithoutFeedback: FCReactive<TouchableWithoutFeedback, TouchableWithoutFeedbackProps>;
+        View: FCReactive<View, ViewProps>;
+    }
+}

package/types/reactive-web.d.ts

@@ -0,0 +1,7 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { IReactive, FCReactiveObject } from '@legendapp/state/react';
+
+declare module '@legendapp/state/react' {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface IReactive extends FCReactiveObject<JSX.IntrinsicElements> {}
+}