atom.io 0.18.0 → 0.18.2

package/internal/dist/index.cjs

@@ -504,27 +504,37 @@ function withdraw(token, store) {
     }
     target = target.child;
   }
+  throw new NotFoundError(token, store);
 }
 
 // internal/src/store/withdraw-new-family-member.ts
-function withdrawNewFamilyMember(token, store) {
-  if (token.family) {
-    store.logger.info(
-      `\u{1F46A}`,
-      token.type,
-      token.key,
-      `creating new family member in store "${store.config.name}"`
-    );
-    const target = newest(store);
-    const family = target.families.get(token.family.key);
-    if (family) {
-      const jsonSubKey = JSON.parse(token.family.subKey);
-      family(jsonSubKey);
-      const state = withdraw(token, store);
-      return state;
+function withdrawOrCreate(token, store) {
+  try {
+    const state = withdraw(token, store);
+    return state;
+  } catch (notFoundError) {
+    if (token.family) {
+      store.logger.info(
+        `\u{1F46A}`,
+        token.type,
+        token.key,
+        `creating new family member in store "${store.config.name}"`
+      );
+      const target = newest(store);
+      const family = target.families.get(token.family.key);
+      if (family) {
+        const jsonSubKey = JSON.parse(token.family.subKey);
+        family(jsonSubKey);
+        const state = withdraw(token, store);
+        return state;
+      }
+      throw new NotFoundError(
+        { key: token.family.key, type: `${token.type}_family` },
+        store
+      );
     }
+    throw notFoundError;
   }
-  return void 0;
 }
 
 // internal/src/future.ts
@@ -546,6 +556,24 @@ 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) {
+    if (originValue === void 0) {
+      return typeof atom.default === `function` ? atom.default() : atom.default;
+    }
+    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/caching.ts
 function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
@@ -572,7 +600,12 @@ function cacheValue(key, value, subject, target) {
   return value;
 }
 var readCachedValue = (token, target) => {
-  const value = target.valueMap.get(token.key);
+  let value = target.valueMap.get(token.key);
+  if (token.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    value = copiedValue;
+  }
   return value;
 };
 var evictCachedValue = (key, target) => {
@@ -614,10 +647,11 @@ function createRegularAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `atom` }, store);
+      const target2 = newest(store);
+      const atomAlreadyCreated = target2.atoms.has(fullKey);
       let token;
-      if (existing) {
-        token = deposit(existing);
+      if (atomAlreadyCreated) {
+        token = { type: `atom`, key: fullKey, family };
       } else {
         const individualOptions = {
           key: fullKey,
@@ -819,34 +853,33 @@ 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(
-    `\u{1F4E2}`,
-    state.type,
-    state.key,
-    `went (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `) subscribers:`,
-    state.subject.subscribers
-  );
+  switch (state.type) {
+    case `mutable_atom`:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `is now (`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+      break;
+    default:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `went (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+  }
   state.subject.next(update);
 };
 
@@ -947,14 +980,16 @@ var setAtom = (atom, next, target) => {
       stowUpdate(atom, update, target);
     } else if (atom.key.startsWith(`*`)) {
       const mutableKey = atom.key.slice(1);
-      target.atoms.get(mutableKey);
+      const mutableAtom = target.atoms.get(mutableKey);
       let transceiver = target.valueMap.get(mutableKey);
-      if (atom.type === `mutable_atom` && isChildStore(target)) {
+      if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
         const { parent } = target;
-        const copiedValue = copyMutableIfNeeded(atom, parent, target);
+        const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target);
         transceiver = copiedValue;
       }
-      transceiver.do(update.newValue);
+      const accepted = transceiver.do(update.newValue) === null;
+      if (accepted)
+        evictDownStream(mutableAtom, target);
     }
   }
 };
@@ -974,15 +1009,11 @@ 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);
-  }
+  const state = withdrawOrCreate(token, store);
   setAtomOrSelector(state, value, store);
   closeOperation(store);
 }
@@ -1067,14 +1098,8 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
-    var _a;
     const target = newest(store);
