atom.io 0.15.1 → 0.15.2

package/internal/dist/index.d.ts

@@ -219,10 +219,12 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private Update;
     private initializeState;
     private unsubscribeFromInnerValue;
+    private unsubscribeFromState;
     private observeCore;
     private updateCore;
     mutableState: MutableAtomToken<Mutable, Json.Serializable>;
     latestUpdateState: AtomToken<typeof this.Update | null>;
+    dispose: () => void;
     constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
 }
 
@@ -381,8 +383,7 @@ declare class Future<T> extends Promise<T> {
 
 declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
 declare function cacheValue<T extends Promise<any>>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): Future<T>;
-declare const readCachedValue: <T>(key: string, target: Store) => T;
-declare const isValueCached: (key: string, target: Store) => boolean;
+declare const readCachedValue: <T>(token: StateNode<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
@@ -410,7 +411,7 @@ declare class NotFoundError extends Error {
     constructor(token: ReadonlySelectorToken<any> | StateToken<any>, store: Store);
 }
 
-declare const readOrComputeValue: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store: Store) => T;
+declare const readOrComputeValue: <T>(state: StateNode<T>, target: Store) => T;
 
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing: T) => T;
@@ -425,4 +426,6 @@ declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update:
 
 declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
 
-export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+type StateNode<T> = Atom<T> | ReadonlySelector<T> | Selector<T>;
+
+export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, type StateNode, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };

package/internal/dist/index.js

@@ -1,4 +1,4 @@
-import { getState as getState$1, setState as setState$1, runTransaction } from '../../dist/chunk-S7R5MU6A.js';
+import { getState as getState$1, setState as setState$1, runTransaction } from '../../dist/chunk-K22LR3V6.js';
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
 import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
@@ -38,6 +38,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);
@@ -63,11 +112,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);
@@ -82,17 +132,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,
@@ -200,55 +250,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(
@@ -361,10 +362,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;
   }
 };
 
@@ -925,15 +929,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}`;
@@ -963,32 +958,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();
-            setState(latestUpdateState, update, target);
-          }
-        );
+        if (target.operation.open) {
+          const unsubscribe = target.subject.operationStatus.subscribe(
+            mutableState.key,
+            () => {
+              unsubscribe();
+              setState(latestUpdateState, update, target);
+            }
+          );
+        } else {
+          setState(mutableState, (current) => current, target);
+          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();
-                  setState(latestUpdateState, update2, store);
-                }
-              );
+              if (target2.operation.open) {
+                const unsubscribe = target2.subject.operationStatus.subscribe(
+                  mutableState.key,
+                  () => {
+                    unsubscribe();
+                    setState(latestUpdateState, update2, target2);
+                  }
+                );
+              } else {
+                setState(mutableState, (current) => current, target2);
+                setState(latestUpdateState, update2, target2);
+              }
             }
           );
         }
@@ -1051,6 +1055,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
@@ -1938,6 +1955,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)) {
@@ -2054,6 +2072,6 @@ function createTransaction(options, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom2 as deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom2 as deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map