atom.io 0.23.5 → 0.24.1

package/dist/chunk-GVHKIJ3G.js

@@ -1,329 +0,0 @@
-import { getFromStore, assignTransactionToContinuity, subscribeToTransaction, setIntoStore, disposeAtom, setEpochNumberOfContinuity, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, getJsonToken, actUponStore } from 'atom.io/internal';
-import { optimisticUpdateQueue, confirmedUpdateQueue } from 'atom.io/realtime-client';
-
-// realtime-client/src/sync-continuity.ts
-function syncContinuity(continuity, socket, store) {
-  const continuityKey = continuity.key;
-  const optimisticUpdates = getFromStore(optimisticUpdateQueue, store);
-  const confirmedUpdates = getFromStore(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 = 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,
-        (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,
-            (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,
-            (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,
-            (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,
-            (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 { syncContinuity };

package/dist/chunk-O47EQUM6.js

@@ -1,29 +0,0 @@
-import { lazyLocalStorageEffect } from './chunk-BWWVY5O5.js';
-import * as AtomIO from 'atom.io';
-
-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: []
-  }
-);
-
-export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue };

package/dist/chunk-OAYGID5B.js

@@ -1,27 +0,0 @@
-// ../anvl/src/json/json-interface.ts
-var stringSetJsonInterface = {
-  toJson: (stringSet) => Array.from(stringSet),
-  fromJson: (json) => new Set(json)
-};
-
-// ../anvl/src/json/index.ts
-var parseJson = (str) => JSON.parse(str);
-var stringifyJson = (json) => JSON.stringify(json);
-var JSON_TYPE_NAMES = [
-  `array`,
-  `boolean`,
-  `null`,
-  `number`,
-  `object`,
-  `string`
-];
-var JSON_DEFAULTS = {
-  array: [],
-  boolean: false,
-  null: null,
-  number: 0,
-  object: {},
-  string: ``
-};
-
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, parseJson, stringSetJsonInterface, stringifyJson };

package/dist/chunk-PNIHPILQ.js

@@ -1,8 +0,0 @@
-import * as Internal from 'atom.io/internal';
-
-// src/get-state.ts
-function getState(token) {
-  return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
-}
-
-export { getState };

package/immortal/src/make-molecule.ts

@@ -1,234 +0,0 @@
-import type { Flat, MoleculeCreation, MoleculeDisposal } from "atom.io"
-import * as Internal from "atom.io/internal"
-import { type Json, stringifyJson } from "atom.io/json"
-
-import { Molecule } from "./molecule"
-
-export type MoleculeConstructor<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
-> = new (
-	context: Molecule<any>[],
-	token: MoleculeToken<Key, Struct, Params>,
-	...params: Params
-) => Molecule<Key> & Struct
-
-export type MoleculeFamilyToken<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
-> = {
-	key: string
-	type: `molecule_family`
-	__K?: Key
-	__S?: Struct
-	__P?: Params
-}
-export type MoleculeFamily<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
-> = Flat<
-	MoleculeFamilyToken<Key, Struct, Params> & {
-		subject: Internal.Subject<MoleculeCreation<Key> | MoleculeDisposal<Key>>
-	}
-> &
-	MoleculeConstructor<Key, Struct, Params>
-
-export type MoleculeToken<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
-> = {
-	key: Key
-	type: `molecule`
-	family?: MoleculeFamilyToken<Key, Struct, Params>
-	__S?: Struct
-	__P?: Params
-}
-
-export type MoleculeFamilyOptions<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
-> = {
-	key: string
-	new: (store: Internal.Store) => MoleculeConstructor<Key, Struct, Params>
-}
-
-export function createMoleculeFamily<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(
-	options: MoleculeFamilyOptions<Key, Struct, Params>,
-	store: Internal.Store,
-): MoleculeFamilyToken<Key, Struct, Params> {
-	const subject = new Internal.Subject<
-		MoleculeCreation<Key> | MoleculeDisposal<Key>
-	>()
-	const token = {
-		key: options.key,
-		type: `molecule_family`,
-	} as const satisfies MoleculeFamilyToken<Key, Struct, Params>
-	const family = Object.assign(options.new(store), { ...token, subject })
-	store.moleculeFamilies.set(options.key, family)
-	return token
-}
-
-export function moleculeFamily<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(
-	options: MoleculeFamilyOptions<Key, Struct, Params>,
-): MoleculeFamilyToken<Key, Struct, Params> {
-	return createMoleculeFamily(options, Internal.IMPLICIT.STORE)
-}
-
-export function makeMoleculeInStore<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(
-	store: Internal.Store,
-	context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[],
-	family: MoleculeFamilyToken<Key, Struct, Params>,
-	key: Key,
-	...params: Params
-): MoleculeToken<Key, Struct, Params> {
-	const target = Internal.newest(store)
-
-	const token = {
-		type: `molecule`,
-		key,
-		family,
-	} as const satisfies MoleculeToken<Key, Struct, Params>
-
-	const contextArray = Array.isArray(context) ? context : [context]
-	const owners = contextArray.map<Molecule<any>>((ctx) => {
-		if (ctx instanceof Molecule) {
-			return ctx
-		}
-		const stringKey = stringifyJson(ctx.key)
-		const molecule = store.molecules.get(stringKey)
-
-		if (!molecule) {
-			throw new Error(
-				`Molecule ${stringKey} not found in store "${store.config.name}"`,
-			)
-		}
-		return molecule
-	})
-
-	const Formula = Internal.withdraw(family, store)
-	const molecule = new Formula(owners, token, ...params)
-	target.molecules.set(stringifyJson(key), molecule)
-
-	const update = {
-		type: `molecule_creation`,
-		token,
-		family,
-		context: contextArray,
-		params,
-	} satisfies MoleculeCreation<Key>
-
-	const isTransaction =
-		Internal.isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.updates.push(update)
-	} else {
-		Formula.subject.next(update)
-	}
-
-	return token
-}
-export function makeMolecule<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(
-	context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[],
-	family: MoleculeFamilyToken<Key, Struct, Params>,
-	key: Key,
-	...params: Params
-): MoleculeToken<Key, Struct, Params> {
-	return makeMoleculeInStore(
-		Internal.IMPLICIT.STORE,
-		context,
-		family,
-		key,
-		...params,
-	)
-}
-
-export function useMoleculeFromStore<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(
-	token: MoleculeToken<Key, Struct, Params>,
-	store: Internal.Store,
-): (Molecule<Key> & Struct) | undefined {
-	const molecule = store.molecules.get(stringifyJson(token.key))
-	return molecule as Molecule<Key> & Struct
-}
-export function useMolecule<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(
-	token: MoleculeToken<Key, Struct, Params>,
-): (Molecule<Key> & Struct) | undefined {
-	return useMoleculeFromStore(token, Internal.IMPLICIT.STORE)
-}
-
-export function disposeMolecule<
-	Key extends Json.Serializable,
-	Struct extends { [key: string]: any },
-	Params extends any[],
->(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): void {
-	const mole = useMoleculeFromStore(token, store)
-	if (!mole || !token.family) {
-		return // add error log
-	}
-	const { family } = token
-	const Formula = Internal.withdraw(family, store)
-	const disposalEvent: MoleculeDisposal<Key> = {
-		type: `molecule_disposal`,
-		token,
-		family,
-		context: mole.above,
-		familyKeys: mole.tokens
-			.map((t) => t.family?.key)
-			.filter((k): k is string => typeof k === `string`),
-	}
-	if (token.family) {
-		disposalEvent.family = token.family
-	}
-	const isTransaction =
-		Internal.isChildStore(store) && store.transactionMeta.phase === `building`
-	if (isTransaction) {
-		store.transactionMeta.update.updates.push(disposalEvent)
-	} else {
-		Formula.subject.next(disposalEvent)
-	}
-
-	mole.dispose()
-}
-
-export type MoleculeType<M extends MoleculeFamilyToken<any, any, any>> =
-	M extends MoleculeFamilyToken<any, infer T, any> ? T : never
-
-export function makeRootMolecule(
-	key: Json.Serializable,
-	store: Internal.Store = Internal.IMPLICIT.STORE,
-): MoleculeToken<Json.Serializable, { [key: string]: unknown }, []> {
-	const molecule = new Molecule(store, undefined, { key, type: `molecule` })
-	store.molecules.set(stringifyJson(key), molecule)
-	return {
-		key,
-		type: `molecule`,
-	} as const
-}