atom.io 0.7.0 → 0.8.1

package/internal/dist/index.js

@@ -1,28 +1,8 @@
 'use strict';
 
-var AtomIO = require('atom.io');
+var atom_io = require('atom.io');
 var json = require('atom.io/json');
 
-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 AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
-
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -43,6 +23,25 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
+// src/future.ts
+var Future = class extends Promise {
+  constructor(executor) {
+    super((resolve, reject) => {
+      const pass = (value) => this.isCanceled ? reject(`canceled`) : resolve(value);
+      const fail = (reason) => this.isCanceled ? reject(`canceled`) : reject(reason);
+      if (typeof executor === `function`) {
+        executor(pass, fail);
+      } else {
+        executor.then(pass, fail);
+      }
+    });
+    this.isCanceled = false;
+  }
+  cancel() {
+    this.isCanceled = true;
+  }
+};
+
 // src/store/deposit.ts
 function deposit(state) {
   const token = {
@@ -122,13 +121,13 @@ var applyTransaction = (output, store) => {
         (_d = store.config.logger) == null ? void 0 : _d.info(`\u{1F527}`, `add atom "${newAtom.key}"`);
       }
     }
-    AtomIO.setState(token, newValue, store);
+    atom_io.setState(token, newValue, store);
   }
   const myTransaction = withdraw(
     { key: store.transactionStatus.key, type: `transaction` },
     store
   );
