atom.io 0.16.3 → 0.18.0

package/internal/dist/index.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
-var atom_io = require('atom.io');
 var json = require('atom.io/json');
-var internal = require('atom.io/internal');
+var atom_io = require('atom.io');
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -333,6 +332,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) {
@@ -376,7 +383,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`
@@ -401,7 +412,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
       });
@@ -468,6 +486,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;
@@ -522,34 +546,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);
@@ -576,10 +572,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) => {
@@ -594,7 +587,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`);
@@ -764,14 +757,6 @@ var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing insta
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
 
-// 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/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
@@ -834,6 +819,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(
@@ -925,7 +925,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);
@@ -942,19 +947,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);
     }
   }
 };
@@ -972,6 +972,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);
@@ -1307,8 +1322,10 @@ function subscribeToState(token, handleUpdate, key, store) {
   };
   return unsubscribe;
 }
+
+// internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = internal.withdraw(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}".`
@@ -1326,8 +1343,10 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
-  const tx = internal.withdraw(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}".`
@@ -1350,6 +1369,8 @@ var subscribeToTransaction = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/mutable/tracker.ts
 var Tracker = class {
   initializeState(mutableState, store) {
     var _a;
@@ -1376,7 +1397,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 = atom_io.getState(mutableState, target);
+    const originalInnerValue = getFromStore(mutableState, target);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
@@ -1385,12 +1406,12 @@ var Tracker = class {
             subscriptionKey,
             () => {
               unsubscribe();
-              atom_io.setState(latestUpdateState, update, target);
+              setIntoStore(latestUpdateState, update, target);
             }
           );
         } else {
-          atom_io.setState(mutableState, (current) => current, target);
-          atom_io.setState(latestUpdateState, update, target);
+          setIntoStore(mutableState, (current) => current, target);
+          setIntoStore(latestUpdateState, update, target);
         }
       }
     );
@@ -1407,12 +1428,12 @@ var Tracker = class {
                   subscriptionKey,
                   () => {
                     unsubscribe();
-                    atom_io.setState(latestUpdateState, update2, target);
+                    setIntoStore(latestUpdateState, update2, target);
                   }
                 );
               } else {
-                atom_io.setState(mutableState, (current) => current, target);
-                atom_io.setState(latestUpdateState, update2, target);
+                setIntoStore(mutableState, (current) => current, target);
+                setIntoStore(latestUpdateState, update2, target);
               }
             }
           );
@@ -1437,7 +1458,7 @@ var Tracker = class {
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                atom_io.setState(
+                setIntoStore(
                   mutableState,
                   (transceiver) => {
                     if (update === `redo` && newValue) {
@@ -1460,11 +1481,11 @@ var Tracker = class {
           subscriptionKey,
           () => {
             unsubscribe();
-            const mutable = atom_io.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) {
-              atom_io.setState(
+              setIntoStore(
                 mutableState,
                 (transceiver) => (transceiver.do(newValue), transceiver),
                 target
@@ -1545,7 +1566,7 @@ function createMutableAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => atom_io.setState(token, next, store),
+        setSelf: (next) => setIntoStore(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1752,7 +1773,7 @@ function createRegularAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => atom_io.setState(token, next, store),
+        setSelf: (next) => setIntoStore(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1811,17 +1832,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;
-  atom_io.setState({ key, type: `atom` }, value, store);
+  setIntoStore({ key, type: `atom` }, value, store);
 }
 
 // internal/src/ingest-updates/ingest-selector-update.ts
@@ -2100,7 +2139,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) => {
@@ -2253,6 +2302,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;
@@ -2301,7 +2380,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
@@ -2318,6 +2402,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 = {
@@ -2343,20 +2442,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) => atom_io.getState(token, child),
-      set: (token, value) => atom_io.setState(token, value, child),
-      run: (token, id2) => atom_io.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)
     }
@@ -2404,6 +2504,24 @@ 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`];
 
@@ -2418,8 +2536,11 @@ exports.Subject = Subject;
 exports.TRANSACTION_PHASES = TRANSACTION_PHASES;
 exports.Tracker = Tracker;
 exports.abortTransaction = abortTransaction;
+exports.actUponStore = actUponStore;
 exports.addAtomToTimeline = addAtomToTimeline;
 exports.applyTransaction = applyTransaction;
+exports.arbitrary = arbitrary;
+exports.assignTransactionToContinuity = assignTransactionToContinuity;
 exports.become = become;
 exports.buildTransaction = buildTransaction;
 exports.cacheValue = cacheValue;
@@ -2443,7 +2564,11 @@ exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
 exports.evictCachedValue = evictCachedValue;
 exports.findInStore = findInStore;
+exports.getContinuityKey = getContinuityKey;
 exports.getEnvironmentData = getEnvironmentData;
+exports.getEpochNumberOfAction = getEpochNumberOfAction;
+exports.getEpochNumberOfContinuity = getEpochNumberOfContinuity;
+exports.getFromStore = getFromStore;
 exports.getJsonFamily = getJsonFamily;
 exports.getJsonToken = getJsonToken;
 exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
@@ -2453,9 +2578,11 @@ exports.ingestSelectorUpdate = ingestSelectorUpdate;
 exports.ingestTransactionUpdate = ingestTransactionUpdate;
 exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
+exports.isChildStore = isChildStore;
 exports.isDone = isDone;
 exports.isMutable = isMutable;
 exports.isReadonlySelectorKey = isReadonlySelectorKey;
+exports.isRootStore = isRootStore;
 exports.isSelectorKey = isSelectorKey;
 exports.isStateKey = isStateKey;
 exports.isTransceiver = isTransceiver;
@@ -2468,6 +2595,9 @@ exports.readCachedValue = readCachedValue;
 exports.readOrComputeValue = readOrComputeValue;
 exports.registerSelector = registerSelector;
 exports.setAtomOrSelector = setAtomOrSelector;
+exports.setEpochNumberOfAction = setEpochNumberOfAction;
+exports.setEpochNumberOfContinuity = setEpochNumberOfContinuity;
+exports.setIntoStore = setIntoStore;
 exports.subscribeToRootAtoms = subscribeToRootAtoms;
 exports.subscribeToState = subscribeToState;
 exports.subscribeToTimeline = subscribeToTimeline;