atom.io 0.21.0 → 0.22.0

package/internal/src/mutable/tracker-family.ts

@@ -2,7 +2,7 @@ import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import { createRegularAtomFamily } from "../families"
+import { createRegularAtomFamily, seekInStore } from "../families"
 import type { Store } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
@@ -15,44 +15,46 @@ export class FamilyTracker<
 		? Signal
 		: never
 
-	public readonly findLatestUpdateState: RegularAtomFamily<
+	public readonly latestUpdateAtoms: RegularAtomFamily<
 		typeof this.Update | null,
 		FamilyMemberKey
 	>
-	public readonly findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>
+	public readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>
 
 	public constructor(
-		findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>,
+		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
 		store: Store,
 	) {
-		this.findLatestUpdateState = createRegularAtomFamily<
+		this.latestUpdateAtoms = createRegularAtomFamily<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
 			{
-				key: `*${findMutableState.key}`,
+				key: `*${mutableAtoms.key}`,
 				default: null,
 			},
 			store,
 		)
-		this.findMutableState = findMutableState
-		this.findMutableState.subject.subscribe(
+		this.mutableAtoms = mutableAtoms
+		this.mutableAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
 			(atomToken) => {
 				if (atomToken.family) {
 					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
-					this.findLatestUpdateState(key)
+					seekInStore(this.latestUpdateAtoms, key, store)
 					new Tracker<Core>(atomToken, store)
 				}
 			},
 		)
-		this.findLatestUpdateState.subject.subscribe(
+		this.latestUpdateAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
 			(atomToken) => {
 				if (atomToken.family) {
 					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = this.findMutableState(key)
-					new Tracker<Core>(mutableAtomToken, store)
+					const mutableAtomToken = seekInStore(this.mutableAtoms, key, store)
+					if (mutableAtomToken) {
+						new Tracker<Core>(mutableAtomToken, store)
+					}
 				}
 			},
 		)

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/not-found-error.ts