-  if (myTransaction === null) {
+  if (myTransaction === void 0) {
     throw new Error(
       `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
     );
@@ -384,8 +383,8 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
       try {
         const output = options.do(
           {
-            get: (token2) => AtomIO.getState(token2, store),
-            set: (token2, value) => AtomIO.setState(token2, value, store)
+            get: (token2) => atom_io.getState(token2, store),
+            set: (token2, value) => atom_io.setState(token2, value, store)
           },
           ...params
         );
@@ -416,12 +415,12 @@ var redoTransactionUpdate = (update, store) => {
   for (const { key, newValue } of update.atomUpdates) {
     const token = { key, type: `atom` };
     const state = withdraw(token, store);
-    if (state === null) {
+    if (state === void 0) {
       throw new Error(
         `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
       );
     }
-    AtomIO.setState(state, newValue, store);
+    atom_io.setState(state, newValue, store);
   }
 };
 var undoTransactionUpdate = (update, store) => {
@@ -430,12 +429,12 @@ var undoTransactionUpdate = (update, store) => {
   for (const { key, oldValue } of update.atomUpdates) {
     const token = { key, type: `atom` };
     const state = withdraw(token, store);
-    if (state === null) {
+    if (state === void 0) {
       throw new Error(
         `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
       );
     }
-    AtomIO.setState(state, oldValue, store);
+    atom_io.setState(state, oldValue, store);
   }
 };
 
@@ -546,7 +545,7 @@ var clearStore = (store = IMPLICIT.STORE) => {
 // src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
   const atom = withdraw(atomToken, store);
-  if (atom === null) {
+  if (atom === void 0) {
     throw new Error(
       `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
     );
@@ -578,7 +577,7 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
           { key: currentTransactionKey, type: `transaction` },
           store
         );
-        if (currentTransaction === null) {
+        if (currentTransaction === void 0) {
           throw new Error(
             `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
           );
@@ -712,14 +711,14 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   switch (update.type) {
     case `atom_update`: {
       const { key, newValue } = update;
-      AtomIO.setState({ key, type: `atom` }, newValue, store);
+      atom_io.setState({ key, type: `atom` }, newValue, store);
       break;
     }
     case `selector_update`:
     case `transaction_update`: {
       for (const atomUpdate of update.atomUpdates) {
         const { key, newValue } = atomUpdate;
-        AtomIO.setState({ key, type: `atom` }, newValue, store);
+        atom_io.setState({ key, type: `atom` }, newValue, store);
       }
       break;
     }
@@ -753,14 +752,14 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   switch (update.type) {
     case `atom_update`: {
       const { key, oldValue } = update;
-      AtomIO.setState({ key, type: `atom` }, oldValue, store);
+      atom_io.setState({ key, type: `atom` }, oldValue, store);
       break;
     }
     case `selector_update`:
     case `transaction_update`: {
       for (const atomUpdate of [...update.atomUpdates].reverse()) {
         const { key, oldValue } = atomUpdate;
-        AtomIO.setState({ key, type: `atom` }, oldValue, store);
+        atom_io.setState({ key, type: `atom` }, oldValue, store);
       }
       break;
     }
@@ -877,7 +876,7 @@ function withdraw(token, store) {
       return state;
     }
   }
-  return null;
+  return void 0;
 }
 
 // src/store/withdraw-new-family-member.ts
@@ -896,12 +895,31 @@ function withdrawNewFamilyMember(token, store) {
       return state;
     }
   }
-  return null;
+  return void 0;
 }
 
 // src/caching.ts
-var cacheValue = (key, value, store = IMPLICIT.STORE) => {
-  target(store).valueMap.set(key, value);
+var cacheValue = (key, value, subject, store = IMPLICIT.STORE) => {
+  const currentValue = target(store).valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target(store).valueMap.set(key, future);
+    future.then((value2) => {
+      cacheValue(key, value2, subject, store);
+      subject.next({ newValue: value2, oldValue: value2 });
+    }).catch((error) => {
+      var _a;
+      (_a = store.config.logger) == null ? void 0 : _a.error(
+        `Promised value for "${key}" rejected:`,
+        error
+      );
+    });
+  } else {
+    target(store).valueMap.set(key, value);
+  }
 };
 var readCachedValue = (key, store = IMPLICIT.STORE) => target(store).valueMap.get(key);
 var isValueCached = (key, store = IMPLICIT.STORE) => target(store).valueMap.has(key);
@@ -933,7 +951,7 @@ var Tracker = class {
     return latestUpdateState;
   }
   observeCore(mutableState, latestUpdateState, store = IMPLICIT.STORE) {
-    const originalInnerValue = AtomIO__namespace.getState(mutableState, store);
+    const originalInnerValue = atom_io.getState(mutableState, store);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       `tracker:${store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
       (update) => {
@@ -941,12 +959,12 @@ var Tracker = class {
           mutableState.key,
           () => {
             unsubscribe();
-            AtomIO__namespace.setState(latestUpdateState, update, store);
+            atom_io.setState(latestUpdateState, update, store);
           }
         );
       }
     );
-    AtomIO__namespace.subscribe(
+    atom_io.subscribe(
       mutableState,
       (update) => {
         var _a;
@@ -959,7 +977,7 @@ var Tracker = class {
                 mutableState.key,
                 () => {
                   unsubscribe();
-                  AtomIO__namespace.setState(latestUpdateState, update2, store);
+                  atom_io.setState(latestUpdateState, update2, store);
                 }
               );
             }
@@ -971,7 +989,7 @@ var Tracker = class {
     );
   }
   updateCore(mutableState, latestUpdateState, store = IMPLICIT.STORE) {
-    AtomIO__namespace.subscribe(
+    atom_io.subscribe(
       latestUpdateState,
       ({ newValue, oldValue }) => {
         const timelineId = store.timelineAtoms.getRelatedKey(
@@ -980,11 +998,11 @@ var Tracker = class {
         if (timelineId) {
           const timelineData = store.timelines.get(timelineId);
           if (timelineData == null ? void 0 : timelineData.timeTraveling) {
-            const unsubscribe2 = AtomIO__namespace.subscribeToTimeline(
+            const unsubscribe2 = atom_io.subscribeToTimeline(
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                AtomIO__namespace.setState(
+                atom_io.setState(
                   mutableState,
                   (transceiver) => {
                     if (update === `redo` && newValue) {
@@ -1006,7 +1024,7 @@ var Tracker = class {
           () => {
             unsubscribe();
             if (newValue) {
-              AtomIO__namespace.setState(
+              atom_io.setState(
                 mutableState,
                 (transceiver) => (transceiver.do(newValue), transceiver),
                 store
@@ -1030,7 +1048,7 @@ function createMutableAtom(options, store = IMPLICIT.STORE) {
   const coreState = createAtom(options, void 0, store);
   new Tracker(coreState, store);
   const jsonState = json.selectJson(coreState, options, store);
-  AtomIO__namespace.subscribe(
+  atom_io.subscribe(
     jsonState,
     () => {
       var _a2;
@@ -1118,7 +1136,7 @@ var openOperation = (token, store) => {
     (_a = store.config.logger) == null ? void 0 : _a.error(
       `\u274C failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
     );
-    throw Symbol(`violation`);
+    return `rejection`;
   }
   core.operation = {
     open: true,
@@ -1296,14 +1314,14 @@ var stowUpdate = (state, update, store) => {
   logger == null ? void 0 : logger.info(`\u{1F4DD} ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`);
 };
 
-// src/set-state/set-atom-state.ts
-var setAtomState = (atom, next, store = IMPLICIT.STORE) => {
+// src/set-state/set-atom.ts
+var setAtom = (atom, next, store = IMPLICIT.STORE) => {
   var _a, _b;
   const oldValue = getState__INTERNAL(atom, store);
   let newValue = copyMutableIfWithinTransaction(atom, store);
   newValue = become(next)(newValue);
   (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting atom "${atom.key}" to`, newValue);
-  cacheValue(atom.key, newValue, store);
+  cacheValue(atom.key, newValue, atom.subject, store);
   if (isAtomDefault(atom.key, store)) {
     markAtomAsNotDefault(atom.key, store);
   }
@@ -1320,22 +1338,12 @@ var setAtomState = (atom, next, store = IMPLICIT.STORE) => {
   }
 };
 
-// src/set-state/set-selector-state.ts
-var setSelectorState = (selector, next, store = IMPLICIT.STORE) => {
-  var _a, _b;
-  const oldValue = getState__INTERNAL(selector, store);
-  const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting selector "${selector.key}" to`, newValue);
-  (_b = store.config.logger) == null ? void 0 : _b.info(`   || propagating change made to "${selector.key}"`);
-  selector.set(newValue);
-};
-
 // src/set-state/set-state-internal.ts
 var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
-  if (`set` in state) {
-    setSelectorState(state, value, store);
+  if (state.type === `selector`) {
+    state.set(value);
   } else {
-    setAtomState(state, value, store);
+    setAtom(state, value, store);
   }
 };
 
@@ -1401,7 +1409,7 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
     const core = target(store);
     const alreadyRegistered = core.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
     const dependencyState = withdraw(dependency, store);
-    if (dependencyState === null) {
+    if (dependencyState === void 0) {
       throw new Error(
         `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
       );
@@ -1433,7 +1441,7 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
   },
   set: (stateToken, newValue) => {
     const state = withdraw(stateToken, store);
-    if (state === null) {
+    if (state === void 0) {
       throw new Error(
         `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
       );
@@ -1449,21 +1457,21 @@ var createReadWriteSelector = (options, family, store, core) => {
   const { get, set } = registerSelector(options.key, store);
   const getSelf = () => {
     const value = options.get({ get });
-    cacheValue(options.key, value, store);
+    cacheValue(options.key, value, subject, store);
     return value;
   };
   const setSelf = (next) => {
     var _a2;
     const oldValue = getSelf();
+    const newValue = become(next)(oldValue);
     (_a2 = store.config.logger) == null ? void 0 : _a2.info(
       `   <- "${options.key}" went (`,
       oldValue,
       `->`,
-      next,
+      newValue,
       `)`
     );
-    const newValue = become(next)(oldValue);
-    cacheValue(options.key, newValue, store);
+    cacheValue(options.key, newValue, subject, store);
     markDone(options.key, store);
     if (store.transactionStatus.phase === `idle`) {
       subject.next({ newValue, oldValue });
@@ -1498,7 +1506,7 @@ var createReadonlySelector = (options, family, store, core) => {
   const { get } = registerSelector(options.key, store);
   const getSelf = () => {
     const value = options.get({ get });
-    cacheValue(options.key, value, store);
+    cacheValue(options.key, value, subject, store);
     return value;
   };
   const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
@@ -1744,12 +1752,12 @@ function createAtom(options, family, store = IMPLICIT.STORE) {
   const initialValue = options.default instanceof Function ? options.default() : options.default;
   core.atoms.set(newAtom.key, newAtom);
   markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, store);
+  cacheValue(options.key, initialValue, subject, store);
   const token = deposit(newAtom);
   for (const effect of (_e = options.effects) != null ? _e : []) {
     effect({
-      setSelf: (next) => AtomIO.setState(token, next, store),
-      onSet: (handle) => AtomIO.subscribe(token, handle, `effect[${subject.subscribers.size}]`, store)
+      setSelf: (next) => atom_io.setState(token, next, store),
+      onSet: (handle) => atom_io.subscribe(token, handle, `effect[${subject.subscribers.size}]`, store)
     });
   }
   store.subject.atomCreation.next(token);
@@ -1782,7 +1790,7 @@ var recallState = (state, store = IMPLICIT.STORE) => {
 var subscribeToRootAtoms = (state, store) => {
   const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
     const atom = withdraw(atomToken, store);
-    if (atom === null) {
+    if (atom === void 0) {
       throw new Error(
         `Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
       );
@@ -1815,6 +1823,7 @@ var subscribeToRootAtoms = (state, store) => {
 };
 
 exports.FamilyTracker = FamilyTracker;
+exports.Future = Future;
 exports.IMPLICIT = IMPLICIT;
 exports.Store = Store;
 exports.Subject = Subject;