atom.io 0.31.1 → 0.32.1

package/dist/chunk-3PQTWLQQ.js

@@ -0,0 +1,83 @@
+import { IMPLICIT, setIntoStore, subscribeToState, getFromStore, findInStore, getJsonToken, withdraw, subscribeToTimeline, redo, undo } from './chunk-UQEYZ3OI.js';
+import * as React5 from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var StoreContext = React5.createContext(IMPLICIT.STORE);
+var StoreProvider = ({ children, store = IMPLICIT.STORE }) => /* @__PURE__ */ jsx(StoreContext.Provider, { value: store, children });
+
+// react/src/parse-state-overloads.ts
+function parseStateOverloads(store, ...rest) {
+  let token;
+  if (rest.length === 2) {
+    const family = rest[0];
+    const key = rest[1];
+    token = findInStore(store, family, key);
+  } else {
+    token = rest[0];
+  }
+  return token;
+}
+
+// react/src/use-i.ts
+function useI(...params) {
+  const store = React5.useContext(StoreContext);
+  const token = parseStateOverloads(store, ...params);
+  const setter = React5.useRef(null);
+  if (setter.current === null) {
+    setter.current = (next) => {
+      setIntoStore(store, token, next);
+    };
+  }
+  return setter.current;
+}
+function useO(...params) {
+  const store = React5.useContext(StoreContext);
+  const token = parseStateOverloads(store, ...params);
+  const id = React5.useId();
+  return React5.useSyncExternalStore(
+    (dispatch) => subscribeToState(store, token, `use-o:${id}`, dispatch),
+    () => getFromStore(store, token),
+    () => getFromStore(store, token)
+  );
+}
+
+// react/src/use-json.ts
+function useJSON(token, key) {
+  const store = React5.useContext(StoreContext);
+  const stateToken = token.type === `mutable_atom_family` ? findInStore(store, token, key) : token;
+  const jsonToken = getJsonToken(store, stateToken);
+  return useO(jsonToken);
+}
+function useTL(token) {
+  const store = React5.useContext(StoreContext);
+  const id = React5.useId();
+  const timeline = withdraw(store, token);
+  const tokenRef = React5.useRef(token);
+  const rebuildMeta = () => {
+    return {
+      at: timeline.at,
+      length: timeline.history.length,
+      undo: () => {
+        undo(token);
+      },
+      redo: () => {
+        redo(token);
+      }
+    };
+  };
+  const meta = React5.useRef(rebuildMeta());
+  const retrieve = () => {
+    if (meta.current.at !== timeline?.at || meta.current.length !== timeline?.history.length || tokenRef.current !== token) {
+      tokenRef.current = token;
+      meta.current = rebuildMeta();
+    }
+    return meta.current;
+  };
+  return React5.useSyncExternalStore(
+    (dispatch) => subscribeToTimeline(store, token, `use-tl:${id}`, dispatch),
+    retrieve,
+    retrieve
+  );
+}
+
+export { StoreContext, StoreProvider, useI, useJSON, useO, useTL };

package/dist/chunk-3ZFTRSNG.js

@@ -0,0 +1,523 @@
+import { persistSync } from './chunk-4LWKCEW3.js';
+import { atom, selector, setIntoStore, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, setEpochNumberOfContinuity, disposeAtom, parseJson, getJsonToken, getUpdateToken, subscribeToState, subscribeToTransaction, getFromStore, assignTransactionToContinuity, actUponStore } from './chunk-UQEYZ3OI.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 continuityEpoch = getEpochNumberOfContinuity(store, continuityKey);
+    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(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 };

package/dist/chunk-4LWKCEW3.js

@@ -0,0 +1,14 @@
+// web/src/persist-sync.ts
+var persistSync = (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));
+  });
+};
+
+export { persistSync };