atom.io 0.23.4 → 0.24.0

package/realtime-client/dist/index.js

@@ -1,10 +1,10 @@
-export { syncContinuity } from '../../dist/chunk-GVHKIJ3G.js';
-export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue } from '../../dist/chunk-O47EQUM6.js';
-import '../../dist/chunk-BWWVY5O5.js';
+import { lazyLocalStorageEffect } from '../../dist/chunk-BWWVY5O5.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
-import { setIntoStore, getJsonToken, getUpdateToken } from 'atom.io/internal';
+import { setIntoStore, getJsonToken, getUpdateToken, getFromStore, assignTransactionToContinuity, subscribeToTransaction, disposeAtom, setEpochNumberOfContinuity, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, actUponStore } from 'atom.io/internal';
 import { parseJson } from 'atom.io/json';
+import * as AtomIO from 'atom.io';
+import { optimisticUpdateQueue as optimisticUpdateQueue$1, confirmedUpdateQueue as confirmedUpdateQueue$1 } from 'atom.io/realtime-client';
 
 function pullAtom(token, socket, store) {
   const setServedValue = (data) => {
@@ -85,17 +85,17 @@ function pullSelector(token, socket, store) {
   const unsubscribes = [];
   if (atomKeys) {
     for (const atomKey of atomKeys) {
-      const atom = store.atoms.get(atomKey);
-      if (!atom) {
+      const atom3 = store.atoms.get(atomKey);
+      if (!atom3) {
         continue;
       }
-      switch (atom.type) {
+      switch (atom3.type) {
         case `atom`: {
-          unsubscribes.push(pullAtom(atom, socket, store));
+          unsubscribes.push(pullAtom(atom3, socket, store));
           break;
         }
         case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtom(atom, socket, store));
+          unsubscribes.push(pullMutableAtom(atom3, socket, store));
           break;
         }
       }
@@ -119,17 +119,17 @@ function pullSelectorFamilyMember(token, socket, store) {
   const unsubscribes = [];
   if (atomKeys) {
     for (const atomKey of atomKeys) {
-      const atom = store.atoms.get(atomKey);
-      if (!atom) {
+      const atom3 = store.atoms.get(atomKey);
+      if (!atom3) {
         continue;
       }
-      switch (atom.type) {
+      switch (atom3.type) {
         case `atom`: {
-          unsubscribes.push(pullAtomFamilyMember(atom, socket, store));
+          unsubscribes.push(pullAtomFamilyMember(atom3, socket, store));
           break;
         }
         case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtomFamilyMember(atom, socket, store));
+          unsubscribes.push(pullMutableAtomFamilyMember(atom3, socket, store));
           break;
         }
       }
@@ -156,6 +156,30 @@ function pushState(token, socket, store) {
     socket.emit(`unclaim:${token.key}`);
   };
 }
+var myIdState__INTERNAL = AtomIO.atom({
+  key: `mySocketId__INTERNAL`,
+  default: void 0
+});
+var myIdState = AtomIO.selector({
+  key: `mySocketId`,
+  get: ({ get }) => get(myIdState__INTERNAL)
+});
+var usernameEffects = typeof window === `undefined` ? [] : [lazyLocalStorageEffect(`myUsername`)];
+var myUsernameState = AtomIO.atom({
+  key: `myUsername`,
+  default: null,
+  effects: usernameEffects
+});
+var optimisticUpdateQueue = AtomIO.atom({
+  key: `updateQueue`,
+  default: []
+});
+var confirmedUpdateQueue = AtomIO.atom(
+  {
+    key: `serverConfirmedUpdateQueue`,
+    default: []
+  }
+);
 function serverAction(token, socket, store) {
   const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
     token,
@@ -169,5 +193,328 @@ function serverAction(token, socket, store) {
     unsubscribeFromLocalUpdates();
   };
 }
+function syncContinuity(continuity, socket, store) {
+  const continuityKey = continuity.key;
+  const optimisticUpdates = getFromStore(optimisticUpdateQueue$1, store);
+  const confirmedUpdates = getFromStore(confirmedUpdateQueue$1, store);
+  const initializeContinuity = (epoch, payload) => {
+    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
+    let i = 0;
+    let k = ``;
+    let v = null;
+    for (const x of payload) {
+      if (i % 2 === 0) {
+        k = x;
+      } else {
+        v = x;
+        if (`type` in k && k.type === `mutable_atom`) {
+          k = getJsonToken(k, store);
+        }
+        setIntoStore(k, v, store);
+      }
+      i++;
+    }
+    setEpochNumberOfContinuity(continuityKey, epoch, store);
+  };
+  socket.off(`continuity-init:${continuityKey}`);
+  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
+  const registerAndAttemptConfirmedUpdate = (confirmed) => {
+    function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `reconciling updates`
+      );
+      setIntoStore(
+        optimisticUpdateQueue$1,
+        (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`,
+            `continuity`,
+            continuityKey,
+            `results for ${optimisticUpdate.id} match between client and server`
+          );
+          socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
+          return;
+        }
+      } else {
+        store.logger.info(
+          `\u274C`,
+          `continuity`,
+          continuityKey,
+          `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
+        );
+      }
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `updates do not match`,
+        optimisticUpdate,
+        confirmedUpdate
+      );
+      const reversedOptimisticUpdates = optimisticUpdates.toReversed();
+      for (const subsequentOptimistic of reversedOptimisticUpdates) {
+        ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
+      }
+      store.logger.info(
+        `\u23EA`,
+        `continuity`,
+        continuityKey,
+        `undid optimistic updates:`,
+        reversedOptimisticUpdates
+      );
+      ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
+      store.logger.info(
+        `\u23EA`,
+        `continuity`,
+        continuityKey,
+        `undid zeroth optimistic update`,
+        optimisticUpdate
+      );
+      ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
+      store.logger.info(
+        `\u23E9`,
+        `continuity`,
+        continuityKey,
+        `applied confirmed update`,
+        confirmedUpdate
+      );
+      socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
+      for (const subsequentOptimistic of optimisticUpdates) {
+        const token = {
+          type: `transaction`,
+          key: subsequentOptimistic.key
+        };
+        const { id, params } = subsequentOptimistic;
+        actUponStore(token, id, store)(...params);
+      }
+      store.logger.info(
+        `\u23E9`,
+        `continuity`,
+        continuityKey,
+        `reapplied subsequent optimistic updates:`,
+        optimisticUpdates
+      );
+    }
+    store.logger.info(
+      `\u{1F9D1}\u200D\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `integrating confirmed update`,
+      { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
+    );
+    const zerothOptimisticUpdate = optimisticUpdates[0];
+    if (zerothOptimisticUpdate) {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `has optimistic updates to reconcile`
+      );
+      if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
+        store.logger.info(
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
+        );
+        reconcileEpoch(zerothOptimisticUpdate, confirmed);
+        for (const nextConfirmed of confirmedUpdates) {
+          const nextOptimistic = optimisticUpdates[0];
+          if (nextConfirmed.epoch === (nextOptimistic == null ? void 0 : nextOptimistic.epoch)) {
+            reconcileEpoch(nextOptimistic, nextConfirmed);
+          } else {
+            break;
+          }
+        }
+      } else {
+        store.logger.info(
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
+        );
+        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+          (update) => update.epoch === confirmed.epoch
+        );
+        if (!confirmedUpdateIsAlreadyEnqueued) {
+          store.logger.info(
+            `\u{1F448}`,
+            `continuity`,
+            continuityKey,
+            `pushing confirmed update to queue`,
+            confirmed
+          );
+          setIntoStore(
+            confirmedUpdateQueue$1,
+            (queue) => {
+              queue.push(confirmed);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        }
+      }
+    } else {
+      store.logger.info(
+        `\u{1F9D1}\u200D\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `has no optimistic updates to deal with`
+      );
+      const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store);
+      const isRoot = isRootStore(store);
+      if (isRoot && continuityEpoch === confirmed.epoch - 1) {
+        store.logger.info(
+          `\u2705`,
+          `continuity`,
+          continuityKey,
+          `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
+        );
+        ingestTransactionUpdate(`newValue`, confirmed, store);
+        socket.emit(`ack:${continuityKey}`, confirmed.epoch);
+        setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
+      } else if (isRoot && continuityEpoch !== void 0) {
+        store.logger.info(
+          `\u{1F9D1}\u200D\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
+          {
+            clientEpoch: continuityEpoch,
+            serverEpoch: confirmed.epoch
+          }
+        );
+        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+          (update) => update.epoch === confirmed.epoch
+        );
+        if (confirmedUpdateIsAlreadyEnqueued) {
+          store.logger.info(
+            `\u{1F44D}`,
+            `continuity`,
+            continuityKey,
+            `confirmed update #${confirmed.epoch} is already enqueued`
+          );
+        } else {
+          store.logger.info(
+            `\u{1F448}`,
+            `continuity`,
+            continuityKey,
+            `pushing confirmed update #${confirmed.epoch} to queue`
+          );
+          setIntoStore(
+            confirmedUpdateQueue$1,
+            (queue) => {
+              queue.push(confirmed);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        }
+      }
+    }
+  };
+  socket.off(`tx-new:${continuityKey}`);
+  socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
+  const unsubscribeFunctions = continuity.actions.map((transaction) => {
+    assignTransactionToContinuity(continuityKey, transaction.key, store);
+    const unsubscribeFromTransactionUpdates = subscribeToTransaction(
+      transaction,
+      (clientUpdate) => {
+        store.logger.info(
+          `\u{1F91E}`,
+          `continuity`,
+          continuityKey,
+          `enqueuing optimistic update`
+        );
+        const optimisticUpdateIndex = optimisticUpdates.findIndex(
+          (update) => update.id === clientUpdate.id
+        );
+        if (optimisticUpdateIndex === -1) {
+          store.logger.info(
+            `\u{1F91E}`,
+            `continuity`,
+            continuityKey,
+            `enqueuing new optimistic update`
+          );
+          setIntoStore(
+            optimisticUpdateQueue$1,
+            (queue) => {
+              queue.push(clientUpdate);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        } else {
+          store.logger.info(
+            `\u{1F91E}`,
+            `continuity`,
+            continuityKey,
+            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
+          );
+          setIntoStore(
+            optimisticUpdateQueue$1,
+            (queue) => {
+              queue[optimisticUpdateIndex] = clientUpdate;
+              return queue;
+            },
+            store
+          );
+        }
+        socket.emit(`tx-run:${continuityKey}`, {
+          id: clientUpdate.id,
+          key: transaction.key,
+          params: clientUpdate.params
+        });
+      },
+      `tx-run:${continuityKey}`,
+      store
+    );
+    return unsubscribeFromTransactionUpdates;
+  });
+  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 {
+        v = x;
+        setIntoStore(k, v, store);
+      }
+      i++;
+    }
+  });
+  socket.on(
+    `conceal:${continuityKey}`,
+    (concealed) => {
+      for (const token of concealed) {
+        disposeAtom(token, store);
+      }
+    }
+  );
+  socket.emit(`get:${continuityKey}`);
+  return () => {
+    socket.off(`continuity-init:${continuityKey}`);
+    socket.off(`tx-new:${continuityKey}`);
+    for (const unsubscribe of unsubscribeFunctions)
+      unsubscribe();
+  };
+}
 
-export { pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction };
+export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity };