atom.io 0.20.3 → 0.21.1

package/internal/dist/index.js

@@ -11,44 +11,30 @@ function arbitrary(random = Math.random) {
 // internal/src/future.ts
 var Future = class extends Promise {
   constructor(executor) {
-    let promise;
     let superResolve;
     let superReject;
     super((resolve, reject) => {
       superResolve = resolve;
       superReject = reject;
-      promise = executor instanceof Promise ? executor : new Promise(executor);
-      promise.then(
-        (value) => {
-          if (promise) {
-            this.pass(promise, value);
-          }
-        },
-        (reason) => {
-          if (promise) {
-            this.fail(promise, reason);
-          }
-        }
-      );
     });
-    this.destiny = promise;
     this.resolve = superResolve;
     this.reject = superReject;
+    this.use(executor instanceof Promise ? executor : new Promise(executor));
   }
   pass(promise, value) {
-    if (promise === this.destiny) {
+    if (promise === this.fate) {
       this.resolve(value);
     }
   }
   fail(promise, reason) {
-    if (promise === this.destiny) {
+    if (promise === this.fate) {
       this.reject(reason);
     }
   }
   use(value) {
     if (value instanceof Promise) {
       const promise = value;
-      this.destiny = promise;
+      this.fate = promise;
       promise.then(
         (resolved) => {
           this.pass(promise, resolved);
@@ -59,7 +45,7 @@ var Future = class extends Promise {
       );
     } else {
       this.resolve(value);
-      this.destiny = void 0;
+      this.fate = void 0;
     }
   }
 };
@@ -158,9 +144,11 @@ var Store = class {
     );
     this.on = {
       atomCreation: new Subject(),
+      atomDisposal: new Subject(),
       selectorCreation: new Subject(),
-      transactionCreation: new Subject(),
+      selectorDisposal: new Subject(),
       timelineCreation: new Subject(),
+      transactionCreation: new Subject(),
       transactionApplying: new StatefulSubject(
         null
       ),
@@ -942,8 +930,8 @@ function createStandaloneSelector(options, store) {
   return createReadonlySelector(options, void 0, store);
 }
 
-// internal/src/selector/delete-selector.ts
-function deleteSelector(selectorToken, store) {
+// internal/src/selector/dispose-selector.ts
+function disposeSelector(selectorToken, store) {
   const target = newest(store);
   const { key } = selectorToken;
   switch (selectorToken.type) {
@@ -964,20 +952,21 @@ function deleteSelector(selectorToken, store) {
   );
   for (const downstreamToken of downstreamTokens) {
     if (downstreamToken) {
-      deleteSelector(downstreamToken, store);
+      disposeSelector(downstreamToken, store);
     }
   }
   target.selectorGraph.delete(key);
   store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
+  store.on.selectorDisposal.next(selectorToken);
 }
 
 // internal/src/subscribe/recall-state.ts
 var recallState = (state, store) => {
   const target = newest(store);
-  if (!target.operation.open) {
-    return target.valueMap.get(state.key);
+  if (target.operation.open) {
+    return target.operation.prev.get(state.key);
   }
-  return target.operation.prev.get(state.key);
+  return target.valueMap.get(state.key);
 };
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
@@ -1026,11 +1015,24 @@ var subscribeToRootAtoms = (selector, store) => {
 
 // internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
+  function safelyHandleUpdate(update) {
+    if (store.operation.open) {
+      const unsubscribe2 = store.on.operationClose.subscribe(
+        `state subscription ${key}`,
+        () => {
+          unsubscribe2();
+          handleUpdate(update);
+        }
+      );
+    } else {
+      handleUpdate(update);
+    }
+  }
   const state = withdrawOrCreate(token, store);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
   const isSelector = state.type === `selector` || state.type === `readonly_selector`;
   let dependencyUnsubFunctions = null;
-  let updateHandler = handleUpdate;
+  let updateHandler = safelyHandleUpdate;
   if (isSelector) {
     dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
     updateHandler = (update) => {
@@ -1038,7 +1040,7 @@ function subscribeToState(token, handleUpdate, key, store) {
         dependencyUnsubFunctions.length = 0;
         dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
       }
-      handleUpdate(update);
+      safelyHandleUpdate(update);
     };
   }
   const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
@@ -1127,18 +1129,7 @@ var Tracker = class {
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
-        if (target.operation.open) {
-          const unsubscribe = target.on.operationClose.subscribe(
-            subscriptionKey,
-            () => {
-              unsubscribe();
-              setIntoStore(latestUpdateState, update, target);
-            }
-          );
-        } else {
-          setIntoStore(mutableState, (current) => current, target);
-          setIntoStore(latestUpdateState, update, target);
-        }
+        setIntoStore(latestUpdateState, update, target);
       }
     );
     this.unsubscribeFromState = subscribeToState(
@@ -1149,18 +1140,7 @@ var Tracker = class {
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (transceiverUpdate) => {
-              if (target.operation.open) {
-                const unsubscribe = target.on.operationClose.subscribe(
-                  subscriptionKey,
-                  () => {
-                    unsubscribe();
-                    setIntoStore(latestUpdateState, transceiverUpdate, target);
-                  }
-                );
-              } else {
-                setIntoStore(mutableState, (current) => current, target);
-                setIntoStore(latestUpdateState, transceiverUpdate, target);
-              }
+              setIntoStore(latestUpdateState, transceiverUpdate, target);
             }
           );
         }
@@ -1597,8 +1577,8 @@ function createStandaloneAtom(options, store) {
   return createRegularAtom(options, void 0, store);
 }
 
-// internal/src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
+// internal/src/atom/dispose-atom.ts
+function disposeAtom(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -1610,27 +1590,29 @@ function deleteAtom(atomToken, store) {
       key,
       `Tried to delete atom, but it does not exist in the store.`
     );
-  }
-  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
-  target.atoms.delete(key);
-  target.valueMap.delete(key);
-  const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
-  if (selectorKeys) {
-    for (const selectorKey of selectorKeys) {
-      const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
-      if (token) {
-        deleteSelector(token, store);
+  } else {
+    (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
+    target.atoms.delete(key);
+    target.valueMap.delete(key);
+    const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
+    if (selectorKeys) {
+      for (const selectorKey of selectorKeys) {
+        const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
+        if (token) {
+          disposeSelector(token, store);
+        }
       }
     }
+    target.selectorAtoms.delete(key);
+    target.atomsThatAreDefault.delete(key);
+    target.timelineAtoms.delete(key);
+    if (atomToken.type === `mutable_atom`) {
+      const updateToken = getUpdateToken(atomToken);
+      disposeAtom(updateToken, store);
+    }
+    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
+    store.on.atomDisposal.next(atomToken);
   }
-  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`);
 }
 
 // internal/src/get-environment-data.ts
@@ -2285,4 +2267,4 @@ function getEpochNumberOfAction(transactionKey, 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, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };

package/internal/src/atom/create-regular-atom.ts

@@ -16,7 +16,7 @@ import { subscribeToState } from "../subscribe"
 import { markAtomAsDefault } from "./is-default"
 
 export function createRegularAtom<T>(
-	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
+	options: RegularAtomOptions<T>,
 	family: FamilyMetadata | undefined,
 	store: Store,
 ): RegularAtomToken<T> {

package/internal/src/atom/dispose-atom.ts

@@ -0,0 +1,42 @@
+import type { AtomToken } from "atom.io"
+
+import type { Store } from ".."
+import { disposeSelector, getUpdateToken, newest } from ".."
+
+export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
+	const target = newest(store)
+	const { key } = atomToken
+	const atom = target.atoms.get(key)
+	if (!atom) {
+		store.logger.error(
+			`❌`,
+			`atom`,
+			key,
+			`Tried to delete atom, but it does not exist in the store.`,
+		)
+	} else {
+		atom.cleanup?.()
+		target.atoms.delete(key)
+		target.valueMap.delete(key)
+		const selectorKeys = target.selectorAtoms.getRelatedKeys(key)
+		if (selectorKeys) {
+			for (const selectorKey of selectorKeys) {
+				const token =
+					target.selectors.get(selectorKey) ??
+					target.readonlySelectors.get(selectorKey)
+				if (token) {
+					disposeSelector(token, store)
+				}
+			}
+		}
+		target.selectorAtoms.delete(key)
+		target.atomsThatAreDefault.delete(key)
+		target.timelineAtoms.delete(key)
+		if (atomToken.type === `mutable_atom`) {
+			const updateToken = getUpdateToken(atomToken)
+			disposeAtom(updateToken, store)
+		}
+		store.logger.info(`🔥`, `atom`, key, `deleted`)
+		store.on.atomDisposal.next(atomToken)
+	}
+}

package/internal/src/atom/index.ts

@@ -1,4 +1,4 @@
 export * from "./create-regular-atom"
 export * from "./create-standalone-atom"
-export * from "./delete-atom"
+export * from "./dispose-atom"
 export * from "./is-default"

package/internal/src/future.ts

@@ -8,7 +8,7 @@
  * Can be constructed like a Promise, or from an existing Promise.
  */
 export class Future<T> extends Promise<T> {
-	private destiny: Promise<T> | undefined
+	private fate: Promise<T> | undefined
 	private resolve: (value: T) => void
 	private reject: (reason?: any) => void
 
@@ -17,38 +17,24 @@ export class Future<T> extends Promise<T> {
 			| Promise<T>
 			| ((resolve: (value: T) => void, reject: (reason?: any) => void) => void),
 	) {
-		let promise: Promise<T> | undefined
 		let superResolve: ((value: T) => void) | undefined
 		let superReject: ((reason?: any) => void) | undefined
 		super((resolve, reject) => {
 			superResolve = resolve
 			superReject = reject
-			promise = executor instanceof Promise ? executor : new Promise(executor)
-			promise.then(
-				(value) => {
-					if (promise) {
-						this.pass(promise, value)
-					}
-				},
-				(reason) => {
-					if (promise) {
-						this.fail(promise, reason)
-					}
-				},
-			)
 		})
-		this.destiny = promise
 		this.resolve = superResolve as (value: T) => void
 		this.reject = superReject as (reason?: any) => void
+		this.use(executor instanceof Promise ? executor : new Promise(executor))
 	}
 
 	private pass(promise: Promise<T>, value: T) {
-		if (promise === this.destiny) {
+		if (promise === this.fate) {
 			this.resolve(value)
 		}
 	}
 	private fail(promise: Promise<T>, reason: any) {
-		if (promise === this.destiny) {
+		if (promise === this.fate) {
 			this.reject(reason)
 		}
 	}
@@ -56,7 +42,7 @@ export class Future<T> extends Promise<T> {
 	public use(value: Promise<T> | T): void {
 		if (value instanceof Promise) {
 			const promise = value
-			this.destiny = promise
+			this.fate = promise
 			promise.then(
 				(resolved) => {
 					this.pass(promise, resolved)
@@ -67,7 +53,7 @@ export class Future<T> extends Promise<T> {
 			)
 		} else {
 			this.resolve(value)
-			this.destiny = undefined
+			this.fate = undefined
 		}
 	}
 }

package/internal/src/get-state/get-from-store.ts

@@ -1,8 +1,7 @@
 import type { ReadableToken } from "atom.io"
 
-import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
-import { withdraw, withdrawOrCreate } from "../store"
+import { withdrawOrCreate } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
 export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {

package/internal/src/mutable/tracker.ts

@@ -66,18 +66,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
 			(update) => {
-				if (target.operation.open) {
-					const unsubscribe = target.on.operationClose.subscribe(
-						subscriptionKey,
-						() => {
-							unsubscribe()
-							setIntoStore(latestUpdateState, update, target)
-						},
-					)
-				} else {
-					setIntoStore(mutableState, (current) => current, target)
-					setIntoStore(latestUpdateState, update, target)
-				}
+				setIntoStore(latestUpdateState, update, target)
 			},
 		)
 		this.unsubscribeFromState = subscribeToState(
@@ -88,18 +77,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
 						(transceiverUpdate) => {
-							if (target.operation.open) {
-								const unsubscribe = target.on.operationClose.subscribe(
-									subscriptionKey,
-									() => {
-										unsubscribe()
-										setIntoStore(latestUpdateState, transceiverUpdate, target)
-									},
-								)
-							} else {
-								setIntoStore(mutableState, (current) => current, target)
-								setIntoStore(latestUpdateState, transceiverUpdate, target)
-							}
+							setIntoStore(latestUpdateState, transceiverUpdate, target)
 						},
 					)
 				}

package/internal/src/operation.ts

@@ -1,6 +1,5 @@
 import type { WritableToken } from "atom.io"
 
-import { newest } from "./lineage"
 import type { Store } from "./store"
 import { isChildStore } from "./transaction/is-root-store"
 

package/internal/src/selector/{delete-selector.ts → dispose-selector.ts}

@@ -3,7 +3,7 @@ import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 import type { Store } from ".."
 import { newest } from ".."
 
-export function deleteSelector(
+export function disposeSelector(
 	selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>,
 	store: Store,
 ): void {
@@ -29,9 +29,10 @@ export function deleteSelector(
 		)
 	for (const downstreamToken of downstreamTokens) {
 		if (downstreamToken) {
-			deleteSelector(downstreamToken, store)
+			disposeSelector(downstreamToken, store)
 		}
 	}
 	target.selectorGraph.delete(key)
 	store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
+	store.on.selectorDisposal.next(selectorToken)
 }

package/internal/src/selector/index.ts

@@ -1,7 +1,7 @@
 export * from "./create-readonly-selector"
 export * from "./create-standalone-selector"
 export * from "./create-writable-selector"
-export * from "./delete-selector"
+export * from "./dispose-selector"
 export * from "./get-selector-dependency-keys"
 export * from "./register-selector"
 export * from "./trace-selector-atoms"

package/internal/src/store/deposit.ts

@@ -1,4 +1,5 @@
 import type {
+	AtomToken,
 	Func,
 	MutableAtomToken,
 	ReadableToken,
@@ -11,10 +12,12 @@ import type {
 } from "atom.io"
 
 import type {
+	Atom,
 	MutableAtom,
 	ReadableState,
 	ReadonlySelector,
 	RegularAtom,
+	Selector,
 	Transceiver,
 	WritableSelector,
 	WritableState,
@@ -25,8 +28,10 @@ export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
 export function deposit<T extends Transceiver<any>>(
 	state: MutableAtom<T, any>,
 ): MutableAtomToken<T, any>
+export function deposit<T>(state: Atom<T>): AtomToken<T>
 export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
+export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
 export function deposit<T extends Func>(
 	state: Transaction<T>,

package/internal/src/store/store.ts

@@ -82,11 +82,15 @@ export class Store implements Lineage {
 
 	public on = {
 		atomCreation: new Subject<AtomToken<unknown>>(),
+		atomDisposal: new Subject<AtomToken<unknown>>(),
 		selectorCreation: new Subject<
 			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
 		>(),
-		transactionCreation: new Subject<TransactionToken<Func>>(),
+		selectorDisposal: new Subject<
+			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
+		>(),
 		timelineCreation: new Subject<TimelineToken<unknown>>(),
+		transactionCreation: new Subject<TransactionToken<Func>>(),
 		transactionApplying: new StatefulSubject<TransactionProgress<Func> | null>(
 			null,
 		),

package/internal/src/subscribe/recall-state.ts

@@ -4,8 +4,8 @@ import type { Store } from "../store"
 
 export const recallState = <T>(state: ReadableState<T>, store: Store): T => {
 	const target = newest(store)
-	if (!target.operation.open) {
-		return target.valueMap.get(state.key)
+	if (target.operation.open) {
+		return target.operation.prev.get(state.key)
 	}
-	return target.operation.prev.get(state.key)
+	return target.valueMap.get(state.key)
 }

package/internal/src/subscribe/subscribe-to-state.ts

@@ -1,4 +1,4 @@
-import type { ReadableToken, UpdateHandler } from "atom.io"
+import type { ReadableToken, StateUpdate, UpdateHandler } from "atom.io"
 
 import type { Store } from "../store"
 import { withdrawOrCreate } from "../store"
@@ -10,12 +10,25 @@ export function subscribeToState<T>(
 	key: string,
 	store: Store,
 ): () => void {
+	function safelyHandleUpdate(update: StateUpdate<any>): void {
+		if (store.operation.open) {
+			const unsubscribe = store.on.operationClose.subscribe(
+				`state subscription ${key}`,
+				() => {
+					unsubscribe()
+					handleUpdate(update)
+				},
+			)
+		} else {
+			handleUpdate(update)
+		}
+	}
 	const state = withdrawOrCreate(token, store)
 	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`)
 	const isSelector =
 		state.type === `selector` || state.type === `readonly_selector`
 	let dependencyUnsubFunctions: (() => void)[] | null = null
-	let updateHandler: UpdateHandler<T> = handleUpdate
+	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
 	if (isSelector) {
 		dependencyUnsubFunctions = subscribeToRootAtoms(state, store)
 		updateHandler = (update) => {
@@ -23,7 +36,7 @@ export function subscribeToState<T>(
 				dependencyUnsubFunctions.length = 0
 				dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store))
 			}
-			handleUpdate(update)
+			safelyHandleUpdate(update)
 		}
 	}
 	const mainUnsubFunction = state.subject.subscribe(key, updateHandler)