@@ -16,10 +16,18 @@ type AtomIOToken =
 	| TransactionToken<any>
 
 function prettyPrintTokenType(token: AtomIOToken) {
-	if (token.type === `readonly_selector`) {
-		return `Readonly Selector`
+	switch (token.type) {
+		case `atom_family`:
+			return `Atom Family`
+		case `readonly_selector`:
+			return `Readonly Selector`
+		case `readonly_selector_family`:
+			return `Readonly Selector Family`
+		case `selector_family`:
+			return `Selector Family`
+		default:
+			return capitalize(token.type)
 	}
-	return capitalize(token.type)
 }
 
 export class NotFoundError extends Error {

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/create-readonly-selector.ts

@@ -19,9 +19,9 @@ export const createReadonlySelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 
-	const { get, find } = registerSelector(options.key, target)
+	const { get, find, seek } = registerSelector(options.key, target)
 	const getSelf = () => {
-		const value = options.get({ get, find })
+		const value = options.get({ get, find, seek })
 		cacheValue(options.key, value, subject, newest(store))
 		return value
 	}

package/internal/src/selector/create-writable-selector.ts

@@ -22,8 +22,8 @@ export const createWritableSelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const transactors = registerSelector(options.key, target)
-	const { find, get } = transactors
-	const readonlyTransactors = { find, get }
+	const { find, get, seek } = transactors
+	const readonlyTransactors = { find, get, seek }
 
 	const getSelf = () => {
 		const value = options.get(readonlyTransactors)

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

@@ -9,30 +9,47 @@ export function disposeSelector(
 ): void {
 	const target = newest(store)
 	const { key } = selectorToken
-	switch (selectorToken.type) {
-		case `selector`:
-			target.selectors.delete(key)
-			break
-		case `readonly_selector`:
-			target.readonlySelectors.delete(key)
-			break
-	}
-	target.valueMap.delete(key)
-	target.selectorAtoms.delete(key)
-	const downstreamTokens = target.selectorGraph
-		.getRelationEntries({ upstreamSelectorKey: key })
-		.filter(([_, { source }]) => source === key)
-		.map(
-			([downstreamSelectorKey]) =>
-				target.selectors.get(downstreamSelectorKey) ??
-				target.readonlySelectors.get(downstreamSelectorKey),
+	const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key)
+	if (!selector) {
+		store.logger.error(
+			`❌`,
+			`selector`,
+			key,
+			`Tried to dispose selector, but it does not exist in the store.`,
+		)
+	} else if (!selector.family) {
+		store.logger.error(
+			`❌`,
+			`selector`,
+			key,
+			`Standalone selectors cannot be disposed.`,
 		)
-	for (const downstreamToken of downstreamTokens) {
-		if (downstreamToken) {
-			disposeSelector(downstreamToken, store)
+	} else {
+		switch (selectorToken.type) {
+			case `selector`:
+				target.selectors.delete(key)
+				break
+			case `readonly_selector`:
+				target.readonlySelectors.delete(key)
+				break
+		}
+		target.valueMap.delete(key)
+		target.selectorAtoms.delete(key)
+		const downstreamTokens = target.selectorGraph
+			.getRelationEntries({ upstreamSelectorKey: key })
+			.filter(([_, { source }]) => source === key)
+			.map(
+				([downstreamSelectorKey]) =>
+					target.selectors.get(downstreamSelectorKey) ??
+					target.readonlySelectors.get(downstreamSelectorKey),
+			)
+		for (const downstreamToken of downstreamTokens) {
+			if (downstreamToken) {
+				disposeSelector(downstreamToken, store)
+			}
 		}
+		target.selectorGraph.delete(key)
+		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
+		store.on.selectorDisposal.next(selectorToken)
 	}
-	target.selectorGraph.delete(key)
-	store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
-	store.on.selectorDisposal.next(selectorToken)
 }

package/internal/src/selector/register-selector.ts

@@ -1,11 +1,13 @@
-import type { findState, Transactors } from "atom.io"
+import type { Transactors } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 
-import { findInStore } from "../families"
+import { findInStore, seekInStore } from "../families"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
@@ -15,7 +17,7 @@ export const registerSelector = (
 	get: (dependency) => {
 		const target = newest(store)
 
-		const dependencyState = withdrawOrCreate(dependency, store)
+		const dependencyState = withdraw(dependency, store)
 		const dependencyValue = readOrComputeValue(dependencyState, store)
 
 		store.logger.info(
@@ -40,8 +42,9 @@ export const registerSelector = (
 		return dependencyValue
 	},
 	set: (WritableToken, newValue) => {
-		const state = withdrawOrCreate(WritableToken, store)
+		const state = withdraw(WritableToken, store)
 		setAtomOrSelector(state, newValue, store)
 	},
 	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
+	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
 })

package/internal/src/set-state/set-into-store.ts

@@ -2,7 +2,7 @@ import type { WritableToken } from "atom.io"
 
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
@@ -27,7 +27,7 @@ export function setIntoStore<T, New extends T>(
 		)
 		return
 	}
-	const state = withdrawOrCreate(token, store)
+	const state = withdraw(token, store)
 	setAtomOrSelector(state, value, store)
 	closeOperation(store)
 }

package/internal/src/store/index.ts

@@ -1,4 +1,3 @@
 export * from "./deposit"
 export * from "./store"
 export * from "./withdraw"
-export * from "./withdraw-new-family-member"

package/internal/src/store/store.ts

@@ -12,6 +12,7 @@ import type {
 	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
+import type { Molecule } from "atom.io/immortal"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
@@ -80,6 +81,9 @@ export class Store implements Lineage {
 		},
 	)
 
+	public molecules = new Map<string, Molecule<any>>()
+	public miscResources = new Map<string, Disposable>()
+
 	public on = {
 		atomCreation: new Subject<AtomToken<unknown>>(),
 		atomDisposal: new Subject<AtomToken<unknown>>(),
@@ -107,8 +111,10 @@ export class Store implements Lineage {
 
 	public config: {
 		name: string
+		lifespan: `ephemeral` | `immortal`
 	} = {
 		name: `IMPLICIT_STORE`,
+		lifespan: `ephemeral`,
 	}
 
 	public loggers: AtomIOLogger[] = [
@@ -126,7 +132,7 @@ export class Store implements Lineage {
 		},
 	}
 
-	public constructor(name: string, store: Store | null = null) {
+	public constructor(config: Store[`config`], store: Store | null = null) {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
@@ -141,7 +147,7 @@ export class Store implements Lineage {
 
 			this.config = {
 				...store?.config,
-				name,
+				...config,
 			}
 			for (const [, family] of store.families) {
 				family.install(this)
@@ -153,7 +159,7 @@ export class Store implements Lineage {
 				}
 				atom.install(this)
 				if (atom.type === `mutable_atom`) {
-					const originalJsonToken = getJsonToken(atom)
+					const originalJsonToken = getJsonToken(atom, store)
 					const originalUpdateToken = getUpdateToken(atom)
 					mutableHelpers.add(originalJsonToken.key)
 					mutableHelpers.add(originalUpdateToken.key)
@@ -182,13 +188,20 @@ export const IMPLICIT = {
 	STORE_INTERNAL: undefined as Store | undefined,
 	get STORE(): Store {
 		return (
-			this.STORE_INTERNAL ?? (this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`))
+			this.STORE_INTERNAL ??
+			(this.STORE_INTERNAL = new Store({
+				name: `IMPLICIT_STORE`,
+				lifespan: `ephemeral`,
+			}))
 		)
 	},
 }
 
 export const clearStore = (store: Store): void => {
 	const { config } = store
-	Object.assign(store, new Store(config.name))
+	for (const disposable of store.miscResources.values()) {
+		disposable[Symbol.dispose]()
+	}
+	Object.assign(store, new Store(config))
 	store.config = config
 }

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,7 +1,7 @@
-import type { ReadableToken, UpdateHandler } from "atom.io"
+import type { ReadableToken, StateUpdate, UpdateHandler } from "atom.io"
 
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
@@ -10,12 +10,25 @@ export function subscribeToState<T>(
 	key: string,
 	store: Store,
 ): () => void {
-	const state = withdrawOrCreate(token, store)
+	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 = withdraw(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)

package/internal/src/transaction/build-transaction.ts

@@ -1,9 +1,11 @@
-import type { findState, Func } from "atom.io"
+import type { Func } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
 import { arbitrary } from "../arbitrary"
-import { findInStore } from "../families"
+import { findInStore, seekInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { getFromStore } from "../get-state"
 import { LazyMap } from "../lazy-map"
@@ -43,6 +45,8 @@ export const buildTransaction = (
 		}),
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
+		molecules: new LazyMap(parent.molecules),
+		miscResources: new LazyMap(parent.miscResources),
 	}
 	const epoch = getEpochNumberOfAction(key, store)
 	const transactionMeta: TransactionProgress<Func> = {
@@ -63,6 +67,7 @@ export const buildTransaction = (
 			run: (token, identifier = arbitrary()) =>
 				actUponStore(token, identifier, child),
 			find: ((token, k) => findInStore(token, k, child)) as typeof findState,
+			seek: ((token, k) => seekInStore(token, k, child)) as typeof seekState,
 			env: () => getEnvironmentData(child),
 		},
 	}

package/introspection/dist/index.cjs

@@ -66,55 +66,45 @@ var attachAtomIndex = (store = Internal2.IMPLICIT.STORE) => {
       },
       effects: [
         ({ setSelf }) => {
-          const unsubscribeFromAtomCreation = store.on.atomCreation.subscribe(
-            `introspection`,
-            (atomToken) => {
-              if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-                return;
-              }
-              setSelf((self) => {
-                if (atomToken.family) {
-                  const { key: familyKey, subKey } = atomToken.family;
-                  let familyNode = self.get(familyKey);
-                  if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
-                    familyNode = {
-                      key: familyKey,
-                      familyMembers: /* @__PURE__ */ new Map()
-                    };
-                    self.set(familyKey, familyNode);
-                  }
-                  familyNode.familyMembers.set(subKey, atomToken);
-                } else {
-                  self.set(atomToken.key, atomToken);
-                }
-                return self;
-              });
+          store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
+            if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+              return;
             }
-          );
-          const unsubscribeFromAtomDisposal = store.on.atomDisposal.subscribe(
-            `introspection`,
-            (atomToken) => {
-              setSelf((self) => {
-                if (atomToken.family) {
-                  const { key: familyKey, subKey } = atomToken.family;
-                  const familyNode = self.get(familyKey);
-                  if (familyNode && `familyMembers` in familyNode) {
-                    familyNode.familyMembers.delete(subKey);
-                    if (familyNode.familyMembers.size === 0) {
-                      self.delete(familyKey);
-                    }
+            setSelf((self) => {
+              if (atomToken.family) {
+                const { key: familyKey, subKey } = atomToken.family;
+                let familyNode = self.get(familyKey);
+                if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
+                  familyNode = {
+                    key: familyKey,
+                    familyMembers: /* @__PURE__ */ new Map()
+                  };
+                  self.set(familyKey, familyNode);
+                }
+                familyNode.familyMembers.set(subKey, atomToken);
+              } else {
+                self.set(atomToken.key, atomToken);
+              }
+              return self;
+            });
+          });
+          store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
+            setSelf((self) => {
+              if (atomToken.family) {
+                const { key: familyKey, subKey } = atomToken.family;
+                const familyNode = self.get(familyKey);
+                if (familyNode && `familyMembers` in familyNode) {
+                  familyNode.familyMembers.delete(subKey);
+                  if (familyNode.familyMembers.size === 0) {
+                    self.delete(familyKey);
                   }
-                } else {
-                  self.delete(atomToken.key);
                 }
-                return self;
-              });
-            }
-          );
-          return () => {
-            unsubscribeFromAtomCreation();
-            unsubscribeFromAtomDisposal();
-          };
+              } else {
+                self.delete(atomToken.key);
+              }
+              return self;
+            });
+          });
         }
       ]
     },
@@ -159,7 +149,7 @@ var attachSelectorIndex = (store = Internal2.IMPLICIT.STORE) => {
       },
       effects: [
         ({ setSelf }) => {
-          const unsubscribeFromSelectorCreation = store.on.selectorCreation.subscribe(
+          store.on.selectorCreation.subscribe(
             `introspection`,
             (selectorToken) => {
               if (selectorToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
@@ -184,7 +174,7 @@ var attachSelectorIndex = (store = Internal2.IMPLICIT.STORE) => {
               });
             }
           );
-          const unsubscribeFromSelectorDisposal = store.on.selectorDisposal.subscribe(
+          store.on.selectorDisposal.subscribe(
             `introspection`,
             (selectorToken) => {
               setSelf((self) => {
@@ -204,10 +194,6 @@ var attachSelectorIndex = (store = Internal2.IMPLICIT.STORE) => {
               });
             }
           );
-          return () => {
-            unsubscribeFromSelectorCreation();
-            unsubscribeFromSelectorDisposal();
-          };
         }
       ]
     },
@@ -245,19 +231,7 @@ var attachTimelineFamily = (store = Internal2.IMPLICIT.STORE) => {
         ({ setSelf }) => {
           const tl = store.timelines.get(key);
           tl == null ? void 0 : tl.subject.subscribe(`introspection`, (_) => {
-            if (store.operation.open === true) {
-              const unsubscribe = store.on.operationClose.subscribe(
-                `introspection`,
-                (operationClose) => {
-                  if (operationClose.open === false) {
-                    unsubscribe();
-                    setSelf(__spreadValues({}, tl));
-                  }
-                }
-              );
-            } else {
-              setSelf(__spreadValues({}, tl));
-            }
+            setSelf(__spreadValues({}, tl));
           });
         }
       ]