atom.io 0.32.4 → 0.33.1

package/dist/chunk-IR77IXS7.js

@@ -1,526 +0,0 @@
-import { persistSync } from './chunk-4LWKCEW3.js';
-import { atom, selector, setIntoStore, isRootStore, getEpochNumberOfContinuity, ingestTransactionUpdate, setEpochNumberOfContinuity, disposeAtom, parseJson, getJsonToken, getUpdateToken, subscribeToState, subscribeToTransaction, getFromStore, assignTransactionToContinuity, actUponStore } from './chunk-7SJVR7FZ.js';
-
-// realtime-client/src/continuity/register-and-attempt-confirmed-update.ts
-var useRegisterAndAttemptConfirmedUpdate = (store, continuityKey, socket, optimisticUpdates, confirmedUpdates) => (confirmed) => {
-  function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `reconciling updates`
-    );
-    setIntoStore(store, optimisticUpdateQueue, (queue) => {
-      queue.shift();
-      return queue;
-    });
-    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(store, token, id)(...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?.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(store, confirmedUpdateQueue, (queue) => {
-          queue.push(confirmed);
-          queue.sort((a, b) => a.epoch - b.epoch);
-          return queue;
-        });
-      }
-    }
-  } else {
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `has no optimistic updates to deal with`
-    );
-    const isRoot = isRootStore(store);
-    let continuityEpoch;
-    if (isRoot) {
-      continuityEpoch = getEpochNumberOfContinuity(store, continuityKey);
-    }
-    if (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(store, continuityKey, confirmed.epoch);
-    } 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(store, confirmedUpdateQueue, (queue) => {
-          queue.push(confirmed);
-          queue.sort((a, b) => a.epoch - b.epoch);
-          return queue;
-        });
-      }
-    }
-  }
-};
-
-// realtime-client/src/continuity/use-conceal-state.ts
-function useConcealState(store) {
-  return (concealed) => {
-    for (const token of concealed) {
-      disposeAtom(store, token);
-    }
-  };
-}
-
-// realtime-client/src/continuity/use-reveal-state.ts
-function useRevealState(store) {
-  return (revealed) => {
-    let i = 0;
-    let k;
-    let v;
-    for (const x of revealed) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        setIntoStore(store, k, v);
-      }
-      i++;
-    }
-  };
-}
-
-// realtime-client/src/pull-atom.ts
-function pullAtom(store, socket, token) {
-  const setServedValue = (data) => {
-    setIntoStore(store, token, data);
-  };
-  socket.on(`serve:${token.key}`, setServedValue);
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`serve:${token.key}`, setServedValue);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-
-// realtime-client/src/pull-atom-family-member.ts
-function pullAtomFamilyMember(store, socket, token) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = parseJson(serializedSubKey);
-  socket?.on(`serve:${token.key}`, (data) => {
-    setIntoStore(store, token, data);
-  });
-  socket?.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket?.off(`serve:${token.key}`);
-    socket?.emit(`unsub:${token.key}`);
-  };
-}
-
-// realtime-client/src/pull-mutable-atom.ts
-function pullMutableAtom(store, socket, token) {
-  const jsonToken = getJsonToken(store, token);
-  const updateToken = getUpdateToken(token);
-  socket.on(`init:${token.key}`, (data) => {
-    setIntoStore(store, jsonToken, data);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      setIntoStore(store, updateToken, data);
-    }
-  );
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`init:${token.key}`);
-    socket.off(`next:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-
-// realtime-client/src/pull-mutable-atom-family-member.ts
-function pullMutableAtomFamilyMember(store, socket, token) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = parseJson(serializedSubKey);
-  socket.on(`init:${token.key}`, (data) => {
-    const jsonToken = getJsonToken(store, token);
-    setIntoStore(store, jsonToken, data);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      const trackerToken = getUpdateToken(token);
-      setIntoStore(store, trackerToken, data);
-    }
-  );
-  socket.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket.off(`serve:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-
-// realtime-client/src/pull-selector.ts
-function pullSelector(store, socket, token) {
-  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
-  const unsubscribes = [];
-  if (atomKeys) {
-    for (const atomKey of atomKeys) {
-      const atom2 = store.atoms.get(atomKey);
-      if (!atom2) {
-        continue;
-      }
-      switch (atom2.type) {
-        case `atom`: {
-          unsubscribes.push(pullAtom(store, socket, atom2));
-          break;
-        }
-        case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtom(store, socket, atom2));
-          break;
-        }
-      }
-    }
-  }
-  return () => {
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
-  };
-}
-
-// realtime-client/src/pull-selector-family-member.ts
-function pullSelectorFamilyMember(store, socket, token) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
-  const unsubscribes = [];
-  if (atomKeys) {
-    for (const atomKey of atomKeys) {
-      const atom2 = store.atoms.get(atomKey);
-      if (!atom2) {
-        continue;
-      }
-      switch (atom2.type) {
-        case `atom`: {
-          unsubscribes.push(pullAtomFamilyMember(store, socket, atom2));
-          break;
-        }
-        case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtomFamilyMember(store, socket, atom2));
-          break;
-        }
-      }
-    }
-  }
-  return () => {
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
-  };
-}
-
-// realtime-client/src/push-state.ts
-function pushState(store, socket, token) {
-  socket.emit(`claim:${token.key}`);
-  subscribeToState(store, token, `push`, ({ newValue }) => {
-    socket.emit(`pub:${token.key}`, newValue);
-  });
-  return () => {
-    socket.off(`pub:${token.key}`);
-    socket.emit(`unclaim:${token.key}`);
-  };
-}
-
-// realtime-client/src/realtime-client-stores/client-main-store.ts
-var myIdState__INTERNAL = atom({
-  key: `mySocketId__INTERNAL`,
-  default: void 0
-});
-var myIdState = selector({
-  key: `mySocketId`,
-  get: ({ get }) => get(myIdState__INTERNAL)
-});
-var myUsernameState = atom({
-  key: `myName`,
-  default: null,
-  effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `myUsername`)]
-});
-
-// realtime-client/src/realtime-client-stores/client-sync-store.ts
-var optimisticUpdateQueue = atom({
-  key: `updateQueue`,
-  default: []
-});
-var confirmedUpdateQueue = atom(
-  {
-    key: `serverConfirmedUpdateQueue`,
-    default: []
-  }
-);
-
-// realtime-client/src/server-action.ts
-function serverAction(store, socket, token) {
-  const unsubscribeFromLocalUpdates = subscribeToTransaction(
-    store,
-    token,
-    `tx-run:${token.key}:${socket.id}`,
-    (clientUpdate) => {
-      socket.emit(`tx-run:${token.key}`, clientUpdate);
-    }
-  );
-  return () => {
-    unsubscribeFromLocalUpdates();
-  };
-}
-
-// realtime-client/src/sync-continuity.ts
-function syncContinuity(store, socket, continuity) {
-  const continuityKey = continuity.key;
-  const optimisticUpdates = getFromStore(store, optimisticUpdateQueue);
-  const confirmedUpdates = getFromStore(store, confirmedUpdateQueue);
-  const initializeContinuity = (epoch, payload) => {
-    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
-    let i = 0;
-    let k;
-    let v;
-    for (const x of payload) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        if (`type` in k && k.type === `mutable_atom`) {
-          k = getJsonToken(store, k);
-        }
-        setIntoStore(store, k, v);
-      }
-      i++;
-    }
-    setEpochNumberOfContinuity(store, continuityKey, epoch);
-  };
-  socket.off(`continuity-init:${continuityKey}`);
-  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  const registerAndAttemptConfirmedUpdate = useRegisterAndAttemptConfirmedUpdate(
-    store,
-    continuityKey,
-    socket,
-    optimisticUpdates,
-    confirmedUpdates
-  );
-  socket.off(`tx-new:${continuityKey}`);
-  socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
-  const unsubscribeFunctions = continuity.actions.map((transaction) => {
-    assignTransactionToContinuity(store, continuityKey, transaction.key);
-    const unsubscribeFromTransactionUpdates = subscribeToTransaction(
-      store,
-      transaction,
-      `tx-run:${continuityKey}`,
-      (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(store, optimisticUpdateQueue, (queue) => {
-            queue.push(clientUpdate);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          });
-        } else {
-          store.logger.info(
-            `\u{1F91E}`,
-            `continuity`,
-            continuityKey,
-            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
-          );
-          setIntoStore(store, optimisticUpdateQueue, (queue) => {
-            queue[optimisticUpdateIndex] = clientUpdate;
-            return queue;
-          });
-        }
-        socket.emit(`tx-run:${continuityKey}`, {
-          id: clientUpdate.id,
-          key: transaction.key,
-          params: clientUpdate.params
-        });
-      }
-    );
-    return unsubscribeFromTransactionUpdates;
-  });
-  const revealState = useRevealState(store);
-  const concealState = useConcealState(store);
-  socket.on(`reveal:${continuityKey}`, revealState);
-  socket.on(`conceal:${continuityKey}`, concealState);
-  socket.emit(`get:${continuityKey}`);
-  return () => {
-    socket.off(`continuity-init:${continuityKey}`);
-    socket.off(`tx-new:${continuityKey}`);
-    for (const unsubscribe of unsubscribeFunctions) unsubscribe();
-  };
-}
-
-export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState };