atom.io 0.36.3 → 0.37.1

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -1,40 +1,49 @@
-import type { Atom, WritableState } from ".."
+import type { Atom, OpenOperation, Store, WritableState } from ".."
 import { traceRootSelectorAtoms } from ".."
-import type { Store } from "../store"
+import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import { setAtom } from "./set-atom"
 
-function resetAtom(store: Store, state: Atom<any>) {
-	switch (state.type) {
+function resetAtom<T>(
+	target: Store & { operation: OpenOperation },
+	atom: Atom<T>,
+): [oldValue: T, newValue: T] {
+	switch (atom.type) {
 		case `mutable_atom`:
-			setAtom(store, state, new state.class())
-			return
+			return setAtom(target, atom, new atom.class())
 		case `atom`: {
-			let def = state.default
+			let def = atom.default
 			if (def instanceof Function) {
 				def = def()
 			}
-			setAtom(store, state, def)
+			return setAtom(target, atom, def)
 		}
 	}
 }
 
-export function resetAtomOrSelector(
-	store: Store,
-	state: WritableState<any>,
-): void {
+export function resetAtomOrSelector<T>(
+	target: Store & { operation: OpenOperation },
+	state: WritableState<T>,
+): [oldValue: T, newValue: T] {
+	let protoUpdate: [T, T]
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
-			resetAtom(store, state)
+			protoUpdate = resetAtom(target, state)
 			break
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
 			{
-				const atoms = traceRootSelectorAtoms(store, state.key)
+				const oldValue = state.getFrom(target)
+				const atoms = traceRootSelectorAtoms(target, state.key)
 				for (const atom of atoms.values()) {
-					resetAtom(store, atom)
+					const rootProtoUpdate = resetAtom(target, atom)
+					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false)
 				}
+				const newValue = state.getFrom(target)
+				protoUpdate = [oldValue, newValue]
 			}
 			break
 	}
+
+	return protoUpdate
 }

package/src/internal/set-state/set-atom-or-selector.ts

@@ -1,20 +1,25 @@
 import type { WritableState } from ".."
+import type { OpenOperation } from "../operation"
 import type { Store } from "../store"
 import { setAtom } from "./set-atom"
+import { setSelector } from "./set-selector"
 
 export const setAtomOrSelector = <T>(
-	store: Store,
+	target: Store & { operation: OpenOperation },
 	state: WritableState<T>,
 	value: T | ((oldValue: T) => T),
-): void => {
+): [oldValue: T, newValue: T] => {
+	let protoUpdate: [T, T]
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
-			setAtom(store, state, value)
+			protoUpdate = setAtom(target, state, value)
 			break
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
-			state.set(value)
+			protoUpdate = setSelector(target, state, value)
 			break
 	}
+
+	return protoUpdate
 }

package/src/internal/set-state/set-atom.ts

@@ -1,65 +1,20 @@
-import type { KeyedStateUpdate } from "atom.io"
-
-import type { Atom, MutableAtom, Store } from ".."
-import { hasRole } from "../atom/has-role"
+import type { Atom, OpenOperation, Store } from ".."
 import { writeToCache } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
-import { isTransceiver, type Transceiver } from "../mutable"
 import { markDone } from "../operation"
-import { isChildStore } from "../transaction/is-root-store"
 import { become } from "./become"
-import { emitUpdate } from "./emit-update"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 
 export const setAtom = <T>(
-	target: Store,
+	target: Store & { operation: OpenOperation<any> },
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
-): void => {
+): [oldValue: T, newValue: T] => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)
 	let newValue = become(next)(oldValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
 	newValue = writeToCache(target, atom, newValue)
 	markDone(target, atom.key)
 	evictDownstreamFromAtom(target, atom)
-	const update = { oldValue, newValue }
-	if (!isChildStore(target)) {
-		emitUpdate(target, atom, update)
-		return
-	}
-	if (target.on.transactionApplying.state === null) {
-		const { key } = atom
-		if (isTransceiver(update.newValue)) {
-			return
-		}
-		const atomUpdate: KeyedStateUpdate<T> = {
-			type: `atom_update`,
-			key,
-			...update,
-		}
-		if (atom.family) {
-			atomUpdate.family = atom.family
-		}
-		target.transactionMeta.update.updates.push(atomUpdate)
-		target.logger.info(
-			`📁`,
-			`atom`,
-			key,
-			`stowed (`,
-			update.oldValue,
-			`->`,
-			update.newValue,
-			`)`,
-		)
-	} else if (hasRole(atom, `tracker:signal`)) {
-		const key = atom.key.slice(1)
-		const mutable = target.atoms.get(key) as MutableAtom<
-			Transceiver<unknown, any, any>
-		>
-		const transceiver = readOrComputeValue(target, mutable, `mut`)
-		const accepted = transceiver.do(update.newValue) === null
-		if (accepted === true) {
-			evictDownstreamFromAtom(target, mutable)
-		}
-	}
+	return [oldValue, newValue]
 }

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