-    const dependencyState = (_a = withdraw(dependency, store)) != null ? _a : withdrawNewFamilyMember(dependency, store);
-    if (dependencyState === void 0) {
-      throw new Error(
-        `State "${dependency.key}" not found in store "${store.config.name}".`
-      );
-    }
+    const dependencyState = withdrawOrCreate(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
       `\u{1F50C}`,
@@ -1097,12 +1122,7 @@ var registerSelector = (selectorKey, store) => ({
     return dependencyValue;
   },
   set: (WritableToken, newValue) => {
-    const state = withdraw(WritableToken, store);
-    if (state === void 0) {
-      throw new Error(
-        `State "${WritableToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      );
-    }
+    const state = withdrawOrCreate(WritableToken, store);
     setAtomOrSelector(state, newValue, store);
   },
   find: (token, key) => findInStore(token, key, store)
@@ -1290,8 +1310,7 @@ var subscribeToRootAtoms = (selector, store) => {
 
 // internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
-  var _a;
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  const state = withdrawOrCreate(token, store);
   if (state === void 0) {
     throw new Error(
       `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
@@ -1326,11 +1345,6 @@ function subscribeToState(token, handleUpdate, key, store) {
 // internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, 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}".`
-    );
-  }
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
   return () => {
@@ -1347,11 +1361,6 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
 // internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, 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}".`
-    );
-  }
   store.logger.info(
     `\u{1F440}`,
     `transaction`,
@@ -1626,10 +1635,11 @@ function createMutableAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `mutable_atom` }, store);
+      const target2 = newest(store);
+      const atomAlreadyCreated = target2.atoms.has(fullKey);
       let token;
-      if (existing) {
-        token = deposit(existing);
+      if (atomAlreadyCreated) {
+        token = { type: `mutable_atom`, key: fullKey, family };
       } else {
         const individualOptions = {
           key: fullKey,
@@ -1829,6 +1839,10 @@ function deleteAtom(atomToken, store) {
   target.selectorAtoms.delete(key);
   target.atomsThatAreDefault.delete(key);
   target.timelineAtoms.delete(key);
+  if (atomToken.type === `mutable_atom`) {
+    const updateToken = getUpdateToken(atomToken);
+    deleteAtom(updateToken, store);
+  }
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
@@ -1848,11 +1862,7 @@ function getEnvironmentData(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);
-  }
+  const state = withdrawOrCreate(token, store);
   return readOrComputeValue(state, store);
 }
 
@@ -1860,7 +1870,11 @@ function getFromStore(token, store) {
 function ingestAtomUpdate(applying, atomUpdate, store) {
   const { key, newValue, oldValue } = atomUpdate;
   const value = applying === `newValue` ? newValue : oldValue;
-  setIntoStore({ key, type: `atom` }, value, store);
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(token, value, store);
 }
 
 // internal/src/ingest-updates/ingest-selector-update.ts
@@ -1920,16 +1934,11 @@ var LazyMap = class extends Map {
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
   let maybeAtom = withdraw(atomToken, store);
-  if ((maybeAtom == null ? void 0 : maybeAtom.type) === `mutable_atom`) {
+  if (maybeAtom.type === `mutable_atom`) {
     const updateToken = getUpdateToken(maybeAtom);
     maybeAtom = withdraw(updateToken, store);
   }
   const atom = maybeAtom;
-  if (atom === void 0) {
-    throw new Error(
-      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
-    );
-  }
   store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key });
   atom.subject.subscribe(`timeline`, (update) => {
     var _a, _b, _c, _d, _e, _f;
@@ -1961,15 +1970,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
         }
       }
       if (currentTransactionKey) {
-        const currentTransaction = withdraw(
-          { key: currentTransactionKey, type: `transaction` },
-          store
-        );
-        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}".`
-          );
-        }
+        const txToken = {
+          key: currentTransactionKey,
+          type: `transaction`
+        };
+        const currentTransaction = withdraw(txToken, store);
         if (tl.transactionKey !== currentTransactionKey) {
           if (tl.transactionKey) {
             store.logger.error(
@@ -2141,15 +2146,6 @@ function createTimeline(options, store, data) {
     if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
       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) => {
@@ -2162,26 +2158,8 @@ function createTimeline(options, store, data) {
       }
     } else {
       let atom = withdraw(tokenOrFamily, store);
-      if (atom === void 0) {
-        store.logger.error(
-          `\u274C`,
-          `timeline`,
-          options.key,
-          `Failed to add atom "${atomKey}" because it does not exist in the store`
-        );
-        continue;
-      }
       if (isMutable(atom)) {
         const updateAtom = withdraw(getUpdateToken(atom), store);
-        if (updateAtom === void 0) {
-          store.logger.error(
-            `\u274C`,
-            `timeline`,
-            options.key,
-            `Failed to add update atom "${atomKey}" because it does not exist in the store`
-          );
-          continue;
-        }
         atom = updateAtom;
         atomKey = atom.key;
       }
@@ -2328,7 +2306,6 @@ function setEpochNumberOfAction(transactionKey, newEpoch, store) {
   const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
   if (continuityKey !== void 0) {
     store.transactionMeta.epoch.set(continuityKey, newEpoch);
-    console.log(`epoch is now`, newEpoch);
   }
 }
 
@@ -2380,7 +2357,6 @@ var applyTransaction = (output, store) => {
   }
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (isRootStore(parent)) {
-    console.log(child.transactionMeta.update);
     setEpochNumberOfAction(
       child.transactionMeta.update.key,
       child.transactionMeta.update.epoch,
@@ -2607,6 +2583,6 @@ exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
 exports.traceSelectorAtoms = traceSelectorAtoms;
 exports.updateSelectorAtoms = updateSelectorAtoms;
 exports.withdraw = withdraw;
-exports.withdrawNewFamilyMember = withdrawNewFamilyMember;
+exports.withdrawOrCreate = withdrawOrCreate;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map