atom.io 0.25.6 → 0.26.0

package/realtime/dist/index.cjs

@@ -1,120 +0,0 @@
-'use strict';
-
-var internal = require('atom.io/internal');
-var atom_io = require('atom.io');
-var data = require('atom.io/data');
-var setRtx = require('atom.io/transceivers/set-rtx');
-
-// realtime/src/realtime-continuity.ts
-var InvariantMap = class extends Map {
-  set(key, value) {
-    if (this.has(key)) {
-      console.warn(`Tried to set a key that already exists in an InvariantMap`, {
-        key,
-        value
-      });
-      return this;
-    }
-    return super.set(key, value);
-  }
-  clear() {
-    throw new Error(`Cannot clear an InvariantMap`);
-  }
-};
-var _SyncGroup = class _SyncGroup {
-  constructor(key) {
-    this.key = key;
-    this.type = `continuity`;
-    this.globals = [];
-    this.actions = [];
-    this.perspectives = [];
-  }
-  static create(key, builder) {
-    const group = new _SyncGroup(key);
-    const { type, globals, actions, perspectives } = builder(group);
-    const token = { type, key, globals, actions, perspectives };
-    _SyncGroup.existing.set(key, token);
-    return token;
-  }
-  add(...args) {
-    const zeroth = args[0];
-    if (zeroth.type === `atom` || zeroth.type === `mutable_atom`) {
-      const globals = args;
-      for (const global of globals) {
-        switch (global.type) {
-          case `atom`:
-            this.globals.push(global);
-            break;
-          case `mutable_atom`:
-            this.globals.push(internal.getUpdateToken(global));
-            break;
-        }
-      }
-    } else if (zeroth.type === `transaction`) {
-      const actions = args;
-      this.actions.push(...actions);
-    } else {
-      const [family, index] = args;
-      this.perspectives.push({
-        type: `realtime_perspective`,
-        resourceAtoms: family,
-        viewAtoms: index
-      });
-    }
-    return this;
-  }
-};
-_SyncGroup.existing = new InvariantMap();
-var SyncGroup = _SyncGroup;
-function continuity(options) {
-  const { key, config } = options;
-  const token = SyncGroup.create(key, config);
-  const { actions } = token;
-  for (const action of actions) {
-    internal.assignTransactionToContinuity(key, action.key, internal.IMPLICIT.STORE);
-  }
-  internal.setEpochNumberOfContinuity(key, -1, internal.IMPLICIT.STORE);
-  return token;
-}
-var usersInThisRoomIndex = atom_io.atom({
-  key: `usersInRoomIndex`,
-  mutable: true,
-  default: () => new setRtx.SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
-});
-var roomIndex = atom_io.atom({
-  key: `roomIndex`,
-  default: () => new setRtx.SetRTX(),
-  mutable: true,
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => setRtx.SetRTX.fromJSON(json)
-});
-var DEFAULT_USER_IN_ROOM_META = {
-  enteredAtEpoch: 0
-};
-var usersInRooms = data.join(
-  {
-    key: `usersInRooms`,
-    between: [`room`, `user`],
-    cardinality: `1:n`
-  },
-  DEFAULT_USER_IN_ROOM_META
-);
-var usersInMyRoomView = atom_io.selectorFamily({
-  key: `usersInMyRoomView`,
-  get: (myUsername) => ({ find }) => {
-    const usersInRoomsAtoms = data.getInternalRelations(usersInRooms);
-    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
-    return [myRoomIndex];
-  }
-});
-
-exports.DEFAULT_USER_IN_ROOM_META = DEFAULT_USER_IN_ROOM_META;
-exports.InvariantMap = InvariantMap;
-exports.SyncGroup = SyncGroup;
-exports.continuity = continuity;
-exports.roomIndex = roomIndex;
-exports.usersInMyRoomView = usersInMyRoomView;
-exports.usersInRooms = usersInRooms;
-exports.usersInThisRoomIndex = usersInThisRoomIndex;

package/realtime-client/dist/index.cjs