@@ -1,14 +1,9 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import { type Canonical, parseJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import { findInStore } from "../families"
-import { getFamilyOfToken } from "../families/get-family-of-token"
-import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
-import { withdraw } from "../store"
-import { resetAtomOrSelector } from "./reset-atom-or-selector"
-import { RESET_STATE } from "./reset-in-store"
-import { setAtomOrSelector } from "./set-atom-or-selector"
+import { operateOnStore } from "./operate-on-store"
+import type { RESET_STATE } from "./reset-in-store"
 
 export function setIntoStore<T, New extends T>(
 	store: Store,
@@ -16,10 +11,15 @@ export function setIntoStore<T, New extends T>(
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
-export function setIntoStore<T, K extends Canonical, New extends T>(
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
-	key: K,
+	key: Key,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
@@ -36,71 +36,5 @@ export function setIntoStore<T, New extends T>(
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {
-	let token: WritableToken<T>
-	let family: WritableFamilyToken<T, Canonical> | null
-	let key: Canonical | null
-	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
-	if (params.length === 2) {
-		token = params[0]
-		value = params[1]
-		if (token.family) {
-			// biome-ignore lint/style/noNonNullAssertion: this token belongs to a family
-			family = getFamilyOfToken(store, token)!
-			key = parseJson(token.family.subKey)
-			token = findInStore(store, family, key)
-		}
-	} else {
-		family = params[0]
-		key = params[1]
-		value = params[2]
-		token = findInStore(store, family, key)
-	}
-
-	const action = value === RESET_STATE ? `reset` : `set`
-
-	if (`counterfeit` in token && `family` in token) {
-		const subKey = token.family.subKey
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === subKey,
-		)
-		store.logger.error(
-			`❌`,
-			token.type,
-			token.key,
-			`could not be`,
-			action,
-			`because it was not found in the store "${store.config.name}".`,
-			disposal
-				? `This state was previously disposed:\n${disposal.trace}`
-				: `No previous disposal trace was found.`,
-		)
-		return
-	}
-
-	const rejectionTime = openOperation(store, token)
-	if (rejectionTime) {
-		const unsubscribe = store.on.operationClose.subscribe(
-			`waiting to ${action} "${token.key}" at T-${rejectionTime}`,
-			function waitUntilOperationCloseToSetState() {
-				unsubscribe()
-				store.logger.info(
-					`🟢`,
-					token.type,
-					token.key,
-					`resuming deferred`,
-					action,
-					`from T-${rejectionTime}`,
-				)
-				setIntoStore(store, token, value)
-			},
-		)
-		return
-	}
-	const state = withdraw(store, token)
-	if (value === RESET_STATE) {
-		resetAtomOrSelector(store, state)
-	} else {
-		setAtomOrSelector(store, state, value)
-	}
-	closeOperation(store)
+	operateOnStore(store, true, ...params)
 }

package/src/internal/set-state/set-selector.ts

@@ -0,0 +1,35 @@
+import type { WritableSelector } from ".."
+import { writeToCache } from "../caching"
+import { markDone, type OpenOperation } from "../operation"
+import type { Store } from "../store"
+import { become } from "./become"
+
+export function setSelector<T>(
+	target: Store & { operation: OpenOperation<any> },
+	selector: WritableSelector<T>,
+	next: T | ((oldValue: T) => T),
+): [oldValue: T, newValue: T] {
+	let oldValue: T
+	let newValue: T
+	let constant: T
+
+	const { type, key } = selector
+
+	switch (selector.type) {
+		case `writable_pure_selector`:
+			oldValue = selector.getFrom(target)
+			newValue = become(next)(oldValue)
+			writeToCache(target, selector, newValue)
+			break
+		case `writable_held_selector`:
+			constant = selector.const
+			become(next)(constant)
+			oldValue = constant
+			newValue = constant
+	}
+
+	target.logger.info(`📝`, type, key, `setting to`, newValue)
+	markDone(target, key)
+	selector.setSelf(newValue)
+	return [oldValue, newValue]
+}

package/src/internal/store/store.ts

@@ -1,8 +1,8 @@
 import type {
 	AtomToken,
 	Logger,
-	MoleculeCreation,
-	MoleculeDisposal,
+	MoleculeCreationEvent,
+	MoleculeDisposalEvent,
 	SelectorToken,
 	TimelineToken,
 	TransactionToken,
@@ -253,8 +253,8 @@ export type StoreEventCarrier = {
 	transactionCreation: Subject<TransactionToken<Fn>>
 	transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>
 	operationClose: Subject<OperationProgress>
-	moleculeCreation: Subject<MoleculeCreation>
-	moleculeDisposal: Subject<MoleculeDisposal>
+	moleculeCreation: Subject<MoleculeCreationEvent>
+	moleculeDisposal: Subject<MoleculeDisposalEvent>
 }
 
 declare global {

package/src/internal/subscribe/subscribe-in-store.ts

@@ -1,8 +1,8 @@
 import type {
 	ReadableToken,
+	TimelineEvent,
 	TimelineManageable,
 	TimelineToken,
-	TimelineUpdate,
 	TransactionToken,
 	TransactionUpdateHandler,
 	UpdateHandler,
@@ -30,7 +30,7 @@ export function subscribeInStore<F extends Fn>(
 export function subscribeInStore<M extends TimelineManageable>(
 	store: Store,
 	token: TimelineToken<M>,
-	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
+	handleUpdate: (update: TimelineEvent<M> | `redo` | `undo`) => void,
 	key?: string,
 ): () => void
 export function subscribeInStore<M extends TimelineManageable>(
@@ -39,7 +39,7 @@ export function subscribeInStore<M extends TimelineManageable>(
 	handleUpdate:
 		| TransactionUpdateHandler<any>
 		| UpdateHandler<any>
-		| ((update: TimelineUpdate<M> | `redo` | `undo`) => void),
+		| ((update: TimelineEvent<M> | `redo` | `undo`) => void),
 	key?: string,
 ): () => void
 export function subscribeInStore(

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

@@ -1,4 +1,4 @@
-import type { TimelineManageable, TimelineToken, TimelineUpdate } from "atom.io"
+import type { TimelineEvent, TimelineManageable, TimelineToken } from "atom.io"
 
 import type { Store } from "../store/store"
 import { withdraw } from "../store/withdraw"
@@ -7,7 +7,7 @@ export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
 	store: Store,
 	token: TimelineToken<ManagedAtom>,
 	key: string,
-	handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void,
+	handleUpdate: (update: TimelineEvent<any> | `redo` | `undo`) => void,
 ): (() => void) => {
 	const tl = withdraw(store, token)
 	store.logger.info(`👀`, `timeline`, token.key, `Adding subscription "${key}"`)

package/src/internal/timeline/create-timeline.ts

@@ -1,78 +1,38 @@
 import type {
 	AtomFamilyToken,
 	AtomToken,
-	FamilyMetadata,
-	MoleculeCreation,
-	MoleculeDisposal,
-	ReadableToken,
-	StateCreation,
-	StateDisposal,
-	StateUpdate,
+	AtomUpdateEvent,
+	StateCreationEvent,
+	StateDisposalEvent,
+	TimelineEvent,
 	TimelineManageable,
 	TimelineOptions,
 	TimelineToken,
-	TimelineUpdate,
-	TokenType,
+	TransactionOutcomeEvent,
+	TransactionSubEvent,
 	TransactionToken,
-	TransactionUpdate,
-	TransactionUpdateContent,
 } from "atom.io"
 
 import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
-import { type Store, withdraw } from "../store"
+import { deposit, type Store, withdraw } from "../store"
 import { Subject } from "../subject"
 import { isChildStore } from "../transaction"
-import type { Flat, Fn } from "../utility-types"
-
-export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<
-	StateUpdate<TokenType<ManagedAtom>> & {
-		key: string
-		type: `atom_update`
-		timestamp: number
-		family?: FamilyMetadata
-	}
->
-export type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
-	key: string
-	type: `selector_update`
-	timestamp: number
-	atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[]
-}
-export type TimelineTransactionUpdate = Flat<
-	TransactionUpdate<Fn> & {
-		key: string
-		type: `transaction_update`
-		timestamp: number
-	}
->
-export type TimelineStateCreation<T extends ReadableToken<any>> = Flat<
-	StateCreation<T> & { timestamp: number }
->
-export type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<
-	StateDisposal<T> & { timestamp: number }
->
-export type TimelineMoleculeCreation = Flat<
-	MoleculeCreation & { timestamp: number }
->
-export type TimelineMoleculeDisposal = Flat<
-	MoleculeDisposal & { timestamp: number }
->
 
 export type Timeline<ManagedAtom extends TimelineManageable> = {
 	type: `timeline`
 	key: string
 	at: number
 	shouldCapture?: (
-		update: TimelineUpdate<ManagedAtom>,
+		update: TimelineEvent<ManagedAtom>,
 		timeline: Timeline<ManagedAtom>,
 	) => boolean
 	timeTraveling: `into_future` | `into_past` | null
-	history: TimelineUpdate<ManagedAtom>[]
+	history: TimelineEvent<ManagedAtom>[]
 	selectorTime: number | null
 	transactionKey: string | null
 	install: (store: Store) => void
-	subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>
+	subject: Subject<TimelineEvent<ManagedAtom> | `redo` | `undo`>
 	subscriptions: Map<string, () => void>
 }
 
@@ -187,15 +147,15 @@ function addAtomToTimeline(
 			`timeline`,
 			function timelineCapturesAtomUpdate(update) {
 				const target = newest(store)
-				const currentSelectorKey =
+				const currentSelectorToken =
 					store.operation.open &&
 					store.operation.token.type === `writable_pure_selector`
-						? store.operation.token.key
+						? store.operation.token
 						: null
 				const currentSelectorTime =
 					store.operation.open &&
 					store.operation.token.type === `writable_pure_selector`
-						? store.operation.time
+						? store.operation.timestamp
 						: null
 
 				const txUpdateInProgress = target.on.transactionApplying.state?.update
@@ -211,28 +171,30 @@ function addAtomToTimeline(
 					`->`,
 					update.newValue,
 					txUpdateInProgress
-						? `in transaction "${txUpdateInProgress.key}"`
-						: currentSelectorKey
-							? `in selector "${currentSelectorKey}"`
+						? `in transaction "${txUpdateInProgress.token.key}"`
+						: currentSelectorToken
+							? `in selector "${currentSelectorToken.key}"`
 							: ``,
 				)
 				if (tl.timeTraveling === null) {
 					if (txUpdateInProgress) {
 						joinTransaction(store, tl, txUpdateInProgress)
-					} else if (currentSelectorKey && currentSelectorTime) {
-						let latestUpdate: TimelineUpdate<any> | undefined = tl.history.at(-1)
+					} else if (currentSelectorToken && currentSelectorTime) {
+						let latestUpdate: TimelineEvent<any> | undefined = tl.history.at(-1)
 
 						if (currentSelectorTime !== tl.selectorTime) {
 							latestUpdate = {
 								type: `selector_update`,
 								timestamp: currentSelectorTime,
-								key: currentSelectorKey,
+								// key: currentSelectorKey,
+								token: currentSelectorToken,
 								atomUpdates: [],
 							}
 							latestUpdate.atomUpdates.push({
-								key: atom.key,
 								type: `atom_update`,
-								...update,
+								token: atomToken,
+								update,
+								timestamp: Date.now(), // 👺 use store operation
 							})
 							if (tl.at !== tl.history.length) {
 								tl.history.splice(tl.at)
@@ -244,8 +206,10 @@ function addAtomToTimeline(
 								`⌛`,
 								`timeline`,
 								tl.key,
-								`got a selector_update "${currentSelectorKey}" with`,
-								latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+								`got a selector_update "${currentSelectorToken.key}" with`,
+								latestUpdate.atomUpdates.map(
+									(atomUpdate) => atomUpdate.token.key,
+								),
 							)
 
 							tl.at = tl.history.length
@@ -253,16 +217,19 @@ function addAtomToTimeline(
 						} else {
 							if (latestUpdate?.type === `selector_update`) {
 								latestUpdate.atomUpdates.push({
-									key: atom.key,
 									type: `atom_update`,
-									...update,
+									token: atomToken,
+									update,
+									timestamp: Date.now(), // 👺 use store operation
 								})
 								store.logger.info(
 									`⌛`,
 									`timeline`,
 									tl.key,
-									`set selector_update "${currentSelectorKey}" to`,
-									latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
+									`set selector_update "${currentSelectorToken.key}" to`,
+									latestUpdate?.atomUpdates.map(
+										(atomUpdate) => atomUpdate.token.key,
+									),
 								)
 							}
 						}
@@ -282,15 +249,11 @@ function addAtomToTimeline(
 						if (tl.at !== tl.history.length) {
 							tl.history.splice(tl.at)
 						}
-						const atomUpdate: TimelineAtomUpdate<any> = {
+						const atomUpdate: AtomUpdateEvent<any> = {
 							type: `atom_update`,
+							token: deposit(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(
@@ -340,9 +303,9 @@ function addAtomFamilyToTimeline(
 function joinTransaction(
 	store: Store,
 	tl: Timeline<any>,
-	txUpdateInProgress: TransactionUpdate<Fn>,
+	txUpdateInProgress: TransactionOutcomeEvent<TransactionToken<any>>,
 ) {
-	const currentTxKey = txUpdateInProgress.key
+	const currentTxKey = txUpdateInProgress.token.key
 	const currentTxInstanceId = txUpdateInProgress.id
 	const currentTxToken: TransactionToken<any> = {
 		key: currentTxKey,
@@ -364,15 +327,16 @@ function joinTransaction(
 					// biome-ignore lint/style/noNonNullAssertion: we are in the context of this timeline
 					const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key)!
 
-					const updates = filterTransactionUpdates(
-						transactionUpdate.updates,
+					const subEventsFiltered = filterTransactionSubEvents(
+						transactionUpdate.subEvents,
 						timelineTopics,
 					)
 
-					const timelineTransactionUpdate: TimelineTransactionUpdate = {
-						timestamp: Date.now(),
+					const timelineTransactionUpdate: TransactionOutcomeEvent<
+						TransactionToken<any>
+					> = {
 						...transactionUpdate,
-						updates,
+						subEvents: subEventsFiltered,
 					}
 					const willCapture =
 						tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true
@@ -387,19 +351,20 @@ function joinTransaction(
 	}
 }
 
-function filterTransactionUpdates(
-	updates: TransactionUpdateContent[],
+function filterTransactionSubEvents(
+	updates: TransactionSubEvent[],
 	timelineTopics: Set<string>,
-): TransactionUpdateContent[] {
+): TransactionSubEvent[] {
 	return updates
 		.filter((updateFromTx) => {
-			if (updateFromTx.type === `transaction_update`) {
+			if (updateFromTx.type === `transaction_outcome`) {
 				return true
 			}
 
 			let key: string
 			let familyKey: string | undefined
 			switch (updateFromTx.type) {
+				case `atom_update`:
 				case `state_creation`:
 				case `state_disposal`:
 					key = updateFromTx.token.key
@@ -409,11 +374,6 @@ function filterTransactionUpdates(
 				case `molecule_disposal`:
 				case `molecule_transfer`:
 					return true // always include
-				case `atom_update`:
-				case `selector_update`:
-					key = updateFromTx.key
-					familyKey = updateFromTx.family?.key
-					break
 			}
 			timelineTopics.has(key)
 			if (familyKey && timelineTopics.has(familyKey)) {
@@ -421,12 +381,12 @@ function filterTransactionUpdates(
 			}
 			return timelineTopics.has(key)
 		})
-		.map((updateFromTx) => {
-			if (`updates` in updateFromTx) {
+		.map((updateFromTx): TransactionSubEvent => {
+			if (`subEvents` in updateFromTx) {
 				return {
 					...updateFromTx,
-					updates: filterTransactionUpdates(
-						updateFromTx.updates,
+					subEvents: filterTransactionSubEvents(
+						updateFromTx.subEvents,
 						timelineTopics,
 					),
 				}
@@ -437,13 +397,9 @@ function filterTransactionUpdates(
 
 function handleStateLifecycleEvent(
 	store: Store,
-	event: StateCreation<any> | StateDisposal<any>,
+	event: StateCreationEvent<any> | StateDisposalEvent<any>,
 	tl: Timeline<any>,
 ): void {
-	const timestamp = Date.now()
-	const timelineEvent = Object.assign(event, {
-		timestamp,
-	}) as TimelineUpdate<any>
 	if (!tl.timeTraveling) {
 		const target = newest(store)
 		if (isChildStore(target)) {
@@ -453,9 +409,9 @@ function handleStateLifecycleEvent(
 			if (txUpdateInProgress) {
 				joinTransaction(store, tl, txUpdateInProgress.update)
 			} else {
-				tl.history.push(timelineEvent)
+				tl.history.push(event)
 				tl.at = tl.history.length
-				tl.subject.next(timelineEvent)
+				tl.subject.next(event)
 			}
 		}
 	}