@legendapp/state 3.0.0-beta.4 → 3.0.0-beta.40

package/sync-plugins/firebase.js

@@ -103,6 +103,61 @@ if (process.env.NODE_ENV === "development") {
   };
 }
 
+// src/is.ts
+function isMap(obj) {
+  return obj instanceof Map || obj instanceof WeakMap;
+}
+var globalState = {
+  pendingNodes: /* @__PURE__ */ new Map(),
+  dirtyNodes: /* @__PURE__ */ new Set()
+};
+function replacer(key, value) {
+  if (isMap(value)) {
+    return {
+      __LSType: "Map",
+      value: Array.from(value.entries())
+      // or with spread: value: [...value]
+    };
+  } else if (value instanceof Set) {
+    return {
+      __LSType: "Set",
+      value: Array.from(value)
+      // or with spread: value: [...value]
+    };
+  } else if (globalState.replacer) {
+    value = globalState.replacer(key, value);
+  }
+  return value;
+}
+var ISO8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+function reviver(key, value) {
+  if (value) {
+    if (typeof value === "string" && ISO8601.test(value)) {
+      return new Date(value);
+    }
+    if (typeof value === "object") {
+      if (value.__LSType === "Map") {
+        return new Map(value.value);
+      } else if (value.__LSType === "Set") {
+        return new Set(value.value);
+      }
+    }
+    if (globalState.reviver) {
+      value = globalState.reviver(key, value);
+    }
+  }
+  return value;
+}
+function safeStringify(value) {
+  return value ? JSON.stringify(value, replacer) : value;
+}
+function safeParse(value) {
+  return value ? JSON.parse(value, reviver) : value;
+}
+function clone(value) {
+  return safeParse(safeStringify(value));
+}
+
 // src/sync-plugins/firebase.ts
 var isEnabled$ = state.observable(true);
 var firebaseConfig = {};