@@ -1,569 +0,0 @@
-'use strict';
-
-var Internal = require('atom.io/internal');
-var json = require('atom.io/json');
-var AtomIO = require('atom.io');
-var realtimeClient = require('atom.io/realtime-client');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-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) => {
-    Internal.setIntoStore(token, data, store);
-  };
-  socket.on(`serve:${token.key}`, setServedValue);
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`serve:${token.key}`, setServedValue);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullAtomFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = json.parseJson(serializedSubKey);
-  socket == null ? void 0 : socket.on(`serve:${token.key}`, (data) => {
-    Internal.setIntoStore(token, data, store);
-  });
-  socket == null ? void 0 : socket.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket == null ? void 0 : socket.off(`serve:${token.key}`);
-    socket == null ? void 0 : socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullMutableAtom(token, socket, store) {
-  const jsonToken = Internal.getJsonToken(token, store);
-  const updateToken = Internal.getUpdateToken(token);
-  socket.on(`init:${token.key}`, (data) => {
-    Internal.setIntoStore(jsonToken, data, store);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      Internal.setIntoStore(updateToken, data, store);
-    }
-  );
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`init:${token.key}`);
-    socket.off(`next:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullMutableAtomFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = json.parseJson(serializedSubKey);
-  socket.on(`init:${token.key}`, (data) => {
-    const jsonToken = Internal.getJsonToken(token, store);
-    Internal.setIntoStore(jsonToken, data, store);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      const trackerToken = Internal.getUpdateToken(token);
-      Internal.setIntoStore(trackerToken, data, store);
-    }
-  );
-  socket.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket.off(`serve:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-
-// realtime-client/src/pull-selector.ts
-function pullSelector(token, socket, store) {
-  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
-  const unsubscribes = [];
-  if (atomKeys) {
-    for (const atomKey of atomKeys) {
-      const atom3 = store.atoms.get(atomKey);
-      if (!atom3) {
-        continue;
-      }
-      switch (atom3.type) {
-        case `atom`: {
-          unsubscribes.push(pullAtom(atom3, socket, store));
-          break;
-        }
-        case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtom(atom3, socket, store));
-          break;
-        }
-      }
-    }
-  }
-  return () => {
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
-  };
-}
-
-// realtime-client/src/pull-selector-family-member.ts
-function pullSelectorFamilyMember(token, socket, store) {
-  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 atom3 = store.atoms.get(atomKey);
-      if (!atom3) {
-        continue;
-      }
-      switch (atom3.type) {
-        case `atom`: {
-          unsubscribes.push(pullAtomFamilyMember(atom3, socket, store));
-          break;
-        }
-        case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtomFamilyMember(atom3, socket, store));
-          break;
-        }
-      }
-    }
-  }
-  return () => {
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
-  };
-}
-function pushState(token, socket, store) {
-  socket.emit(`claim:${token.key}`);
-  Internal__namespace.subscribeToState(
-    token,
-    ({ newValue }) => {
-      socket.emit(`pub:${token.key}`, newValue);
-    },
-    `push`,
-    store
-  );
-  return () => {
-    socket.off(`pub:${token.key}`);
-    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(window.localStorage)(JSON);
-
-// realtime-client/src/realtime-client-stores/client-main-store.ts
-var myIdState__INTERNAL = AtomIO__namespace.atom({
-  key: `mySocketId__INTERNAL`,
-  default: void 0
-});
-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: []
-});
-var confirmedUpdateQueue = AtomIO__namespace.atom(
-  {
-    key: `serverConfirmedUpdateQueue`,
-    default: []
-  }
-);
-function serverAction(token, socket, store) {
-  const unsubscribeFromLocalUpdates = Internal__namespace.subscribeToTransaction(
-    token,
-    (clientUpdate) => {
-      socket.emit(`tx-run:${token.key}`, clientUpdate);
-    },
-    `tx-run:${token.key}:${socket.id}`,
-    store
-  );
-  return () => {
-    unsubscribeFromLocalUpdates();
-  };
-}
-function syncContinuity(continuity, socket, store) {
-  const continuityKey = continuity.key;
-  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;
-    for (const x of payload) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        if (`type` in k && k.type === `mutable_atom`) {
-          k = Internal.getJsonToken(k, store);
-        }
-        Internal.setIntoStore(k, v, store);
-      }
-      i++;
-    }
-    Internal.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`
-      );
-      Internal.setIntoStore(
-        realtimeClient.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`,
-            `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) {
-        Internal.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
-      }
-      store.logger.info(
-        `\u23EA`,
-        `continuity`,
-        continuityKey,
-        `undid optimistic updates:`,
-        reversedOptimisticUpdates
-      );
-      Internal.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
-      store.logger.info(
-        `\u23EA`,
-        `continuity`,
-        continuityKey,
-        `undid zeroth optimistic update`,
-        optimisticUpdate
-      );
-      Internal.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;
-        Internal.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
-          );
-          Internal.setIntoStore(
-            realtimeClient.confirmedUpdateQueue,
-            (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 = Internal.getEpochNumberOfContinuity(continuityKey, store);
-      const isRoot = Internal.isRootStore(store);
-      if (isRoot && continuityEpoch === confirmed.epoch - 1) {
-        store.logger.info(
-          `\u2705`,
-          `continuity`,
-          continuityKey,
-          `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
-        );
-        Internal.ingestTransactionUpdate(`newValue`, confirmed, store);
-        socket.emit(`ack:${continuityKey}`, confirmed.epoch);
-        Internal.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`
-          );
-          Internal.setIntoStore(
-            realtimeClient.confirmedUpdateQueue,
-            (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) => {
-    Internal.assignTransactionToContinuity(continuityKey, transaction.key, store);
-    const unsubscribeFromTransactionUpdates = Internal.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`
-          );
-          Internal.setIntoStore(
-            realtimeClient.optimisticUpdateQueue,
-            (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}`
-          );
-          Internal.setIntoStore(
-            realtimeClient.optimisticUpdateQueue,
-            (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;
-        Internal.setIntoStore(k, v, store);
-      }
-      i++;
-    }
-  });
-  socket.on(
-    `conceal:${continuityKey}`,
-    (concealed) => {
-      for (const token of concealed) {
-        Internal.disposeAtom(token, store);
-      }
-    }
-  );
-  socket.emit(`get:${continuityKey}`);
-  return () => {
-    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;
-exports.pullMutableAtom = pullMutableAtom;
-exports.pullMutableAtomFamilyMember = pullMutableAtomFamilyMember;
-exports.pullSelector = pullSelector;
-exports.pullSelectorFamilyMember = pullSelectorFamilyMember;
-exports.pushState = pushState;
-exports.serverAction = serverAction;
-exports.syncContinuity = syncContinuity;