atom.io 0.31.0 → 0.32.0

package/transceivers/set-rtx/dist/index.js

@@ -1,213 +1,2 @@
+export { SetRTX } from '../../../dist/chunk-GY2XQYZY.js';
 import '../../../dist/chunk-XWL6SNVU.js';
-import { Subject } from 'atom.io/internal';
-import { stringifyJson } from 'atom.io/json';
-
-var SetRTX = class _SetRTX extends Set {
-  mode = `record`;
-  subject = new Subject();
-  cacheLimit = 0;
-  cache = [];
-  cacheIdx = -1;
-  cacheUpdateNumber = -1;
-  constructor(values, cacheLimit = 0) {
-    super(values);
-    if (values instanceof _SetRTX) {
-      this.parent = values;
-      this.cacheUpdateNumber = values.cacheUpdateNumber;
-    }
-    if (cacheLimit) {
-      this.cacheLimit = cacheLimit;
-      this.cache = new Array(cacheLimit);
-      this.subscribe(`auto cache`, (update) => {
-        this.cacheIdx++;
-        this.cacheIdx %= this.cacheLimit;
-        this.cache[this.cacheIdx] = update;
-      });
-    }
-  }
-  toJSON() {
-    return {
-      members: [...this],
-      cache: this.cache,
-      cacheLimit: this.cacheLimit,
-      cacheIdx: this.cacheIdx,
-      cacheUpdateNumber: this.cacheUpdateNumber
-    };
-  }
-  static fromJSON(json) {
-    const set = new _SetRTX(json.members, json.cacheLimit);
-    set.cache = json.cache;
-    set.cacheIdx = json.cacheIdx;
-    set.cacheUpdateNumber = json.cacheUpdateNumber;
-    return set;
-  }
-  add(value) {
-    const result = super.add(value);
-    if (this.mode === `record`) {
-      this.cacheUpdateNumber++;
-      this.emit(`add:${stringifyJson(value)}`);
-    }
-    return result;
-  }
-  clear() {
-    const capturedContents = this.mode === `record` ? [...this] : null;
-    super.clear();
-    if (capturedContents) {
-      this.cacheUpdateNumber++;
-      this.emit(`clear:${JSON.stringify(capturedContents)}`);
-    }
-  }
-  delete(value) {
-    const result = super.delete(value);
-    if (this.mode === `record`) {
-      this.cacheUpdateNumber++;
-      this.emit(`del:${stringifyJson(value)}`);
-    }
-    return result;
-  }
-  parent;
-  child = null;
-  transactionUpdates = null;
-  transaction(run) {
-    this.mode = `transaction`;
-    this.transactionUpdates = [];
-    this.child = new _SetRTX(this);
-    const unsubscribe = this.child._subscribe(`transaction`, (update) => {
-      this.transactionUpdates?.push(update);
-    });
-    try {
-      const shouldCommit = run(this.child);
-      if (shouldCommit) {
-        for (const update of this.transactionUpdates) {
-          this.doStep(update);
-        }
-        this.cacheUpdateNumber++;
-        this.emit(`tx:${this.transactionUpdates.join(`;`)}`);
-      }
-    } catch (thrown) {
-      console.error(`Failed to apply transaction to SetRTX:`, thrown);
-      throw thrown;
-    } finally {
-      unsubscribe();
-      this.child = null;
-      this.transactionUpdates = null;
-      this.mode = `record`;
-    }
-  }
-  _subscribe(key, fn) {
-    return this.subject.subscribe(key, fn);
-  }
-  subscribe(key, fn) {
-    return this.subject.subscribe(key, (update) => {
-      fn(`${this.cacheUpdateNumber}=${update}`);
-    });
-  }
-  emit(update) {
-    this.subject.next(update);
-  }
-  doStep(update) {
-    const typeValueBreak = update.indexOf(`:`);
-    const type = update.substring(0, typeValueBreak);
-    const value = update.substring(typeValueBreak + 1);
-    switch (type) {
-      case `add`:
-        this.add(JSON.parse(value));
-        break;
-      case `clear`:
-        this.clear();
-        break;
-      case `del`:
-        this.delete(JSON.parse(value));
-        break;
-      case `tx`:
-        for (const subUpdate of value.split(`;`)) {
-          this.doStep(subUpdate);
-        }
-    }
-  }
-  getUpdateNumber(update) {
-    const breakpoint = update.indexOf(`=`);
-    return Number(update.substring(0, breakpoint));
-  }
-  do(update) {
-    const breakpoint = update.indexOf(`=`);
-    const updateNumber = Number(update.substring(0, breakpoint));
-    const eventOffset = updateNumber - this.cacheUpdateNumber;
-    const isFuture = eventOffset > 0;
-    if (isFuture) {
-      if (eventOffset === 1) {
-        this.mode = `playback`;
-        const innerUpdate = update.substring(breakpoint + 1);
-        this.doStep(innerUpdate);
-        this.mode = `record`;
-        this.cacheUpdateNumber = updateNumber;
-        return null;
-      }
-      return this.cacheUpdateNumber + 1;
-    }
-    if (Math.abs(eventOffset) < this.cacheLimit) {
-      const eventIdx = this.cacheIdx + eventOffset;
-      const cachedUpdate = this.cache[eventIdx];
-      if (cachedUpdate === update) {
-        return null;
-      }
-      this.mode = `playback`;
-      let done = false;
-      while (!done) {
-        this.cacheIdx %= this.cacheLimit;
-        const u = this.cache[this.cacheIdx];
-        this.cacheIdx--;
-        if (!u) {
-          return `OUT_OF_RANGE`;
-        }
-        this.undo(u);
-        done = this.cacheIdx === eventIdx - 1;
-      }
-      const innerUpdate = update.substring(breakpoint + 1);
-      this.doStep(innerUpdate);
-      this.mode = `record`;
-      this.cacheUpdateNumber = updateNumber;
-      return null;
-    }
-    return `OUT_OF_RANGE`;
-  }
-  undoStep(update) {
-    const breakpoint = update.indexOf(`:`);
-    const type = update.substring(0, breakpoint);
-    const value = update.substring(breakpoint + 1);
-    switch (type) {
-      case `add`:
-        this.delete(JSON.parse(value));
-        break;
-      case `del`:
-        this.add(JSON.parse(value));
-        break;
-      case `clear`: {
-        const values = JSON.parse(value);
-        for (const v of values) this.add(v);
-        break;
-      }
-      case `tx`: {
-        const updates = value.split(`;`);
-        for (let i = updates.length - 1; i >= 0; i--) {
-          this.undoStep(updates[i]);
-        }
-      }
-    }
-  }
-  undo(update) {
-    const breakpoint = update.indexOf(`=`);
-    const updateNumber = Number(update.substring(0, breakpoint));
-    if (updateNumber === this.cacheUpdateNumber) {
-      this.mode = `playback`;
-      const innerUpdate = update.substring(breakpoint + 1);
-      this.undoStep(innerUpdate);
-      this.mode = `record`;
-      this.cacheUpdateNumber--;
-      return null;
-    }
-    return this.cacheUpdateNumber;
-  }
-};
-
-export { SetRTX };