@@ -154,9 +209,6 @@ var fns = {
 };
 function syncedFirebase(props) {
   props = { ...firebaseConfig, ...props };
-  const saving$ = state.observable({});
-  const pendingOutgoing$ = state.observable({});
-  const pendingIncoming$ = state.observable({});
   let didList = false;
   const {
     refPath,
@@ -174,6 +226,102 @@ function syncedFirebase(props) {
   const { fieldCreatedAt, changesSince } = props;
   const asType = props.as || "value";
   const fieldUpdatedAt = props.fieldUpdatedAt || "@";
+  const isRealtime = realtime !== false;
+  const pendingWrites = /* @__PURE__ */ new Map();
+  const enqueuePendingWrite = (key) => {
+    let resolveFn;
+    let rejectFn;
+    const promise = new Promise((resolve, reject) => {
+      resolveFn = resolve;
+      rejectFn = reject;
+    });
+    const entry = {
+      resolve: resolveFn,
+      reject: rejectFn
+    };
+    const state = pendingWrites.get(key);
+    if (state) {
+      state.waiting.push(entry);
+      state.pendingCount += 1;
+    } else {
+      pendingWrites.set(key, {
+        waiting: [entry],
+        ready: [],
+        pendingCount: 1
+      });
+    }
+    return { promise, entry };
+  };
+  const flushPending = (key) => {
+    const state = pendingWrites.get(key);
+    if (!state) {
+      return;
+    }
+    if (state.pendingCount === 0 && state.staged) {
+      const { value, apply } = state.staged;
+      state.staged = void 0;
+      while (state.ready.length) {
+        const entry = state.ready.shift();
+        entry.resolve(value);
+      }
+      if (!state.waiting.length && !state.ready.length) {
+        pendingWrites.delete(key);
+      }
+      apply == null ? void 0 : apply(value);
+    }
+  };
+  const resolvePendingWrite = (key, entry) => {
+    const state = pendingWrites.get(key);
+    if (!state) {
+      return;
+    }
+    const waitingIndex = state.waiting.indexOf(entry);
+    if (waitingIndex >= 0) {
+      state.waiting.splice(waitingIndex, 1);
+      state.pendingCount = Math.max(0, state.pendingCount - 1);
+    }
+    state.ready.push(entry);
+    flushPending(key);
+  };
+  const rejectPendingWrite = (key, entry, error) => {
+    const state = pendingWrites.get(key);
+    if (state) {
+      const waitingIndex = state.waiting.indexOf(entry);
+      if (waitingIndex >= 0) {
+        state.waiting.splice(waitingIndex, 1);
+        state.pendingCount = Math.max(0, state.pendingCount - 1);
+      } else {
+        const readyIndex = state.ready.indexOf(entry);
+        if (readyIndex >= 0) {
+          state.ready.splice(readyIndex, 1);
+        }
+      }
+      if (!state.waiting.length && !state.ready.length) {
+        pendingWrites.delete(key);
+      }
+    }
+    entry.reject(error);
+  };
+  const handleServerValue = (key, value, apply) => {
+    var _a;
+    const state = pendingWrites.get(key);
+    if (!state || !state.waiting.length && !state.ready.length) {
+      pendingWrites.delete(key);
+      apply == null ? void 0 : apply(value);
+    } else {
+      state.staged = {
+        value: value && typeof value === "object" ? clone(value) : value,
+        apply: apply != null ? apply : (_a = state.staged) == null ? void 0 : _a.apply
+      };
+      flushPending(key);
+    }
+  };
+  const ensureFieldId = (key, value) => {
+    if (fieldId && key && value && typeof value === "object" && !value[fieldId]) {
+      value[fieldId] = key;
+    }
+    return value;
+  };
   const computeRef = (lastSync) => {
     const pathFirebase = refPath(fns.getCurrentUser());
     let ref = fns.ref(pathFirebase);
@@ -185,7 +333,8 @@ function syncedFirebase(props) {
     }
     return ref;
   };
-  const list = async ({ lastSync, onError }) => {
+  const list = async (getParams) => {
+    const { lastSync, onError } = getParams;
     const ref = computeRef(lastSync);
     return new Promise((resolve) => {
       fns.once(
@@ -195,20 +344,17 @@ function syncedFirebase(props) {
           let values = [];
           if (!state.isNullOrUndefined(val)) {
             values = asType === "value" ? [val] : Object.entries(val).map(([key, value]) => {
-              if (fieldId && !value[fieldId]) {
-                value[fieldId] = key;
-              }
-              return value;
+              return ensureFieldId(key, value);
             });
           }
           didList = true;
           resolve(values);
         },
-        onError
+        (error) => onError(error, { source: "list", type: "get", retry: getParams })
       );
     });
   };
-  const subscribe = realtime ? ({ lastSync, update: update2, onError }) => {
+  const subscribe = isRealtime ? ({ lastSync, update: update2, onError }) => {
     const ref = computeRef(lastSync);
     let unsubscribes;
     if (asType === "value") {
@@ -216,14 +362,12 @@ function syncedFirebase(props) {
         if (!didList)
           return;
         const val = snap.val();
-        if (saving$[""].get()) {
-          pendingIncoming$[""].set(val);
-        } else {
+        handleServerValue("", val, (resolvedValue) => {
           update2({
-            value: [val],
+            value: [resolvedValue],
             mode: "set"
           });
-        }
+        });
       };
       unsubscribes = [fns.onValue(ref, onValue2, onError)];
     } else {
@@ -231,31 +375,26 @@ function syncedFirebase(props) {
         if (!didList)
           return;
         const key = snap.key;
-        const val = snap.val();
-        if (fieldId && !val[fieldId]) {
-          val[fieldId] = key;
-        }
-        if (saving$[key].get()) {
-          pendingIncoming$[key].set(val);
-        } else {
+        const val = ensureFieldId(key, snap.val());
+        handleServerValue(key, val, (resolvedValue) => {
           update2({
-            value: [val],
-            mode: "assign"
+            value: [resolvedValue],
+            mode: "merge"
           });
-        }
+        });
       };
       const onChildDelete = (snap) => {
         if (!didList)
           return;
         const key = snap.key;
-        const val = snap.val();
-        if (fieldId && !val[fieldId]) {
-          val[fieldId] = key;
-        }
-        val[state.symbolDelete] = true;
-        update2({
-          value: [val],
-          mode: "assign"
+        const valueRaw = snap.val();
+        const valueWithId = ensureFieldId(key, state.isNullOrUndefined(valueRaw) ? {} : valueRaw);
+        valueWithId[state.symbolDelete] = true;
+        handleServerValue(key, valueWithId, (resolvedValue) => {
+          update2({
+            value: [resolvedValue],
+            mode: "merge"
+          });
         });
       };
       unsubscribes = [
@@ -279,42 +418,52 @@ function syncedFirebase(props) {
     }
     return addUpdatedAt(input);
   };
-  const upsert = async (input) => {
-    const id = fieldId ? input[fieldId] : "";
-    if (saving$[id].get()) {
-      pendingOutgoing$[id].set(input);
-    } else {
-      saving$[id].set(true);
-      const path = joinPaths(refPath(fns.getCurrentUser()), fieldId ? id : "");
-      await fns.update(fns.ref(path), input);
-      saving$[id].set(false);
-      flushAfterSave();
-    }
-    return state.when(
-      () => !pendingOutgoing$[id].get(),
-      () => {
-        const value = pendingIncoming$[id].get();
-        if (value) {
-          pendingIncoming$[id].delete();
-          return value;
-        }
-      }
-    );
-  };
-  const flushAfterSave = () => {
-    const outgoing = pendingOutgoing$.get();
-    Object.values(outgoing).forEach((value) => {
-      upsert(value);
+  const upsert = (input, params) => {
+    const id = fieldId && asType !== "value" ? input[fieldId] : "";
+    const pendingKey = fieldId && asType !== "value" ? String(id != null ? id : "") : "";
+    const { promise, entry } = enqueuePendingWrite(pendingKey);
+    const userId = fns.getCurrentUser();
+    const basePath = refPath(userId);
+    const childPath = fieldId && asType !== "value" ? pendingKey : "";
+    const path = joinPaths(basePath, childPath);
+    const ref = fns.ref(path);
+    const updatePromise = fns.update(ref, input);
+    updatePromise.then(() => {
+      resolvePendingWrite(pendingKey, entry);
+    }).catch((error) => {
+      rejectPendingWrite(pendingKey, entry, error);
     });
-    pendingOutgoing$.set({});
+    if (!isRealtime) {
+      updatePromise.then(() => {
+        const onceRef = fieldId && asType !== "value" ? ref : fns.ref(basePath);
+        fns.once(
+          onceRef,
+          (snap) => {
+            const rawValue = snap.val();
+            const value = fieldId && asType !== "value" ? ensureFieldId(pendingKey, state.isNullOrUndefined(rawValue) ? {} : rawValue) : rawValue;
+            handleServerValue(pendingKey, value, (resolvedValue) => {
+              params.update({
+                value: resolvedValue,
+                mode: "merge"
+              });
+            });
+          },
+          (error) => {
+            rejectPendingWrite(pendingKey, entry, error);
+          }
+        );
+      }).catch(() => {
+      });
+    }
+    return promise;
   };
-  const create = readonly ? void 0 : (input) => {
+  const create = readonly ? void 0 : (input, params) => {
     addCreatedAt(input);
-    return upsert(input);
+    return upsert(input, params);
   };
-  const update = readonly ? void 0 : (input) => {
+  const update = readonly ? void 0 : (input, params) => {
     addUpdatedAt(input);
-    return upsert(input);
+    return upsert(input, params);
   };
   const deleteFn = readonly ? void 0 : (input) => {
     const path = joinPaths(
@@ -354,6 +503,7 @@ function syncedFirebase(props) {
   }
   return crud.syncedCrud({
     ...rest,
+    // Workaround for type errors
     list,
     subscribe,
     create,