atom.io 0.15.0 → 0.15.2

package/internal/dist/index.cjs

@@ -77,6 +77,55 @@ var Future = class extends Promise {
   }
 };
 
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, transform, 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 = transform.toJson(originValue);
+    const copiedValue = transform.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 (`family` in atom) {
+      const family = parent.families.get(atom.family.key);
+      if (family && family.type === `atom_family`) {
+        const result = copyMutableFamilyMemberWithinTransaction(
+          atom,
+          family,
+          parent,
+          target
+        );
+        if (result) {
+          return result;
+        }
+      }
+    }
+    if (`toJson` in atom && `fromJson` in atom) {
+      const copiedValue = copyMutableIfNeeded(atom, atom, parent, target);
+      return copiedValue;
+    }
+  }
+  return oldValue;
+}
+function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target) {
+  if (`toJson` in family && `fromJson` in family) {
+    const copyCreated = copyMutableIfNeeded(atom, family, origin, target);
+    return copyCreated;
+  }
+  return null;
+}
+
 // internal/src/caching.ts
 function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
@@ -102,11 +151,12 @@ function cacheValue(key, value, subject, target) {
   target.valueMap.set(key, value);
   return value;
 }
-var readCachedValue = (key, target) => {
-  return target.valueMap.get(key);
-};
-var isValueCached = (key, target) => {
-  return target.valueMap.has(key);
+var readCachedValue = (token, target) => {
+  let value = target.valueMap.get(token.key);
+  if (token.type === `atom`) {
+    value = copyMutableIfWithinTransaction(value, token, target);
+  }
+  return value;
 };
 var evictCachedValue = (key, target) => {
   const currentValue = target.valueMap.get(key);
@@ -121,17 +171,17 @@ var evictCachedValue = (key, target) => {
 };
 
 // internal/src/read-or-compute-value.ts
-var readOrComputeValue = (state, store) => {
-  if (isValueCached(state.key, store)) {
-    store.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
-    return readCachedValue(state.key, store);
+var readOrComputeValue = (state, target) => {
+  if (target.valueMap.has(state.key)) {
+    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state, target);
   }
   if (state.type !== `atom`) {
-    store.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
     return state.get();
   }
   const fallback = state.default instanceof Function ? state.default() : state.default;
-  store.logger.info(
+  target.logger.info(
     `\u{1F481}`,
     `atom`,
     state.key,
@@ -239,55 +289,6 @@ var StatefulSubject = class extends Subject {
   }
 };
 
-// internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, transform, 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 = transform.toJson(originValue);
-    const copiedValue = transform.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 (`toJson` in atom && `fromJson` in atom) {
-      const copiedValue = copyMutableIfNeeded(atom, atom, parent, target);
-      return copiedValue;
-    }
-    if (`family` in atom) {
-      const family = parent.families.get(atom.family.key);
-      if (family && family.type === `atom_family`) {
-        const result = copyMutableFamilyMemberWithinTransaction(
-          atom,
-          family,
-          parent,
-          target
-        );
-        if (result) {
-          return result;
-        }
-      }
-    }
-  }
-  return oldValue;
-}
-function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target) {
-  if (`toJson` in family && `fromJson` in family) {
-    const copyCreated = copyMutableIfNeeded(atom, family, origin, target);
-    return copyCreated;
-  }
-  return null;
-}
-
 // internal/src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
   store.logger.info(
@@ -400,10 +401,13 @@ var setAtom = (atom, next, target) => {
 
 // internal/src/set-state/set-atom-or-selector.ts
 var setAtomOrSelector = (state, value, store) => {
-  if (state.type === `selector`) {
-    state.set(value);
-  } else {
-    setAtom(state, value, store);
+  switch (state.type) {
+    case `atom`:
+      setAtom(state, value, store);
+      break;
+    case `selector`:
+      state.set(value);
+      break;
   }
 };
 
@@ -1224,15 +1228,6 @@ var subscribeToTransaction = (token, handleUpdate, key, store) => {
   };
 };
 var Tracker = class {
-  constructor(mutableState, store) {
-    this.unsubscribeFromInnerValue = null;
-    this.mutableState = mutableState;
-    const target = newest(store);
-    this.latestUpdateState = this.initializeState(mutableState, target);
-    this.observeCore(mutableState, this.latestUpdateState, target);
-    this.updateCore(mutableState, this.latestUpdateState, target);
-    target.trackers.set(mutableState.key, this);
-  }
   initializeState(mutableState, store) {
     var _a;
     const latestUpdateStateKey = `*${mutableState.key}`;
@@ -1262,32 +1257,41 @@ var Tracker = class {
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
       (update) => {
-        const unsubscribe = target.subject.operationStatus.subscribe(
-          mutableState.key,
-          () => {
-            unsubscribe();
-            atom_io.setState(latestUpdateState, update, target);
-          }
-        );
+        if (target.operation.open) {
+          const unsubscribe = target.subject.operationStatus.subscribe(
+            mutableState.key,
+            () => {
+              unsubscribe();
+              atom_io.setState(latestUpdateState, update, target);
+            }
+          );
+        } else {
+          atom_io.setState(mutableState, (current) => current, target);
+          atom_io.setState(latestUpdateState, update, target);
+        }
       }
     );
-    subscribeToState(
+    this.unsubscribeFromState = subscribeToState(
       mutableState,
       (update) => {
-        var _a;
         if (update.newValue !== update.oldValue) {
-          (_a = this.unsubscribeFromInnerValue) == null ? void 0 : _a.call(this);
+          this.unsubscribeFromInnerValue();
           const target2 = newest(store);
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             `tracker:${store.config.name}:${target2.transactionMeta === null ? `main` : target2.transactionMeta.update.key}`,
             (update2) => {
-              const unsubscribe = store.subject.operationStatus.subscribe(
-                mutableState.key,
-                () => {
-                  unsubscribe();
-                  atom_io.setState(latestUpdateState, update2, store);
-                }
-              );
+              if (target2.operation.open) {
+                const unsubscribe = target2.subject.operationStatus.subscribe(
+                  mutableState.key,
+                  () => {
+                    unsubscribe();
+                    atom_io.setState(latestUpdateState, update2, target2);
+                  }
+                );
+              } else {
+                atom_io.setState(mutableState, (current) => current, target2);
+                atom_io.setState(latestUpdateState, update2, target2);
+              }
             }
           );
         }
@@ -1350,6 +1354,19 @@ var Tracker = class {
       store
     );
   }
+  constructor(mutableState, store) {
+    this.mutableState = mutableState;
+    const target = newest(store);
+    this.latestUpdateState = this.initializeState(mutableState, target);
+    this.observeCore(mutableState, this.latestUpdateState, target);
+    this.updateCore(mutableState, this.latestUpdateState, target);
+    target.trackers.set(mutableState.key, this);
+    this.dispose = () => {
+      this.unsubscribeFromInnerValue();
+      this.unsubscribeFromState();
+      target.trackers.delete(mutableState.key);
+    };
+  }
 };
 
 // internal/src/mutable/create-mutable-atom.ts
@@ -1434,7 +1451,7 @@ function createAtomFamily(options, store) {
 }
 function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
-  return Object.assign(
+  const readonlySelectorFamily = Object.assign(
     (key) => {
       const target = newest(store);
       const subKey = json.stringifyJson(key);
@@ -1460,6 +1477,8 @@ function createReadonlySelectorFamily(options, store) {
       install: (store2) => createReadonlySelectorFamily(options, store2)
     }
   );
+  store.families.set(options.key, readonlySelectorFamily);
+  return readonlySelectorFamily;
 }
 function createSelectorFamily(options, store) {
   const isReadonly = !(`set` in options);
@@ -2235,6 +2254,7 @@ var applyTransaction = (output, store) => {
       const atom = child.atoms.get(mutableKey);
       atom == null ? void 0 : atom.install(parent);
     }
+    tracker.dispose();
   }
   for (const atom of child.atoms.values()) {
     if (!parent.atoms.has(atom.key)) {
@@ -2275,11 +2295,12 @@ function getState2(token, store = Internal2__namespace.IMPLICIT.STORE) {
   return Internal2__namespace.readOrComputeValue(state, store);
 }
 function setState5(token, value, store = Internal2__namespace.IMPLICIT.STORE) {
+  var _a;
   const rejection = Internal2__namespace.openOperation(token, store);
   if (rejection) {
     return;
   }
-  const state = Internal2__namespace.withdraw(token, store);
+  const state = (_a = Internal2__namespace.withdraw(token, store)) != null ? _a : Internal2__namespace.withdrawNewFamilyMember(token, store);
   if (state === void 0) {
     throw new Internal2__namespace.NotFoundError(token, store);
   }
@@ -2426,7 +2447,6 @@ exports.isReadonlySelectorKey = isReadonlySelectorKey;
 exports.isSelectorKey = isSelectorKey;
 exports.isStateKey = isStateKey;
 exports.isTransceiver = isTransceiver;
-exports.isValueCached = isValueCached;
 exports.markAtomAsDefault = markAtomAsDefault;
 exports.markAtomAsNotDefault = markAtomAsNotDefault;
 exports.markDone = markDone;