package/transceivers/set-rtx/src/set-rtx.ts

@@ -111,7 +111,10 @@ export class SetRTX<P extends primitive>
 			}
 		} catch (thrown) {
 			/* eslint-disable-next-line no-console */
-			console.error(`Failed to apply transaction to SetRTX:`, thrown)
+			console.warn(
+				`Did not apply transaction to SetRTX; this error was thrown:`,
+				thrown,
+			)
 			throw thrown
 		} finally {
 			unsubscribe()

package/web/dist/index.d.ts

@@ -1,4 +1,33 @@
-import { AtomEffect } from 'atom.io';
+/** @public */
+type Effectors<T> = {
+    /**
+     * Set the value of the atom
+     * @param next - The new value of the atom, or a setter function
+     */
+    setSelf: <New extends T>(next: New | Setter<T, New>) => void;
+    /** Subscribe to changes to the atom */
+    onSet: (callback: (options: {
+        newValue: T;
+        oldValue: T;
+    }) => void) => void;
+};
+/**
+ * @public
+ * A function that runs side effects when the atom is set
+ * @param tools - {@link Effectors} that can be used to run side effects
+ * @returns
+ * Optionally, a cleanup function that will be called when the atom is disposed
+ */
+type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+
+/**
+ * @public
+ * A function that sets the value of a state.
+ * @param oldValue - The current value of the state.
+ * @returns
+ * The new value of the state.
+ */
+type Setter<T, New extends T> = (oldValue: T) => New;
 
 type StringInterface<T> = {
     stringify: (t: T) => string;

package/web/dist/index.js

@@ -1,16 +1,2 @@
+export { persistSync } from '../../dist/chunk-4LWKCEW3.js';
 import '../../dist/chunk-XWL6SNVU.js';
-
-// 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 };

package/data/src/until.ts

@@ -1,15 +0,0 @@
-export type Loadable<T> = Promise<T> | T
-export type Fated<T, E extends Error = Error> = Loadable<E | T>
-
-/**
- * Utility for handling loadable values
- * @param loadable Loadable value
- * @param fallback Fallback value until Loadable is resolved
- * @returns Fallback value if your loadable is a promise, otherwise the loadable's resolved value
- */
-export function until<T>(loadable: Loadable<T>, fallback: T): T {
-	if (loadable instanceof Promise) {
-		return fallback
-	}
-	return loadable
-}

package/dist/chunk-ICGFFQ3H.js

@@ -1,272 +0,0 @@
-import { IMPLICIT, newest, isChildStore, findInStore, disposeFromStore, getTrace } from 'atom.io/internal';
-import { stringifyJson, parseJson } from 'atom.io/json';
-
-// src/molecule.ts
-function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
-  const molecule = {
-    key,
-    stringKey: stringifyJson(key),
-    dependsOn: `any`
-  };
-  store.molecules.set(stringifyJson(key), molecule);
-  return key;
-}
-var $claim = Symbol(`claim`);
-function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
-  const origin = provenance;
-  const stringKey = stringifyJson(key);
-  const invalidKeys = [];
-  const target = newest(store);
-  if (Array.isArray(origin)) {
-    for (const formerClaim of origin) {
-      const claimString = stringifyJson(formerClaim);
-      const claim = target.molecules.get(claimString);
-      if (claim) {
-        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-      } else {
-        invalidKeys.push(claimString);
-      }
-    }
-  } else {
-    const claimString = stringifyJson(origin);
-    const claim = target.molecules.get(claimString);
-    if (claim) {
-      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-    } else {
-      invalidKeys.push(claimString);
-    }
-  }
-  if (invalidKeys.length === 0) {
-    target.molecules.set(stringKey, { key, stringKey, dependsOn });
-  }
-  const creationEvent = {
-    type: `molecule_creation`,
-    key,
-    provenance: origin
-  };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(creationEvent);
-  } else {
-    target.on.moleculeCreation.next(creationEvent);
-  }
-  for (const claim of invalidKeys) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === claim
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      key,
-      `allocation failed:`,
-      `Could not allocate to ${claim} in store "${store.config.name}".`,
-      disposal ? `
-   ${claim} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${claim} was found.`
-    );
-  }
-  return key;
-}
-function fuseWithinStore(store, type, sideA, sideB) {
-  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
-  const above = [sideA, sideB];
-  allocateIntoStore(
-    store,
-    above,
-    compoundKey,
-    `all`
-  );
-  return compoundKey;
-}
-function deallocateFromStore(store, claim) {
-  const stringKey = stringifyJson(claim);
-  const molecule = store.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === stringKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `deallocation failed:`,
-      `Could not find allocation for ${stringKey} in store "${store.config.name}".`,
-      disposal ? `
-   This state was most recently deallocated
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
-    );
-    return;
-  }
-  const joinKeys = store.moleculeJoins.getRelatedKeys(
-    molecule.key
-  );
-  if (joinKeys) {
-    for (const joinKey of joinKeys) {
-      const join = store.joins.get(joinKey);
-      if (join) {
-        join.relations.delete(molecule.key);
-        join.molecules.delete(molecule.stringKey);
-      }
-    }
-  }
-  store.moleculeJoins.delete(molecule.stringKey);
-  const provenance = [];
-  const values = [];
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    key: molecule.key,
-    values,
-    provenance
-  };
-  const target = newest(store);
-  target.molecules.delete(stringKey);
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(disposalEvent);
-  }
-  const relatedMolecules = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  });
-  if (relatedMolecules) {
-    for (const [relatedStringKey, { source }] of relatedMolecules) {
-      if (source === molecule.stringKey) {
-        const relatedKey = parseJson(relatedStringKey);
-        deallocateFromStore(store, relatedKey);
-      } else {
-        provenance.push(source);
-      }
-    }
-  }
-  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
-  if (familyKeys) {
-    for (const familyKey of familyKeys) {
-      const family = target.families.get(familyKey);
-      const token = findInStore(store, family, molecule.key);
-      values.push([family.key, token]);
-      disposeFromStore(store, token);
-    }
-  }
-  target.moleculeGraph.delete(molecule.stringKey);
-  target.moleculeJoins.delete(molecule.stringKey);
-  target.moleculeData.delete(molecule.stringKey);
-  if (!isTransaction) {
-    target.on.moleculeDisposal.next(disposalEvent);
-  }
-  target.molecules.delete(molecule.stringKey);
-  const trace = getTrace(new Error());
-  store.disposalTraces.add({ key: stringKey, trace });
-}
-function claimWithinStore(store, newProvenance, claim, exclusive) {
-  const stringKey = stringifyJson(claim);
-  const target = newest(store);
-  const molecule = target.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === stringKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `claim failed:`,
-      `Could not allocate to ${stringKey} in store "${store.config.name}".`,
-      disposal ? `
-   ${stringKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
-    );
-    return claim;
-  }
-  const newProvenanceKey = stringifyJson(newProvenance);
-  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
-  if (!newProvenanceMolecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === newProvenanceKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `claim failed:`,
-      `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
-      disposal ? `
-   ${newProvenanceKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`
-    );
-    return claim;
-  }
-  const priorProvenance = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
-  if (exclusive) {
-    target.moleculeGraph.delete(stringKey);
-  }
-  target.moleculeGraph.set(
-    {
-      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
-      downstreamMoleculeKey: molecule.stringKey
-    },
-    {
-      source: newProvenanceMolecule.stringKey
-    }
-  );
-  const transferEvent = {
-    type: `molecule_transfer`,
-    key: molecule.key,
-    from: priorProvenance,
-    to: [newProvenanceMolecule.key]
-  };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(transferEvent);
-  }
-  return claim;
-}
-var Realm = class {
-  store;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    makeRootMoleculeInStore(`root`, store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    return allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-  deallocate(claim) {
-    deallocateFromStore(this.store, claim);
-  }
-  claim(newProvenance, claim, exclusive) {
-    return claimWithinStore(this.store, newProvenance, claim, exclusive);
-  }
-};
-var T$ = `T$`;
-var Anarchy = class {
-  store;
-  realm;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Realm(store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  deallocate(key) {
-    deallocateFromStore(this.store, key);
-  }
-  claim(newProvenance, key, exclusive) {
-    claimWithinStore(this.store, newProvenance, key, exclusive);
-  }
-};
-
-export { $claim, Anarchy, Realm, T$, allocateIntoStore, claimWithinStore, deallocateFromStore, fuseWithinStore, makeRootMoleculeInStore };

package/ephemeral/dist/index.d.ts

@@ -1,57 +0,0 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
-import { Transceiver } from 'atom.io/internal';
-import { Json, Canonical } from 'atom.io/json';
-
-/**
- * @overload Mutable Atom
- * Finds a {@link MutableAtomToken} in the store.
- * @param token - A {@link MutableAtomFamilyToken}.
- * @param key - The key of the state.
- * @returns
- * The current value of the state.
- */
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
-/**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
- * @returns
- * The current value of the state.
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
-/**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
- * @returns
- * The current value of the state.
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
-/**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
- * @returns
- * The current value of the state.
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
-/**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
- * @returns
- * The current value of the state.
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
-/**
- * @public
- * Finds a {@link ReadableToken} in the store.
- * @param token - A {@link ReadableFamilyToken}.
- * @param key - The key of the state.
- * @returns
- * The current value of the state.
- * @overload Unknown
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
-
-export { findState };

package/ephemeral/dist/index.js

@@ -1,9 +0,0 @@
-import '../../dist/chunk-XWL6SNVU.js';
-import { findInStore, IMPLICIT } from 'atom.io/internal';
-
-function findState(token, key) {
-  const state = findInStore(IMPLICIT.STORE, token, key);
-  return state;
-}
-
-export { findState };

package/ephemeral/package.json

@@ -1,13 +0,0 @@
-{
-	"name": "atom.io-ephemeral",
-	"type": "module",
-	"private": true,
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		}
-	}
-}

package/ephemeral/src/index.ts

@@ -1 +0,0 @@
-export * from "./find-state"