atom.io 0.16.3 → 0.18.0

package/internal/dist/index.js

@@ -1,9 +1,7 @@
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
-import { isChildStore, isRootStore } from '../../dist/chunk-H4Q5FTPZ.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
-import { AtomIOLogger, getState, setState, runTransaction } from 'atom.io';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
-import { withdraw as withdraw$1 } from 'atom.io/internal';
+import { AtomIOLogger } from 'atom.io';
 
 // internal/src/lineage.ts
 function newest(scion) {
@@ -56,6 +54,14 @@ var StatefulSubject = class extends Subject {
   }
 };
 
+// internal/src/transaction/is-root-store.ts
+function isRootStore(store) {
+  return `epoch` in store.transactionMeta;
+}
+function isChildStore(store) {
+  return `phase` in store.transactionMeta;
+}
+
 // internal/src/store/store.ts
 var Store = class {
   constructor(name, store = null) {
@@ -99,7 +105,11 @@ var Store = class {
     };
     this.operation = { open: false };
     this.transactionMeta = {
-      epoch: -1
+      epoch: /* @__PURE__ */ new Map(),
+      actionContinuities: new Junction({
+        between: [`continuity`, `action`],
+        cardinality: `1:n`
+      })
     };
     this.config = {
       name: `IMPLICIT_STORE`
@@ -124,7 +134,14 @@ var Store = class {
     if (store !== null) {
       this.valueMap = new Map(store == null ? void 0 : store.valueMap);
       this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
-      this.transactionMeta = __spreadValues({}, store == null ? void 0 : store.transactionMeta);
+      if (isRootStore(store)) {
+        this.transactionMeta = {
+          epoch: new Map(store == null ? void 0 : store.transactionMeta.epoch),
+          actionContinuities: new Junction(
+            store == null ? void 0 : store.transactionMeta.actionContinuities.toJSON()
+          )
+        };
+      }
       this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
         name
       });
@@ -191,6 +208,12 @@ function withdraw(token, store) {
       case `readonly_selector`:
         withdrawn = target.readonlySelectors.get(token.key);
         break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+      case `selector_family`:
+      case `readonly_selector_family`:
+        withdrawn = target.families.get(token.key);
+        break;
       case `timeline`:
         withdrawn = target.timelines.get(token.key);
         break;
@@ -245,34 +268,6 @@ var Future = class extends Promise {
   }
 };
 
-// internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, origin, target) {
-  const originValue = origin.valueMap.get(atom.key);
-  const targetValue = target.valueMap.get(atom.key);
-  if (originValue === targetValue) {
-    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
-    const jsonValue = atom.toJson(originValue);
-    const copiedValue = atom.fromJson(jsonValue);
-    target.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
-    return copiedValue;
-  }
-  return targetValue;
-}
-
-// internal/src/set-state/copy-mutable-in-transaction.ts
-function copyMutableIfWithinTransaction(oldValue, atom, store) {
-  const target = newest(store);
-  const parent = target.parent;
-  if (parent !== null) {
-    if (atom.type === `mutable_atom`) {
-      const copiedValue = copyMutableIfNeeded(atom, parent, target);
-      return copiedValue;
-    }
-  }
-  return oldValue;
-}
-
 // internal/src/caching.ts
 function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
@@ -299,10 +294,7 @@ function cacheValue(key, value, subject, target) {
   return value;
 }
 var readCachedValue = (token, target) => {
-  let value = target.valueMap.get(token.key);
-  if (token.type === `atom`) {
-    value = copyMutableIfWithinTransaction(value, token, target);
-  }
+  const value = target.valueMap.get(token.key);
   return value;
 };
 var evictCachedValue = (key, target) => {
@@ -317,7 +309,7 @@ var evictCachedValue = (key, target) => {
   target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 
-// internal/src/read-or-compute-value.ts
+// internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
     target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
@@ -549,6 +541,21 @@ var markDone = (key, store) => {
   store.operation.done.add(key);
 };
 
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
 // internal/src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
   store.logger.info(
@@ -640,7 +647,12 @@ var stowUpdate = (state, update, store) => {
 // internal/src/set-state/set-atom.ts
 var setAtom = (atom, next, target) => {
   const oldValue = readOrComputeValue(atom, target);
-  let newValue = copyMutableIfWithinTransaction(oldValue, atom, target);
+  let newValue = oldValue;
+  if (atom.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(atom, parent, target);
+    newValue = copiedValue;
+  }
   newValue = become(next)(newValue);
   target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
   newValue = cacheValue(atom.key, newValue, atom.subject, target);
@@ -657,19 +669,14 @@ var setAtom = (atom, next, target) => {
       stowUpdate(atom, update, target);
     } else if (atom.key.startsWith(`*`)) {
       const mutableKey = atom.key.slice(1);
-      const mutableAtom = target.atoms.get(mutableKey);
-      let mutable = target.valueMap.get(mutableKey);
-      mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target);
-      const output = mutable.do(update.newValue);
-      if (output !== null) {
-        target.logger.warn(
-          `\u274C`,
-          `mutable_atom`,
-          mutableKey,
-          `could not be updated.`,
-          typeof output === `number` ? `Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${output}` : output
-        );
+      target.atoms.get(mutableKey);
+      let transceiver = target.valueMap.get(mutableKey);
+      if (atom.type === `mutable_atom` && isChildStore(target)) {
+        const { parent } = target;
+        const copiedValue = copyMutableIfNeeded(atom, parent, target);
+        transceiver = copiedValue;
       }
+      transceiver.do(update.newValue);
     }
   }
 };
@@ -687,6 +694,21 @@ var setAtomOrSelector = (state, value, store) => {
   }
 };
 
+// internal/src/set-state/set-into-store.ts
+function setIntoStore(token, value, store) {
+  var _a;
+  const rejection = openOperation(token, store);
+  if (rejection) {
+    return;
+  }
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
 // internal/src/keys.ts
 var isAtomKey = (key, store) => newest(store).atoms.has(key);
 var isSelectorKey = (key, store) => newest(store).selectors.has(key);
@@ -1022,8 +1044,10 @@ function subscribeToState(token, handleUpdate, key, store) {
   };
   return unsubscribe;
 }
+
+// internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = withdraw$1(token, store);
+  const tl = withdraw(token, store);
   if (tl === void 0) {
     throw new Error(
       `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
@@ -1041,8 +1065,10 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
-  const tx = withdraw$1(token, store);
+  const tx = withdraw(token, store);
   if (tx === void 0) {
     throw new Error(
       `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
@@ -1065,6 +1091,8 @@ var subscribeToTransaction = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/mutable/tracker.ts
 var Tracker = class {
   initializeState(mutableState, store) {
     var _a;
@@ -1091,7 +1119,7 @@ var Tracker = class {
   }
   observeCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    const originalInnerValue = getState(mutableState, target);
+    const originalInnerValue = getFromStore(mutableState, target);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
@@ -1100,12 +1128,12 @@ var Tracker = class {
             subscriptionKey,
             () => {
               unsubscribe();
-              setState(latestUpdateState, update, target);
+              setIntoStore(latestUpdateState, update, target);
             }
           );
         } else {
-          setState(mutableState, (current) => current, target);
-          setState(latestUpdateState, update, target);
+          setIntoStore(mutableState, (current) => current, target);
+          setIntoStore(latestUpdateState, update, target);
         }
       }
     );
@@ -1122,12 +1150,12 @@ var Tracker = class {
                   subscriptionKey,
                   () => {
                     unsubscribe();
-                    setState(latestUpdateState, update2, target);
+                    setIntoStore(latestUpdateState, update2, target);
                   }
                 );
               } else {
-                setState(mutableState, (current) => current, target);
-                setState(latestUpdateState, update2, target);
+                setIntoStore(mutableState, (current) => current, target);
+                setIntoStore(latestUpdateState, update2, target);
               }
             }
           );
@@ -1152,7 +1180,7 @@ var Tracker = class {
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                setState(
+                setIntoStore(
                   mutableState,
                   (transceiver) => {
                     if (update === `redo` && newValue) {
@@ -1175,11 +1203,11 @@ var Tracker = class {
           subscriptionKey,
           () => {
             unsubscribe();
-            const mutable = getState(mutableState, target);
+            const mutable = getFromStore(mutableState, target);
             const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
-              setState(
+              setIntoStore(
                 mutableState,
                 (transceiver) => (transceiver.do(newValue), transceiver),
                 target
@@ -1260,7 +1288,7 @@ function createMutableAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => setState(token, next, store),
+        setSelf: (next) => setIntoStore(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1467,7 +1495,7 @@ function createRegularAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => setState(token, next, store),
+        setSelf: (next) => setIntoStore(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1526,17 +1554,35 @@ function deleteAtom(atomToken, store) {
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
+// internal/src/arbitrary.ts
+function arbitrary(random = Math.random) {
+  return random().toString(36).slice(2);
+}
+
 // internal/src/get-environment-data.ts
 function getEnvironmentData(store) {
   return {
-    runtime: typeof window === `undefined` ? typeof global === `object` ? `node` : `unknown` : `browser`,
+    window: typeof window === `undefined` ? void 0 : window,
+    global: typeof global === `undefined` ? void 0 : global,
     store
   };
 }
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(token, store) {
+  var _a;
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  return readOrComputeValue(state, store);
+}
+
+// internal/src/ingest-updates/ingest-atom-update.ts
 function ingestAtomUpdate(applying, atomUpdate, store) {
   const { key, newValue, oldValue } = atomUpdate;
   const value = applying === `newValue` ? newValue : oldValue;
-  setState({ key, type: `atom` }, value, store);
+  setIntoStore({ key, type: `atom` }, value, store);
 }
 
 // internal/src/ingest-updates/ingest-selector-update.ts
@@ -1815,7 +1861,17 @@ function createTimeline(options, store, data) {
   for (const tokenOrFamily of options.atoms) {
     let atomKey = tokenOrFamily.key;
     if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
-      const family = tokenOrFamily;
+      const familyToken = tokenOrFamily;
+      const family = withdraw(familyToken, store);
+      if (family === void 0) {
+        store.logger.error(
+          `\u274C`,
+          `timeline`,
+          options.key,
+          `Failed to add family "${familyToken.key}" because it does not exist in the store`
+        );
+        continue;
+      }
       const familyKey = family.key;
       target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
@@ -1968,6 +2024,36 @@ var abortTransaction = (store) => {
   target.parent.child = null;
 };
 
+// internal/src/transaction/act-upon-store.ts
+function actUponStore(token, id, store) {
+  return (...parameters) => {
+    const tx = withdraw(token, store);
+    if (tx) {
+      return tx.run(parameters, id);
+    }
+    throw new NotFoundError(token, store);
+  };
+}
+
+// internal/src/transaction/set-epoch-number.ts
+function setEpochNumberOfContinuity(continuityKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (isRoot && continuityKey) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+function setEpochNumberOfAction(transactionKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== void 0) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+    console.log(`epoch is now`, newEpoch);
+  }
+}
+
 // internal/src/transaction/apply-transaction.ts
 var applyTransaction = (output, store) => {
   var _a;
@@ -2016,7 +2102,12 @@ var applyTransaction = (output, store) => {
   }
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (isRootStore(parent)) {
-    parent.transactionMeta.epoch = child.transactionMeta.update.epoch;
+    console.log(child.transactionMeta.update);
+    setEpochNumberOfAction(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
+    );
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
       store
@@ -2033,6 +2124,21 @@ var applyTransaction = (output, store) => {
   }
   parent.on.transactionApplying.next(null);
 };
+
+// internal/src/transaction/assign-transaction-to-continuity.ts
+function assignTransactionToContinuity(continuityKey, transactionKey, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const { epoch, actionContinuities } = store.transactionMeta;
+  actionContinuities.set(continuityKey, transactionKey);
+  if (!epoch.has(continuityKey)) {
+    epoch.set(continuityKey, -1);
+  }
+}
+
+// internal/src/transaction/build-transaction.ts
 var buildTransaction = (key, params, store, id) => {
   const parent = newest(store);
   const childBase = {
@@ -2058,20 +2164,21 @@ var buildTransaction = (key, params, store, id) => {
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap)
   };
+  const epoch = getEpochNumberOfAction(key, store);
   const transactionMeta = {
     phase: `building`,
     update: {
       key,
-      id: id != null ? id : Math.random().toString(36).slice(2),
-      epoch: isRootStore(parent) ? parent.transactionMeta.epoch + 1 : NaN,
+      id,
+      epoch: epoch === void 0 ? NaN : epoch + 1,
       updates: [],
       params,
       output: void 0
     },
     transactors: {
-      get: (token) => getState(token, child),
-      set: (token, value) => setState(token, value, child),
-      run: (token, id2) => runTransaction(token, id2, child),
+      get: (token) => getFromStore(token, child),
+      set: (token, value) => setIntoStore(token, value, child),
+      run: (token, id2 = arbitrary()) => actUponStore(token, id2, child),
       find: (token, key2) => findInStore(token, key2, child),
       env: () => getEnvironmentData(child)
     }
@@ -2119,9 +2226,27 @@ function createTransaction(options, store) {
   return token;
 }
 
+// internal/src/transaction/get-epoch-number.ts
+function getContinuityKey(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  return continuity;
+}
+function getEpochNumberOfContinuity(continuityKey, store) {
+  const isRoot = isRootStore(store);
+  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : void 0;
+  return epoch;
+}
+function getEpochNumberOfAction(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  const epoch = isRoot && continuity !== void 0 ? store.transactionMeta.epoch.get(continuity) : void 0;
+  return epoch;
+}
+
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isMutable, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map