atom.io 0.14.1 → 0.14.3

package/dist/{chunk-TE3ZSTQ6.js → chunk-PURABO5G.js}

@@ -422,7 +422,8 @@ var Subject = class {
     this.subscribers.delete(key);
   }
   next(value) {
-    for (const subscriber of this.subscribers.values()) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
       subscriber(value);
     }
   }
@@ -1407,7 +1408,8 @@ var Tracker = class {
   }
   initializeState(mutableState, store) {
     const latestUpdateStateKey = `*${mutableState.key}`;
-    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
+    store.atoms.delete(latestUpdateStateKey);
+    store.valueMap.delete(latestUpdateStateKey);
     const familyMetaData = mutableState.family ? {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
@@ -1420,6 +1422,10 @@ var Tracker = class {
       familyMetaData,
       store
     );
+    if (store.parent) {
+      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+      store.valueMap.set(latestUpdateStateKey, parentValue);
+    }
     return latestUpdateState;
   }
   observeCore(mutableState, latestUpdateState, store) {
@@ -1500,7 +1506,7 @@ var Tracker = class {
           () => {
             unsubscribe();
             const mutable = getState(mutableState, store);
-            const updateNumber = mutable.getUpdateNumber(newValue);
+            const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
               setState(
@@ -1575,6 +1581,9 @@ function createAtomFamily(options, store) {
       subject
     }
   );
+  if (`mutable` in options && typeof options.mutable === `boolean`) {
+    Object.assign(atomFamily2, { mutable: options.mutable });
+  }
   const target = newest(store);
   target.families.set(options.key, atomFamily2);
   return atomFamily2;
@@ -1729,19 +1738,19 @@ var getUpdateToken = (mutableAtomToken) => {
   return updateToken;
 };
 
-// internal/src/mutable/is-atom-token-mutable.ts
-function isAtomTokenMutable(token) {
-  return token.key.endsWith(`::mutable`);
-}
+// internal/src/mutable/get-update-family.ts
+var getUpdateFamily = (mutableAtomFamily, store) => {
+  const target = newest(store);
+  const key = `*${mutableAtomFamily.key}`;
+  const updateFamily = target.families.get(key);
+  return updateFamily;
+};
 
 // internal/src/mutable/transceiver.ts
 function isTransceiver(value) {
   return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
 }
 
-// internal/src/mutable/index.ts
-var isAtomMutable = (atom2) => `isMutable` in atom2;
-
 // internal/src/atom/is-default.ts
 var isAtomDefault = (key, store) => {
   const core = newest(store);
@@ -1910,7 +1919,13 @@ var NotFoundError = class extends Error {
 
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
-  const atom2 = withdraw(atomToken, store);
+  let maybeAtom = withdraw(atomToken, store);
+  if (maybeAtom == null ? void 0 : maybeAtom.mutable) {
+    console.log(`adding transceiver to timeline`, atomToken.key);
+    const updateToken = getUpdateToken(atomToken);
+    maybeAtom = withdraw(updateToken, store);
+  }
+  const atom2 = maybeAtom;
   if (atom2 === void 0) {
     throw new Error(
       `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
@@ -2100,6 +2115,30 @@ var addAtomToTimeline = (atomToken, tl, store) => {
   });
 };
 
+// internal/src/mutable/is-mutable.ts
+function isMutable(atomOrTokenOrFamily, store) {
+  if (`mutable` in atomOrTokenOrFamily) {
+    return atomOrTokenOrFamily.mutable;
+  }
+  if (atomOrTokenOrFamily.type === `atom_family`) {
+    return false;
+  }
+  if (`default` in atomOrTokenOrFamily) {
+    return false;
+  }
+  if (!store) {
+    throw new Error(`Cannot check mutability without a store`);
+  }
+  const atom2 = withdraw(atomOrTokenOrFamily, store);
+  if (!atom2) {
+    throw new Error(`Cannot check mutability without an atom`);
+  }
+  if (`mutable` in atom2) {
+    return atom2.mutable;
+  }
+  return false;
+}
+
 // internal/src/timeline/create-timeline.ts
 function createTimeline(options, store, data) {
   var _a, _b;
@@ -2118,20 +2157,26 @@ function createTimeline(options, store, data) {
   if (options.shouldCapture) {
     tl.shouldCapture = options.shouldCapture;
   }
+  const timelineKey = options.key;
   const target = newest(store);
   for (const tokenOrFamily of options.atoms) {
-    const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key);
-    if (timelineKey) {
+    let atomKey = tokenOrFamily.key;
+    const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey);
+    if (existingTimelineKey) {
       store.logger.error(
         `\u274C`,
         `timeline`,
         options.key,
-        `Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`
+        `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
       );
       continue;
     }
     if (tokenOrFamily.type === `atom_family`) {
-      const family = tokenOrFamily;
+      let family = tokenOrFamily;
+      if (isMutable(family)) {
+        family = getUpdateFamily(family, store);
+        atomKey = family.key;
+      }
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
         addAtomToTimeline(token2, tl, store);
       });
@@ -2141,31 +2186,51 @@ function createTimeline(options, store, data) {
         }
       }
     } else {
-      const token2 = tokenOrFamily;
-      if (`family` in token2 && token2.family) {
+      let atom2 = withdraw(tokenOrFamily, store);
+      if (atom2 === 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(atom2)) {
+        const updateAtom = withdraw(getUpdateToken(atom2), 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;
+        }
+        atom2 = updateAtom;
+        atomKey = atom2.key;
+      }
+      if (`family` in atom2) {
         const familyTimelineKey = target.timelineAtoms.getRelatedKey(
-          token2.family.key
+          atom2.family.key
         );
         if (familyTimelineKey) {
           store.logger.error(
             `\u274C`,
             `timeline`,
             options.key,
-            `Failed to add atom "${token2.key}" because its family "${token2.family.key}" already belongs to timeline "${familyTimelineKey}"`
+            `Failed to add atom "${atom2.key}" because its family "${atom2.family.key}" already belongs to timeline "${familyTimelineKey}"`
           );
           continue;
         }
       }
-      addAtomToTimeline(token2, tl, store);
+      addAtomToTimeline(atom2, tl, store);
     }
-    target.timelineAtoms = target.timelineAtoms.set({
-      atomKey: tokenOrFamily.key,
-      timelineKey: options.key
-    });
+    target.timelineAtoms.set({ atomKey, timelineKey });
   }
   store.timelines.set(options.key, tl);
   const token = {
-    key: options.key,
+    key: timelineKey,
     type: `timeline`
   };
   store.subject.timelineCreation.next(token);
@@ -2511,6 +2576,6 @@ var selectJsonFamily = (atomFamily2, transform, store = IMPLICIT.STORE) => {
   return jsonFamily;
 };
 
-export { AtomIOLogger, FamilyTracker, Future, IMPLICIT, JSON_DEFAULTS, JSON_TYPE_NAMES, Junction, LOG_LEVELS, LazyMap, NotFoundError, Silo, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, __objRest, __restKey, __spreadProps, __spreadValues, abortTransaction, addAtomToTimeline, applyTransaction, atom, atomFamily, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, dispose, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getState, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isBoolean, isDone, isNull, isNumber, isPrimitive, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isString, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, parseJson, readCachedValue, readOrComputeValue, redo, redoTransactionUpdate, registerSelector, runTransaction, selectJson, selectJsonFamily, selector, selectorFamily, setAtomOrSelector, setState, simpleLog, simpleLogger, stringSetJsonInterface, stringifyJson, subscribe, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, timeline, traceAllSelectorAtoms, traceSelectorAtoms, transaction, undo, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { AtomIOLogger, FamilyTracker, Future, IMPLICIT, JSON_DEFAULTS, JSON_TYPE_NAMES, Junction, LOG_LEVELS, LazyMap, NotFoundError, Silo, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, __objRest, __restKey, __spreadProps, __spreadValues, abortTransaction, addAtomToTimeline, applyTransaction, atom, atomFamily, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, dispose, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getState, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isBoolean, isDone, isNull, isNumber, isPrimitive, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isString, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, parseJson, readCachedValue, readOrComputeValue, redo, redoTransactionUpdate, registerSelector, runTransaction, selectJson, selectJsonFamily, selector, selectorFamily, setAtomOrSelector, setState, simpleLog, simpleLogger, stringSetJsonInterface, stringifyJson, subscribe, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, timeline, traceAllSelectorAtoms, traceSelectorAtoms, transaction, undo, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-TE3ZSTQ6.js.map
+//# sourceMappingURL=chunk-PURABO5G.js.map