atom.io 0.18.0 → 0.18.1

package/realtime-client/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var Internal3 = require('atom.io/internal');
+var Internal = require('atom.io/internal');
 var json = require('atom.io/json');
 var AtomIO = require('atom.io');
 var realtimeClient = require('atom.io/realtime-client');
@@ -23,13 +23,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var Internal3__namespace = /*#__PURE__*/_interopNamespace(Internal3);
+var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
 var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
 
 // realtime-client/src/pull-atom.ts
 function pullAtom(token, socket, store) {
   const setServedValue = (data) => {
-    Internal3.setIntoStore(token, data, store);
+    Internal.setIntoStore(token, data, store);
   };
   socket.on(`serve:${token.key}`, setServedValue);
   socket.emit(`sub:${token.key}`);
@@ -47,7 +47,7 @@ function pullAtomFamilyMember(token, socket, store) {
   const { key: familyKey, subKey: serializedSubKey } = token.family;
   const subKey = json.parseJson(serializedSubKey);
   socket == null ? void 0 : socket.on(`serve:${token.key}`, (data) => {
-    Internal3.setIntoStore(token, data, store);
+    Internal.setIntoStore(token, data, store);
   });
   socket == null ? void 0 : socket.emit(`sub:${familyKey}`, subKey);
   return () => {
@@ -56,15 +56,15 @@ function pullAtomFamilyMember(token, socket, store) {
   };
 }
 function pullMutableAtom(token, socket, store) {
-  const jsonToken = Internal3.getJsonToken(token);
-  const updateToken = Internal3.getUpdateToken(token);
+  const jsonToken = Internal.getJsonToken(token);
+  const updateToken = Internal.getUpdateToken(token);
   socket.on(`init:${token.key}`, (data) => {
-    Internal3.setIntoStore(jsonToken, data, store);
+    Internal.setIntoStore(jsonToken, data, store);
   });
   socket.on(
     `next:${token.key}`,
     (data) => {
-      Internal3.setIntoStore(updateToken, data, store);
+      Internal.setIntoStore(updateToken, data, store);
     }
   );
   socket.emit(`sub:${token.key}`);
@@ -82,21 +82,21 @@ function pullMutableAtomFamilyMember(token, socket, store) {
   }
   const { key: familyKey, subKey: serializedSubKey } = token.family;
   const subKey = json.parseJson(serializedSubKey);
-  socket == null ? void 0 : socket.on(`init:${token.key}`, (data) => {
-    const jsonToken = Internal3.getJsonToken(token);
-    Internal3.setIntoStore(jsonToken, data, store);
+  socket.on(`init:${token.key}`, (data) => {
+    const jsonToken = Internal.getJsonToken(token);
+    Internal.setIntoStore(jsonToken, data, store);
   });
-  socket == null ? void 0 : socket.on(
+  socket.on(
     `next:${token.key}`,
     (data) => {
-      const trackerToken = Internal3.getUpdateToken(token);
-      Internal3.setIntoStore(trackerToken, data, store);
+      const trackerToken = Internal.getUpdateToken(token);
+      Internal.setIntoStore(trackerToken, data, store);
     }
   );
-  socket == null ? void 0 : socket.emit(`sub:${familyKey}`, subKey);
+  socket.emit(`sub:${familyKey}`, subKey);
   return () => {
-    socket == null ? void 0 : socket.off(`serve:${token.key}`);
-    socket == null ? void 0 : socket.emit(`unsub:${token.key}`);
+    socket.off(`serve:${token.key}`);
+    socket.emit(`unsub:${token.key}`);
   };
 }
 
@@ -164,7 +164,7 @@ function pullSelectorFamilyMember(token, socket, store) {
 }
 function pushState(token, socket, store) {
   socket.emit(`claim:${token.key}`);
-  Internal3__namespace.subscribeToState(
+  Internal__namespace.subscribeToState(
     token,
     ({ newValue }) => {
       socket.emit(`pub:${token.key}`, newValue);
@@ -177,6 +177,23 @@ function pushState(token, socket, store) {
     socket.emit(`unclaim:${token.key}`);
   };
 }
+
+// __unstable__/web-effects/src/storage.ts
+var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
+  const savedValue = storage.getItem(key);
+  if (savedValue != null)
+    setSelf(parse(savedValue));
+  onSet(({ newValue }) => {
+    if (newValue == null) {
+      storage.removeItem(key);
+      return;
+    }
+    storage.setItem(key, stringify(newValue));
+  });
+};
+var lazyLocalStorageEffect = persistAtom(localStorage)(JSON);
+
+// realtime-client/src/realtime-client-stores/client-main-store.ts
 var myIdState__INTERNAL = AtomIO__namespace.atom({
   key: `mySocketId__INTERNAL`,
   default: void 0
@@ -185,6 +202,12 @@ var myIdState = AtomIO__namespace.selector({
   key: `mySocketId`,
   get: ({ get }) => get(myIdState__INTERNAL)
 });
+var usernameEffects = typeof window === `undefined` ? [] : [lazyLocalStorageEffect(`myUsername`)];
+var myUsernameState = AtomIO__namespace.atom({
+  key: `myUsername`,
+  default: null,
+  effects: usernameEffects
+});
 var optimisticUpdateQueue = AtomIO__namespace.atom({
   key: `updateQueue`,
   default: []
@@ -196,7 +219,7 @@ var confirmedUpdateQueue = AtomIO__namespace.atom(
   }
 );
 function serverAction(token, socket, store) {
-  const unsubscribeFromLocalUpdates = Internal3__namespace.subscribeToTransaction(
+  const unsubscribeFromLocalUpdates = Internal__namespace.subscribeToTransaction(
     token,
     (clientUpdate) => {
       socket.emit(`tx-run:${token.key}`, clientUpdate);
@@ -210,9 +233,10 @@ function serverAction(token, socket, store) {
 }
 function syncContinuity(continuity, socket, store) {
   const continuityKey = continuity.key;
-  const optimisticUpdates = Internal3.getFromStore(realtimeClient.optimisticUpdateQueue, store);
-  const confirmedUpdates = Internal3.getFromStore(realtimeClient.confirmedUpdateQueue, store);
+  const optimisticUpdates = Internal.getFromStore(realtimeClient.optimisticUpdateQueue, store);
+  const confirmedUpdates = Internal.getFromStore(realtimeClient.confirmedUpdateQueue, store);
   const initializeContinuity = (epoch, payload) => {
+    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
     let i = 0;
     let k = ``;
     let v = null;
@@ -221,18 +245,26 @@ function syncContinuity(continuity, socket, store) {
         k = x;
       } else {
         v = x;
-        Internal3.setIntoStore(k, v, store);
+        if (`type` in k && k.type === `mutable_atom`) {
+          k = Internal.getJsonToken(k);
+        }
+        Internal.setIntoStore(k, v, store);
       }
       i++;
     }
-    Internal3.setEpochNumberOfContinuity(continuityKey, epoch, store);
+    Internal.setEpochNumberOfContinuity(continuityKey, epoch, store);
   };
   socket.off(`continuity-init:${continuityKey}`);
   socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
   const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
     function reconcileEpoch(optimisticUpdate, confirmedUpdate2) {
-      store.logger.info(`\u2696\uFE0F`, `continuity`, continuityKey, `reconciling updates`);
-      Internal3.setIntoStore(
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `reconciling updates`
+      );
+      Internal.setIntoStore(
         realtimeClient.optimisticUpdateQueue,
         (queue) => {
           queue.shift();
@@ -261,9 +293,17 @@ function syncContinuity(continuity, socket, store) {
           `thought update #${confirmedUpdate2.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate2.key}:${confirmedUpdate2.id}`
         );
       }
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `updates do not match`,
+        optimisticUpdate,
+        confirmedUpdate2
+      );
       const reversedOptimisticUpdates = optimisticUpdates.toReversed();
       for (const subsequentOptimistic of reversedOptimisticUpdates) {
-        Internal3.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
+        Internal.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
       }
       store.logger.info(
         `\u23EA`,
@@ -272,7 +312,7 @@ function syncContinuity(continuity, socket, store) {
         `undid optimistic updates:`,
         reversedOptimisticUpdates
       );
-      Internal3.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
+      Internal.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
       store.logger.info(
         `\u23EA`,
         `continuity`,
@@ -280,7 +320,7 @@ function syncContinuity(continuity, socket, store) {
         `undid zeroth optimistic update`,
         optimisticUpdate
       );
-      Internal3.ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
+      Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
       store.logger.info(
         `\u23E9`,
         `continuity`,
@@ -295,7 +335,7 @@ function syncContinuity(continuity, socket, store) {
           key: subsequentOptimistic.key
         };
         const { id, params } = subsequentOptimistic;
-        Internal3.actUponStore(token, id, store)(...params);
+        Internal.actUponStore(token, id, store)(...params);
       }
       store.logger.info(
         `\u23E9`,
@@ -306,7 +346,7 @@ function syncContinuity(continuity, socket, store) {
       );
     }
     store.logger.info(
-      `\u2696\uFE0F`,
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
       `continuity`,
       continuityKey,
       `integrating confirmed update`,
@@ -315,14 +355,14 @@ function syncContinuity(continuity, socket, store) {
     const zerothOptimisticUpdate = optimisticUpdates[0];
     if (zerothOptimisticUpdate) {
       store.logger.info(
-        `\u2696\uFE0F`,
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
         `continuity`,
         continuityKey,
         `has optimistic updates to reconcile`
       );
       if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
         store.logger.info(
-          `\u2696\uFE0F`,
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
           `epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`
@@ -338,7 +378,7 @@ function syncContinuity(continuity, socket, store) {
         }
       } else {
         store.logger.info(
-          `\u2696\uFE0F`,
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
           `epoch of confirmed update #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
@@ -354,7 +394,7 @@ function syncContinuity(continuity, socket, store) {
             `pushing confirmed update to queue`,
             confirmedUpdate
           );
-          Internal3.setIntoStore(
+          Internal.setIntoStore(
             realtimeClient.confirmedUpdateQueue,
             (queue) => {
               queue.push(confirmedUpdate);
@@ -367,13 +407,13 @@ function syncContinuity(continuity, socket, store) {
       }
     } else {
       store.logger.info(
-        `\u2696\uFE0F`,
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
         `continuity`,
         continuityKey,
         `has no optimistic updates to deal with`
       );
-      const continuityEpoch = Internal3.getEpochNumberOfContinuity(continuityKey, store);
-      const isRoot = Internal3.isRootStore(store);
+      const continuityEpoch = Internal.getEpochNumberOfContinuity(continuityKey, store);
+      const isRoot = Internal.isRootStore(store);
       if (isRoot && continuityEpoch === confirmedUpdate.epoch - 1) {
         store.logger.info(
           `\u2705`,
@@ -381,12 +421,12 @@ function syncContinuity(continuity, socket, store) {
           continuityKey,
           `integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`
         );
-        Internal3.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
+        Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
         socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-        Internal3.setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store);
+        Internal.setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store);
       } else if (isRoot && continuityEpoch !== void 0) {
         store.logger.info(
-          `\u2696\uFE0F`,
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
           `received update #${confirmedUpdate.epoch} but still waiting for update #${continuityEpoch + 1}`,
@@ -412,7 +452,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `pushing confirmed update #${confirmedUpdate.epoch} to queue`
           );
-          Internal3.setIntoStore(
+          Internal.setIntoStore(
             realtimeClient.confirmedUpdateQueue,
             (queue) => {
               queue.push(confirmedUpdate);
@@ -428,8 +468,8 @@ function syncContinuity(continuity, socket, store) {
   socket.off(`tx-new:${continuityKey}`);
   socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
   const unsubscribeFunctions = continuity.actions.map((transaction) => {
-    Internal3.assignTransactionToContinuity(continuityKey, transaction.key, store);
-    const unsubscribeFromTransactionUpdates = Internal3.subscribeToTransaction(
+    Internal.assignTransactionToContinuity(continuityKey, transaction.key, store);
+    const unsubscribeFromTransactionUpdates = Internal.subscribeToTransaction(
       transaction,
       (clientUpdate) => {
         store.logger.info(
@@ -448,7 +488,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `enqueuing new optimistic update`
           );
-          Internal3.setIntoStore(
+          Internal.setIntoStore(
             realtimeClient.optimisticUpdateQueue,
             (queue) => {
               queue.push(clientUpdate);
@@ -464,7 +504,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `replacing existing optimistic update at index ${optimisticUpdateIndex}`
           );
-          Internal3.setIntoStore(
+          Internal.setIntoStore(
             realtimeClient.optimisticUpdateQueue,
             (queue) => {
               queue[optimisticUpdateIndex] = clientUpdate;
@@ -473,177 +513,52 @@ function syncContinuity(continuity, socket, store) {
             store
           );
         }
-        socket.emit(`tx-run:${continuityKey}`, clientUpdate);
+        socket.emit(`tx-run:${continuityKey}`, {
+          id: clientUpdate.id,
+          key: transaction.key,
+          params: clientUpdate.params
+        });
       },
       `tx-run:${continuityKey}`,
       store
     );
     return unsubscribeFromTransactionUpdates;
   });
-  socket.emit(`get:${continuityKey}`);
-  return () => {
-    socket.off(`continuity-init:${continuityKey}`);
-    socket.off(`tx-new:${continuityKey}`);
-    for (const unsubscribe of unsubscribeFunctions)
-      unsubscribe();
-    socket.emit(`unsub:${continuityKey}`);
-  };
-}
-function syncAction(token, socket, store) {
-  Internal3__namespace.assignTransactionToContinuity(`default`, token.key, store);
-  const optimisticQueue = Internal3__namespace.getFromStore(optimisticUpdateQueue, store);
-  const confirmedQueue = Internal3__namespace.getFromStore(confirmedUpdateQueue, store);
-  const unsubscribeFromLocalUpdates = Internal3__namespace.subscribeToTransaction(
-    token,
-    (clientUpdate) => {
-      const optimisticUpdateQueueIndex = optimisticQueue.findIndex(
-        (update) => update.id === clientUpdate.id
-      );
-      if (optimisticUpdateQueueIndex === -1) {
-        Internal3__namespace.setIntoStore(
-          optimisticUpdateQueue,
-          (queue) => {
-            queue.push(clientUpdate);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          },
-          store
-        );
+  socket.on(`reveal:${continuityKey}`, (revealed) => {
+    let i = 0;
+    let k = ``;
+    let v = null;
+    for (const x of revealed) {
+      if (i % 2 === 0) {
+        k = x;
       } else {
-        Internal3__namespace.setIntoStore(
-          optimisticUpdateQueue,
-          (queue) => {
-            queue[optimisticUpdateQueueIndex] = clientUpdate;
-            return queue;
-          },
-          store
-        );
-      }
-      socket.emit(`tx-run:${token.key}`, clientUpdate);
-    },
-    `tx-run:${token.key}`,
-    store
-  );
-  const reconcileUpdates = (optimisticUpdate, confirmedUpdate) => {
-    Internal3__namespace.setIntoStore(
-      optimisticUpdateQueue,
-      (queue) => {
-        queue.shift();
-        return queue;
-      },
-      store
-    );
-    if (optimisticUpdate.id === confirmedUpdate.id) {
-      const clientResult = JSON.stringify(optimisticUpdate.updates);
-      const serverResult = JSON.stringify(confirmedUpdate.updates);
-      if (clientResult === serverResult) {
-        store.logger.info(
-          `\u2705`,
-          `transaction`,
-          token.key,
-          `results for ${optimisticUpdate.id} match between client and server`
-        );
-        socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-        return;
+        v = x;
+        Internal.setIntoStore(k, v, store);
       }
-    } else {
-      store.logger.info(
-        `\u274C`,
-        `transaction`,
-        token.key,
-        `${store.config.name} thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
-      );
-    }
-    for (const subsequentOptimistic of optimisticQueue.toReversed()) {
-      Internal3__namespace.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
-    }
-    Internal3__namespace.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
-    Internal3__namespace.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-    socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-    for (const subsequentOptimistic of optimisticQueue) {
-      const token2 = Object.assign(
-        { type: `transaction` },
-        subsequentOptimistic
-      );
-      const { id, params } = subsequentOptimistic;
-      Internal3__namespace.actUponStore(token2, id, store)(...params);
+      i++;
     }
-  };
-  const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
-    const zerothOptimisticUpdate = optimisticQueue[0];
-    if (zerothOptimisticUpdate) {
-      if (zerothOptimisticUpdate.epoch === confirmedUpdate.epoch) {
-        reconcileUpdates(zerothOptimisticUpdate, confirmedUpdate);
-        for (const nextConfirmed of confirmedQueue) {
-          const nextOptimistic = optimisticQueue[0];
-          if (nextConfirmed.epoch === nextOptimistic.epoch) {
-            reconcileUpdates(nextOptimistic, nextConfirmed);
-          } else {
-            break;
-          }
-        }
-      } else {
-        const hasEnqueuedOptimisticUpdate = optimisticQueue.some(
-          (update) => update.epoch === confirmedUpdate.epoch
-        );
-        if (hasEnqueuedOptimisticUpdate) {
-          Internal3__namespace.setIntoStore(
-            confirmedUpdateQueue,
-            (queue) => {
-              queue.push(confirmedUpdate);
-              queue.sort((a, b) => a.epoch - b.epoch);
-              return queue;
-            },
-            store
-          );
-        }
-      }
-    } else {
-      const continuityEpoch = Internal3__namespace.getEpochNumberOfAction(token.key, store);
-      if (Internal3__namespace.isRootStore(store) && continuityEpoch === confirmedUpdate.epoch - 1) {
-        Internal3__namespace.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-        socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-        Internal3__namespace.setEpochNumberOfAction(token.key, confirmedUpdate.epoch, store);
-      } else if (Internal3__namespace.isRootStore(store)) {
-        store.logger.info(
-          `\u274C`,
-          `transaction`,
-          token.key,
-          `received out-of-order update from server`,
-          {
-            clientEpoch: store.transactionMeta.epoch,
-            serverEpoch: confirmedUpdate.epoch
-          }
-        );
+  });
+  socket.on(
+    `conceal:${continuityKey}`,
+    (concealed) => {
+      for (const token of concealed) {
+        Internal.deleteAtom(token, store);
       }
     }
-  };
-  socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate);
-  socket.on(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate);
-  socket.emit(`tx-sub:${token.key}`);
-  const unsubscribeFromIncomingUpdates = () => {
-    socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate);
-    socket.emit(`tx-unsub:${token.key}`);
-  };
-  return () => {
-    unsubscribeFromLocalUpdates();
-    unsubscribeFromIncomingUpdates();
-  };
-}
-function syncState(token, socket, store) {
-  const setServedValue = (data) => {
-    Internal3.setIntoStore(token, data, store);
-  };
-  socket.on(`value:${token.key}`, setServedValue);
-  socket.emit(`get:${token.key}`);
+  );
+  socket.emit(`get:${continuityKey}`);
   return () => {
-    socket.off(`value:${token.key}`, setServedValue);
+    socket.off(`continuity-init:${continuityKey}`);
+    socket.off(`tx-new:${continuityKey}`);
+    for (const unsubscribe of unsubscribeFunctions)
+      unsubscribe();
   };
 }
 
 exports.confirmedUpdateQueue = confirmedUpdateQueue;
 exports.myIdState = myIdState;
 exports.myIdState__INTERNAL = myIdState__INTERNAL;
+exports.myUsernameState = myUsernameState;
 exports.optimisticUpdateQueue = optimisticUpdateQueue;
 exports.pullAtom = pullAtom;
 exports.pullAtomFamilyMember = pullAtomFamilyMember;
@@ -653,8 +568,6 @@ exports.pullSelector = pullSelector;
 exports.pullSelectorFamilyMember = pullSelectorFamilyMember;
 exports.pushState = pushState;
 exports.serverAction = serverAction;
-exports.syncAction = syncAction;
 exports.syncContinuity = syncContinuity;
-exports.syncState = syncState;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map