atom.io 0.22.0 → 0.23.1

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

@@ -5,6 +5,7 @@ import type { seekState } from "atom.io/immortal"
 import { findInStore, seekInStore } from "../families"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
+import { getJsonToken } from "../mutable"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -47,4 +48,5 @@ export const registerSelector = (
 	},
 	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
 	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
+	json: (token) => getJsonToken(token, store),
 })

package/internal/src/set-state/stow-update.ts

@@ -38,7 +38,11 @@ export const stowUpdate = <T>(
 	if (!shouldStow) {
 		return
 	}
-	const atomUpdate: KeyedStateUpdate<T> = { key, ...update }
+	const atomUpdate: KeyedStateUpdate<T> = {
+		type: `atom_update`,
+		key,
+		...update,
+	}
 	if (state.family) {
 		atomUpdate.family = state.family
 	}

package/internal/src/store/deposit.ts

@@ -10,6 +10,13 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
+import type {
+	Molecule,
+	MoleculeFamily,
+	MoleculeFamilyToken,
+	MoleculeToken,
+} from "atom.io/immortal"
+import type { Json } from "atom.io/json"
 
 import type {
 	Atom,
@@ -33,28 +40,55 @@ 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<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+	P extends any[],
+>(state: Molecule<K>): MoleculeToken<K, S, P>
+export function deposit<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+	P extends any[],
+>(state: MoleculeFamily<K, S, P>): MoleculeFamilyToken<K, S, P>
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
 export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T>(
 	state:
+		| Molecule<any>
+		| MoleculeFamily<any, any, any>
+		| ReadableState<T>
 		| ReadonlySelector<T>
 		| RegularAtom<T>
 		| Transaction<T extends Func ? T : never>
 		| WritableSelector<T>
 		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
 ):
+	| MoleculeFamilyToken<any, any, any>
+	| MoleculeToken<any, any, any>
 	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
 	| RegularAtomToken<T>
 	| SelectorToken<T>
 	| TransactionToken<T extends Func ? T : never> {
-	const token = {
-		key: state.key,
-		type: state.type,
-	} as any
-	if (`family` in state) {
-		token.family = state.family
+	const { type } = state
+	switch (type) {
+		case `atom`:
+		case `molecule_family`:
+		case `mutable_atom`:
+		case `selector`:
+		case `readonly_selector`:
+		case `transaction`: {
+			const token = {
+				key: state.key,
+				type: state.type,
+			} as any
+			if (`family` in state) {
+				token.family = state.family
+			}
+			return token
+		}
+		case `molecule`:
+			return state.token
 	}
-	return token
 }

package/internal/src/store/store.ts

@@ -2,6 +2,8 @@ import type {
 	AtomToken,
 	Func,
 	Logger,
+	MoleculeCreation,
+	MoleculeDisposal,
 	MutableAtomFamily,
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
@@ -13,7 +15,12 @@ import type {
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
 import type { Molecule } from "atom.io/immortal"
+import type { Json } from "atom.io/json"
 
+import type {
+	MoleculeFamily,
+	MoleculeToken,
+} from "~/packages/atom.io/immortal/src/make-molecule"
 import { Junction } from "~/packages/rel8/junction/src"
 
 import type {
@@ -82,6 +89,7 @@ export class Store implements Lineage {
 	)
 
 	public molecules = new Map<string, Molecule<any>>()
+	public moleculeFamilies = new Map<string, MoleculeFamily<any, any, any>>()
 	public miscResources = new Map<string, Disposable>()
 
 	public on = {
@@ -99,6 +107,9 @@ export class Store implements Lineage {
 			null,
 		),
 		operationClose: new Subject<OperationProgress>(),
+		moleculeCreationStart: new Subject<MoleculeToken<any, any, any>>(),
+		moleculeCreationDone: new Subject<MoleculeToken<any, any, any>>(),
+		moleculeDisposal: new Subject<MoleculeToken<any, any, any>>(),
 	}
 	public operation: OperationProgress = { open: false }
 	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {

package/internal/src/store/withdraw.ts

@@ -24,7 +24,13 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type {
+	Molecule,
+	MoleculeFamily,
+	MoleculeFamilyToken,
+	MoleculeToken,
+} from "atom.io/immortal"
+import { type Json, stringifyJson } from "atom.io/json"
 
 import type {
 	Atom,
@@ -45,6 +51,8 @@ import type { Store } from "./store"
 export type Withdrawable =
 	| Atom<any>
 	| AtomFamily<any, any>
+	| Molecule<any>
+	| MoleculeFamily<any, any, any>
 	| MutableAtom<any, any>
 	| MutableAtomFamily<any, any, any>
 	| ReadableState<any>
@@ -116,6 +124,17 @@ export function withdraw<T, K extends Json.Serializable>(
 	store: Store,
 ): SelectorFamily<T, any>
 
+export function withdraw<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+	P extends any[],
+>(token: MoleculeToken<K, S, P>, store: Store): Molecule<K> & S
+export function withdraw<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+	P extends any[],
+>(token: MoleculeFamilyToken<K, S, P>, store: Store): MoleculeFamily<K, S, P>
+
 export function withdraw<T extends Func>(
 	token: TransactionToken<T>,
 	store: Store,
@@ -126,6 +145,8 @@ export function withdraw<T>(
 ): Timeline<T extends TimelineManageable ? T : never>
 export function withdraw<T>(
 	token:
+		| MoleculeFamilyToken<any, any, any>
+		| MoleculeToken<any, any, any>
 		| RegularAtomFamilyToken<T, any>
 		| RegularAtomToken<T>
 		| SelectorFamilyToken<T, any>
@@ -163,6 +184,12 @@ export function withdraw<T>(
 			case `transaction`:
 				withdrawn = target.transactions.get(token.key)
 				break
+			case `molecule`:
+				withdrawn = target.molecules.get(stringifyJson(token.key))
+				break
+			case `molecule_family`:
+				withdrawn = target.moleculeFamilies.get(token.key)
+				break
 		}
 		if (withdrawn) {
 			return withdrawn

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -29,213 +29,237 @@ export const addAtomToTimeline = (
 	const atom = maybeAtom
 	store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key })
 
-	atom.subject.subscribe(`timeline`, (update) => {
-		const target = newest(store)
-		const currentSelectorKey =
-			store.operation.open && store.operation.token.type === `selector`
-				? store.operation.token.key
-				: null
-		const currentSelectorTime =
-			store.operation.open && store.operation.token.type === `selector`
-				? store.operation.time
-				: null
-		const { transactionApplying } = target.on
-		const currentTransactionKey = transactionApplying.state?.update.key
-		const currentTransactionInstanceId = transactionApplying.state?.update.id
+	tl.subscriptions.set(
+		atom.key,
+		atom.subject.subscribe(`timeline`, (update) => {
+			const target = newest(store)
+			const currentSelectorKey =
+				store.operation.open && store.operation.token.type === `selector`
+					? store.operation.token.key
+					: null
+			const currentSelectorTime =
+				store.operation.open && store.operation.token.type === `selector`
+					? store.operation.time
+					: null
+			const { transactionApplying } = target.on
+			const currentTransactionKey = transactionApplying.state?.update.key
+			const currentTransactionInstanceId = transactionApplying.state?.update.id
 
-		store.logger.info(
-			`⏳`,
-			`timeline`,
-			tl.key,
-			`atom`,
-			atomToken.key,
-			`went`,
-			update.oldValue,
-			`->`,
-			update.newValue,
-			currentTransactionKey
-				? `in transaction "${currentTransactionKey}"`
-				: currentSelectorKey
-					? `in selector "${currentSelectorKey}"`
-					: ``,
-		)
-		if (tl.timeTraveling === null) {
-			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-				const mostRecentUpdate: TimelineUpdate<any> | undefined =
-					tl.history.at(-1)
-				if (mostRecentUpdate === undefined) {
-					throw new Error(
-						`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
-					)
-				}
-			}
-			if (currentTransactionKey) {
-				const txToken: TransactionToken<any> = {
-					key: currentTransactionKey,
-					type: `transaction`,
-				}
-				const currentTransaction = withdraw(txToken, store)
-				if (tl.transactionKey !== currentTransactionKey) {
-					if (tl.transactionKey) {
-						store.logger.error(
-							`🐞`,
-							`timeline`,
-							tl.key,
-							`unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`,
+			store.logger.info(
+				`⏳`,
+				`timeline`,
+				tl.key,
+				`atom`,
+				atomToken.key,
+				`went`,
+				update.oldValue,
+				`->`,
+				update.newValue,
+				currentTransactionKey
+					? `in transaction "${currentTransactionKey}"`
+					: currentSelectorKey
+						? `in selector "${currentSelectorKey}"`
+						: ``,
+			)
+			if (tl.timeTraveling === null) {
+				if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+					const mostRecentUpdate: TimelineUpdate<any> | undefined =
+						tl.history.at(-1)
+					if (mostRecentUpdate === undefined) {
+						throw new Error(
+							`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
 						)
 					}
-					tl.transactionKey = currentTransactionKey
-					const unsubscribe = currentTransaction.subject.subscribe(
-						`timeline:${tl.key}`,
-						(transactionUpdate) => {
-							unsubscribe()
-							if (tl.timeTraveling === null && currentTransactionInstanceId) {
-								if (tl.at !== tl.history.length) {
-									tl.history.splice(tl.at)
-								}
+				}
+				if (currentTransactionKey) {
+					const txToken: TransactionToken<any> = {
+						key: currentTransactionKey,
+						type: `transaction`,
+					}
+					const currentTransaction = withdraw(txToken, store)
+					if (tl.transactionKey !== currentTransactionKey) {
+						if (tl.transactionKey) {
+							store.logger.error(
+								`🐞`,
+								`timeline`,
+								tl.key,
+								`unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`,
+							)
+						}
+						tl.transactionKey = currentTransactionKey
+						const unsubscribe = currentTransaction.subject.subscribe(
+							`timeline:${tl.key}`,
+							(transactionUpdate) => {
+								unsubscribe()
+								if (tl.timeTraveling === null && currentTransactionInstanceId) {
+									if (tl.at !== tl.history.length) {
+										tl.history.splice(tl.at)
+									}
 
-								const filterUpdates = (
-									updates: TransactionUpdate<Func>[`updates`],
-								) =>
-									updates
-										.filter((updateFromTx) => {
-											const newestStore = newest(store)
-											if (`updates` in updateFromTx) {
-												return true
-											}
-											const atomOrFamilyKeys =
-												newestStore.timelineAtoms.getRelatedKeys(tl.key)
+									const filterUpdates = (
+										updates: TransactionUpdate<Func>[`updates`],
+									) =>
+										updates
+											.filter((updateFromTx) => {
+												const newestStore = newest(store)
+												if (`updates` in updateFromTx) {
+													return true
+												}
+												const atomOrFamilyKeys =
+													newestStore.timelineAtoms.getRelatedKeys(tl.key)
 
-											return atomOrFamilyKeys
-												? [...atomOrFamilyKeys].some(
-														(key) =>
-															key === updateFromTx.key ||
-															key === updateFromTx.family?.key,
-													)
-												: false
-										})
-										.map((updateFromTx) => {
-											if (`updates` in updateFromTx) {
-												return {
-													...updateFromTx,
-													updates: filterUpdates(updateFromTx.updates),
+												if (!atomOrFamilyKeys) {
+													return false
+												}
+												let key: string | undefined
+												let familyKey: string | undefined
+												switch (updateFromTx.type) {
+													case `state_creation`:
+													case `state_disposal`:
+														key = updateFromTx.token.key
+														familyKey = updateFromTx.token.family?.key
+														break
+													case `molecule_creation`:
+													case `molecule_disposal`:
+														break
+													default:
+														key = updateFromTx.key
+														familyKey = updateFromTx.family?.key
+														break
+												}
+												if (key === undefined) {
+													return false
+												}
+												if (atomOrFamilyKeys.has(key)) {
+													return true
+												}
+												if (familyKey !== undefined) {
+													return atomOrFamilyKeys.has(familyKey)
+												}
+												return false
+											})
+											.map((updateFromTx) => {
+												if (`updates` in updateFromTx) {
+													return {
+														...updateFromTx,
+														updates: filterUpdates(updateFromTx.updates),
+													}
 												}
-											}
-											return updateFromTx
-										})
+												return updateFromTx
+											})
 
-								const updates = filterUpdates(transactionUpdate.updates)
+									const updates = filterUpdates(transactionUpdate.updates)
 
-								const timelineTransactionUpdate: TimelineTransactionUpdate = {
-									type: `transaction_update`,
-									timestamp: Date.now(),
-									...transactionUpdate,
-									updates,
+									const timelineTransactionUpdate: TimelineTransactionUpdate = {
+										timestamp: Date.now(),
+										...transactionUpdate,
+										updates,
+									}
+									const willCapture =
+										tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true
+									if (willCapture) {
+										tl.history.push(timelineTransactionUpdate)
+										tl.at = tl.history.length
+										tl.subject.next(timelineTransactionUpdate)
+									}
 								}
-								const willCapture =
-									tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true
-								if (willCapture) {
-									tl.history.push(timelineTransactionUpdate)
-									tl.at = tl.history.length
-									tl.subject.next(timelineTransactionUpdate)
-								}
-							}
-							tl.transactionKey = null
+								tl.transactionKey = null
+								store.logger.info(
+									`⌛`,
+									`timeline`,
+									tl.key,
+									`got a transaction_update "${transactionUpdate.key}"`,
+								)
+							},
+						)
+					}
+				} else if (currentSelectorKey && currentSelectorTime) {
+					let latestUpdate: TimelineUpdate<any> | undefined = tl.history.at(-1)
+
+					if (currentSelectorTime !== tl.selectorTime) {
+						latestUpdate = {
+							type: `selector_update`,
+							timestamp: currentSelectorTime,
+							key: currentSelectorKey,
+							atomUpdates: [],
+						}
+						latestUpdate.atomUpdates.push({
+							key: atom.key,
+							type: `atom_update`,
+							...update,
+						})
+						if (tl.at !== tl.history.length) {
+							tl.history.splice(tl.at)
+						}
+
+						tl.history.push(latestUpdate)
+
+						store.logger.info(
+							`⌛`,
+							`timeline`,
+							tl.key,
+							`got a selector_update "${currentSelectorKey}" with`,
+							latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+						)
+
+						tl.at = tl.history.length
+						tl.selectorTime = currentSelectorTime
+					} else {
+						if (latestUpdate?.type === `selector_update`) {
+							latestUpdate.atomUpdates.push({
+								key: atom.key,
+								type: `atom_update`,
+								...update,
+							})
 							store.logger.info(
 								`⌛`,
 								`timeline`,
 								tl.key,
-								`got a transaction_update "${transactionUpdate.key}"`,
+								`set selector_update "${currentSelectorKey}" to`,
+								latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
 							)
-						},
-					)
-				}
-			} else if (currentSelectorKey && currentSelectorTime) {
-				let latestUpdate: TimelineUpdate<any> | undefined = tl.history.at(-1)
-
-				if (currentSelectorTime !== tl.selectorTime) {
-					latestUpdate = {
-						type: `selector_update`,
-						timestamp: currentSelectorTime,
-						key: currentSelectorKey,
-						atomUpdates: [],
+						}
 					}
-					latestUpdate.atomUpdates.push({
-						key: atom.key,
-						type: `atom_update`,
-						...update,
-					})
+					if (latestUpdate) {
+						const willCaptureSelectorUpdate =
+							tl.shouldCapture?.(latestUpdate, tl) ?? true
+						if (willCaptureSelectorUpdate) {
+							tl.subject.next(latestUpdate)
+						} else {
+							tl.history.pop()
+							tl.at = tl.history.length
+						}
+					}
+				} else {
+					const timestamp = Date.now()
+					tl.selectorTime = null
 					if (tl.at !== tl.history.length) {
 						tl.history.splice(tl.at)
 					}
-
-					tl.history.push(latestUpdate)
-
+					const atomUpdate: TimelineAtomUpdate<any> = {
+						type: `atom_update`,
+						timestamp,
+						key: atom.key,
+						oldValue: update.oldValue,
+						newValue: update.newValue,
+					}
+					if (atom.family) {
+						atomUpdate.family = atom.family
+					}
+					const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true
 					store.logger.info(
 						`⌛`,
 						`timeline`,
 						tl.key,
-						`got a selector_update "${currentSelectorKey}" with`,
-						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+						`got an atom_update to "${atom.key}"`,
 					)
-
-					tl.at = tl.history.length
-					tl.selectorTime = currentSelectorTime
-				} else {
-					if (latestUpdate?.type === `selector_update`) {
-						latestUpdate.atomUpdates.push({
-							key: atom.key,
-							type: `atom_update`,
-							...update,
-						})
-						store.logger.info(
-							`⌛`,
-							`timeline`,
-							tl.key,
-							`set selector_update "${currentSelectorKey}" to`,
-							latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
-						)
-					}
-				}
-				if (latestUpdate) {
-					const willCaptureSelectorUpdate =
-						tl.shouldCapture?.(latestUpdate, tl) ?? true
-					if (willCaptureSelectorUpdate) {
-						tl.subject.next(latestUpdate)
-					} else {
-						tl.history.pop()
+					if (willCapture) {
+						tl.history.push(atomUpdate)
 						tl.at = tl.history.length
+						tl.subject.next(atomUpdate)
 					}
 				}
-			} else {
-				const timestamp = Date.now()
-				tl.selectorTime = null
-				if (tl.at !== tl.history.length) {
-					tl.history.splice(tl.at)
-				}
-				const atomUpdate: TimelineAtomUpdate<any> = {
-					type: `atom_update`,
-					timestamp,
-					key: atom.key,
-					oldValue: update.oldValue,
-					newValue: update.newValue,
-				}
-				if (atom.family) {
-					atomUpdate.family = atom.family
-				}
-				const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true
-				store.logger.info(
-					`⌛`,
-					`timeline`,
-					tl.key,
-					`got an atom_update to "${atom.key}"`,
-				)
-				if (willCapture) {
-					tl.history.push(atomUpdate)
-					tl.at = tl.history.length
-					tl.subject.next(atomUpdate)
-				}
 			}
-		}
-	})
+		}),
+	)
 }