atom.io 0.39.1 → 0.40.1

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

@@ -23,12 +23,36 @@ export function setIntoStore<
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
-export function setIntoStore<T, New extends T>(
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+>(
+	store: Store,
+	...params:
+		| [
+				token: WritableFamilyToken<T, K>,
+				key: Key,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+		| [
+				token: WritableToken<T>,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+): void
+
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K>,
+				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [

package/src/internal/store/store.ts

@@ -30,6 +30,8 @@ import type { OperationProgress } from "../operation"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type {
+	ChildStore,
+	RootStore,
 	Transaction,
 	TransactionEpoch,
 	TransactionProgress,
@@ -39,8 +41,8 @@ import type { Fn } from "../utility-types"
 import { CircularBuffer } from "./circular-buffer"
 
 export class Store implements Lineage {
-	public parent: Store | null = null
-	public child: Store | null = null
+	public parent: ChildStore | RootStore | null = null
+	public child: ChildStore | null = null
 
 	public valueMap: Map<string, any> = new Map()
 	public defaults: Map<string, any> = new Map()
@@ -210,14 +212,14 @@ export class Store implements Lineage {
 				) {
 					continue
 				}
-				family.install(this)
+				family.install(this as RootStore)
 			}
 			const mutableHelpers = new Set<string>()
 			for (const [, atom] of store.atoms) {
 				if (mutableHelpers.has(atom.key)) {
 					continue
 				}
-				atom.install(this)
+				atom.install(this as RootStore)
 				if (atom.type === `mutable_atom`) {
 					const originalJsonToken = getJsonToken(store, atom)
 					const originalUpdateToken = getUpdateToken(atom)
@@ -226,19 +228,19 @@ export class Store implements Lineage {
 				}
 			}
 			for (const [, selector] of store.readonlySelectors) {
-				selector.install(this)
+				selector.install(this as RootStore)
 			}
 			for (const [, selector] of store.writableSelectors) {
 				if (mutableHelpers.has(selector.key)) {
 					continue
 				}
-				selector.install(this)
+				selector.install(this as RootStore)
 			}
 			for (const [, tx] of store.transactions) {
-				tx.install(this)
+				tx.install(this as RootStore)
 			}
 			for (const [, timeline] of store.timelines) {
-				timeline.install(this)
+				timeline.install(this as RootStore)
 			}
 		}
 	}
@@ -258,15 +260,15 @@ export type StoreEventCarrier = {
 }
 
 declare global {
-	var ATOM_IO_IMPLICIT_STORE: Store | undefined
+	var ATOM_IO_IMPLICIT_STORE: RootStore | undefined
 }
 
-export const IMPLICIT: { readonly STORE: Store } = {
-	get STORE(): Store {
+export const IMPLICIT: { readonly STORE: RootStore } = {
+	get STORE(): RootStore {
 		globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
 			name: `IMPLICIT_STORE`,
 			lifespan: `ephemeral`,
-		})
+		}) as RootStore
 		return globalThis.ATOM_IO_IMPLICIT_STORE
 	},
 }

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

@@ -4,13 +4,16 @@ import type {
 	AtomUpdateEvent,
 	StateCreationEvent,
 	StateDisposalEvent,
+	StateUpdate,
 	TimelineEvent,
 	TimelineManageable,
 	TimelineOptions,
+	TimelineSelectorUpdateEvent,
 	TimelineToken,
 	TransactionOutcomeEvent,
 	TransactionSubEvent,
 	TransactionToken,
+	WritablePureSelectorToken,
 } from "atom.io"
 
 import { reduceReference } from "../get-state/reduce-reference"
@@ -18,27 +21,24 @@ import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
 import { deposit, type Store, withdraw } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { isChildStore } from "../transaction"
 
 export type Timeline<ManagedAtom extends TimelineManageable> = {
 	type: `timeline`
 	key: string
 	at: number
-	shouldCapture?: (
-		update: TimelineEvent<ManagedAtom>,
-		timeline: Timeline<ManagedAtom>,
-	) => boolean
 	timeTraveling: `into_future` | `into_past` | null
 	history: TimelineEvent<ManagedAtom>[]
 	selectorTime: number | null
 	transactionKey: string | null
-	install: (store: Store) => void
+	install: (store: RootStore) => void
 	subject: Subject<TimelineEvent<ManagedAtom> | `redo` | `undo`>
 	subscriptions: Map<string, () => void>
 }
 
 export function createTimeline<ManagedAtom extends TimelineManageable>(
-	store: Store,
+	store: RootStore,
 	options: TimelineOptions<ManagedAtom>,
 	data?: Timeline<ManagedAtom>,
 ): TimelineToken<ManagedAtom> {
@@ -46,7 +46,6 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 		type: `timeline`,
 		key: options.key,
 		at: 0,
-
 		timeTraveling: null,
 		selectorTime: null,
 		transactionKey: null,
@@ -56,9 +55,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 		subject: new Subject(),
 		subscriptions: new Map(),
 	}
-	if (options.shouldCapture) {
-		tl.shouldCapture = options.shouldCapture
-	}
+
 	const timelineKey = options.key
 	const target = newest(store)
 	for (const initialTopic of options.scope) {
@@ -182,93 +179,32 @@ function addAtomToTimeline(
 					if (txUpdateInProgress) {
 						joinTransaction(store, tl, txUpdateInProgress)
 					} 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,
-								token: currentSelectorToken,
-								atomUpdates: [],
-							}
-							latestUpdate.atomUpdates.push({
-								type: `atom_update`,
-								token: atomToken,
-								update,
-								timestamp: Date.now(), // 👺 use store operation
-							})
-							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 "${currentSelectorToken.key}" with`,
-								latestUpdate.atomUpdates.map(
-									(atomUpdate) => atomUpdate.token.key,
-								),
-							)
-
-							tl.at = tl.history.length
-							tl.selectorTime = currentSelectorTime
-						} else {
-							if (latestUpdate?.type === `selector_update`) {
-								latestUpdate.atomUpdates.push({
-									type: `atom_update`,
-									token: atomToken,
-									update,
-									timestamp: Date.now(), // 👺 use store operation
-								})
-								store.logger.info(
-									`⌛`,
-									`timeline`,
-									tl.key,
-									`set selector_update "${currentSelectorToken.key}" to`,
-									latestUpdate?.atomUpdates.map(
-										(atomUpdate) => atomUpdate.token.key,
-									),
-								)
-							}
-						}
-						if (latestUpdate) {
-							const willCaptureSelectorUpdate =
-								tl.shouldCapture?.(latestUpdate, tl) ?? true
-							if (willCaptureSelectorUpdate) {
-								tl.subject.next(latestUpdate)
-							} else {
-								tl.history.pop()
-								tl.at = tl.history.length
-							}
-						}
+						buildSelectorUpdate(
+							store,
+							tl,
+							atomToken,
+							update,
+							currentSelectorToken,
+							currentSelectorTime,
+						)
 					} else {
 						const timestamp = Date.now()
 						tl.selectorTime = null
-						if (tl.at !== tl.history.length) {
-							tl.history.splice(tl.at)
-						}
-						const atomUpdate: AtomUpdateEvent<any> = {
+
+						const atomUpdate: AtomUpdateEvent<any> & TimelineEvent<any> = {
+							checkpoint: true,
 							type: `atom_update`,
 							token: deposit(atom),
 							update,
 							timestamp,
 						}
-						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)
-						}
+						addToHistory(tl, atomUpdate)
 					}
 				}
 			},
@@ -322,10 +258,6 @@ function joinTransaction(
 				unsubscribe()
 				tl.transactionKey = null
 				if (tl.timeTraveling === null && currentTxInstanceId) {
-					if (tl.at !== tl.history.length) {
-						tl.history.splice(tl.at)
-					}
-
 					// biome-ignore lint/style/noNonNullAssertion: we are in the context of this timeline
 					const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key)!
 
@@ -334,22 +266,96 @@ function joinTransaction(
 						timelineTopics,
 					)
 
-					const timelineTransactionUpdate: TransactionOutcomeEvent<
-						TransactionToken<any>
-					> = {
+					const timelineTransactionUpdate: TimelineEvent<any> &
+						TransactionOutcomeEvent<TransactionToken<any>> = {
+						checkpoint: true,
 						...transactionUpdate,
 						subEvents: subEventsFiltered,
 					}
-					const willCapture =
-						tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true
-					if (willCapture) {
-						tl.history.push(timelineTransactionUpdate)
-						tl.at = tl.history.length
-						tl.subject.next(timelineTransactionUpdate)
-					}
+
+					addToHistory(tl, timelineTransactionUpdate)
+				}
+			},
+		)
+	}
+}
+
+function buildSelectorUpdate(
+	store: Store,
+	tl: Timeline<any>,
+	atomToken: AtomToken<any>,
+	eventOrUpdate: StateCreationEvent<any> | StateUpdate<any>,
+	currentSelectorToken: WritablePureSelectorToken<any>,
+	currentSelectorTime: number,
+) {
+	let latestUpdate: TimelineEvent<any> | undefined = tl.history.at(-1)
+	if (currentSelectorTime !== tl.selectorTime) {
+		const selectorUpdate: TimelineEvent<any> & TimelineSelectorUpdateEvent<any> =
+			(latestUpdate = {
+				checkpoint: true,
+				type: `selector_update`,
+				timestamp: currentSelectorTime,
+				token: currentSelectorToken,
+				subEvents: [],
+			})
+		if (`type` in eventOrUpdate) {
+			latestUpdate.subEvents.push(eventOrUpdate)
+		} else {
+			latestUpdate.subEvents.push({
+				type: `atom_update`,
+				token: atomToken,
+				update: eventOrUpdate,
+				timestamp: Date.now(), // 👺 use store operation
+			})
+		}
+
+		addToHistory(tl, latestUpdate)
+		tl.selectorTime = currentSelectorTime
+
+		store.logger.info(
+			`⌛`,
+			`timeline`,
+			tl.key,
+			`got a selector_update "${currentSelectorToken.key}" with`,
+			latestUpdate.subEvents.map((event) => event.token.key),
+		)
+
+		const operation = store.operation
+		const unsub = store.on.operationClose.subscribe(
+			`timeline:${tl.key} (needs to gather nested selector creations)`,
+			() => {
+				unsub()
+				if (operation.open) {
+					selectorUpdate.subEvents = [
+						...operation.subEvents,
+						...selectorUpdate.subEvents,
+					]
 				}
 			},
 		)
+	} else {
+		if (latestUpdate?.type === `selector_update`) {
+			if (`type` in eventOrUpdate) {
+				latestUpdate.subEvents.push(eventOrUpdate)
+			} else {
+				latestUpdate.subEvents.push({
+					type: `atom_update`,
+					token: atomToken,
+					update: eventOrUpdate,
+					timestamp: Date.now(), // 👺 use store operation
+				})
+			}
+			store.logger.info(
+				`⌛`,
+				`timeline`,
+				tl.key,
+				`set selector_update "${currentSelectorToken.key}" to`,
+				latestUpdate?.subEvents.map((event) => event.token.key),
+			)
+		}
+	}
+	if (latestUpdate) {
+		tl.subject.next(latestUpdate)
 	}
 }
 
@@ -402,6 +408,16 @@ function handleStateLifecycleEvent(
 	event: StateCreationEvent<any> | StateDisposalEvent<any>,
 	tl: Timeline<any>,
 ): void {
+	const currentSelectorToken =
+		store.operation.open &&
+		store.operation.token.type === `writable_pure_selector`
+			? store.operation.token
+			: null
+	const currentSelectorTime =
+		store.operation.open &&
+		store.operation.token.type === `writable_pure_selector`
+			? store.operation.timestamp
+			: null
 	if (!tl.timeTraveling) {
 		const target = newest(store)
 		if (isChildStore(target)) {
@@ -410,10 +426,21 @@ function handleStateLifecycleEvent(
 			const txUpdateInProgress = target.on.transactionApplying.state
 			if (txUpdateInProgress) {
 				joinTransaction(store, tl, txUpdateInProgress.update)
+			} else if (
+				currentSelectorToken &&
+				currentSelectorTime &&
+				event.type === `state_creation`
+			) {
+				buildSelectorUpdate(
+					store,
+					tl,
+					event.token,
+					event,
+					currentSelectorToken,
+					currentSelectorTime,
+				)
 			} else {
-				tl.history.push(event)
-				tl.at = tl.history.length
-				tl.subject.next(event)
+				addToHistory(tl, event)
 			}
 		}
 	}
@@ -427,3 +454,12 @@ function handleStateLifecycleEvent(
 			break
 	}
 }
+
+function addToHistory(tl: Timeline<any>, event: TimelineEvent<any>): void {
+	if (tl.at !== tl.history.length) {
+		tl.history.splice(tl.at)
+	}
+	tl.history.push(event)
+	tl.at = tl.history.length
+	tl.subject.next(event)
+}

package/src/internal/timeline/time-travel.ts

@@ -1,4 +1,4 @@
-import type { TimelineToken } from "atom.io"
+import type { TimelineEvent, TimelineToken } from "atom.io"
 
 import {
 	ingestAtomUpdateEvent,
@@ -30,6 +30,7 @@ export const timeTravel = (
 		)
 		return
 	}
+
 	if (
 		(action === `redo` && timelineData.at === timelineData.history.length) ||
 		(action === `undo` && timelineData.at === 0)
@@ -46,46 +47,57 @@ export const timeTravel = (
 	}
 
 	timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`
-	if (action === `undo`) {
-		--timelineData.at
+	let nextIndex = timelineData.at
+	let events: TimelineEvent<any>[]
+	switch (action) {
+		case `undo`:
+			--nextIndex
+			while (
+				nextIndex !== 0 &&
+				timelineData.history[nextIndex].checkpoint !== true
+			) {
+				--nextIndex
+			}
+			events = timelineData.history.slice(nextIndex, timelineData.at).reverse()
+
+			break
+		case `redo`:
+			++nextIndex
+			events = timelineData.history.slice(timelineData.at, nextIndex)
 	}
+	timelineData.at = nextIndex
 
-	const event = timelineData.history[timelineData.at]
 	const applying = action === `redo` ? `newValue` : `oldValue`
 
-	switch (event.type) {
-		case `atom_update`: {
-			ingestAtomUpdateEvent(store, event, applying)
-			break
-		}
-		case `selector_update`: {
-			ingestSelectorUpdateEvent(store, event, applying)
-			break
-		}
-		case `transaction_outcome`: {
-			ingestTransactionOutcomeEvent(store, event, applying)
-			break
-		}
-		case `state_creation`: {
-			ingestCreationEvent(store, event, applying)
-			break
+	for (const event of events) {
+		switch (event.type) {
+			case `atom_update`: {
+				ingestAtomUpdateEvent(store, event, applying)
+				break
+			}
+			case `selector_update`: {
+				ingestSelectorUpdateEvent(store, event, applying)
+				break
+			}
+			case `transaction_outcome`: {
+				ingestTransactionOutcomeEvent(store, event, applying)
+				break
+			}
+			case `state_creation`: {
+				ingestCreationEvent(store, event, applying)
+				break
+			}
+			case `state_disposal`: {
+				ingestDisposalEvent(store, event, applying)
+				break
+			}
 		}
-		case `state_disposal`: {
-			ingestDisposalEvent(store, event, applying)
-			break
-		}
-		case `molecule_creation`:
-		case `molecule_disposal`:
-	}
-
-	if (action === `redo`) {
-		++timelineData.at
 	}
 
 	timelineData.subject.next(action)
 	timelineData.timeTraveling = null
 	store.logger.info(
-		`⏹️`,
+		`⏸️`,
 		`timeline`,
 		token.key,
 		`"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,

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

@@ -1,19 +1,7 @@
-import { newest } from "../lineage"
-import type { Store } from "../store"
-import { isChildStore } from "./is-root-store"
+import type { ChildStore } from "./is-root-store"
 
-export const abortTransaction = (store: Store): void => {
-	const target = newest(store)
-	if (!isChildStore(target)) {
-		store.logger.warn(
-			`🐞`,
-			`transaction`,
-			`???`,
-			`abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`,
-		)
-		return
-	}
-	store.logger.info(
+export const abortTransaction = (target: ChildStore): void => {
+	target.logger.info(
 		`🪂`,
 		`transaction`,
 		target.transactionMeta.update.token.key,

package/src/internal/transaction/act-upon-store.ts

@@ -1,6 +1,5 @@
 import type { TransactionToken } from "atom.io"
 
-import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import type { Fn } from "../utility-types"
@@ -12,9 +11,6 @@ export function actUponStore<F extends Fn>(
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	return (...parameters: Parameters<F>): ReturnType<F> => {
 		const tx = withdraw(store, token)
-		if (tx) {
-			return tx.run(parameters, id)
-		}
-		throw new NotFoundError(token, store)
+		return tx.run(parameters, id)
 	}
 }

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

@@ -1,30 +1,18 @@
 import { ingestTransactionOutcomeEvent } from "../events"
 import { newest } from "../lineage"
-import type { Store } from "../store"
 import { withdraw } from "../store"
 import type { Fn } from "../utility-types"
+import type { ChildStore } from "./is-root-store"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
 export function applyTransaction<F extends Fn>(
-	store: Store,
+	store: ChildStore,
 	output: ReturnType<F>,
 ): void {
 	const child = newest(store)
 	const { parent } = child
-	if (
-		parent === null ||
-		!isChildStore(child) ||
-		child.transactionMeta?.phase !== `building`
-	) {
-		store.logger.warn(
-			`🐞`,
-			`transaction`,
-			`???`,
-			`applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`,
-		)
-		return
-	}
+
 	child.transactionMeta.phase = `applying`
 	child.transactionMeta.update.output = output
 	parent.child = null
@@ -34,7 +22,7 @@ export function applyTransaction<F extends Fn>(
 		`🛄`,
 		`transaction`,
 		child.transactionMeta.update.token.key,
-		`Applying transaction with ${updates.length} updates:`,
+		`applying ${updates.length} subEvents:`,
 		updates,
 	)
 
@@ -55,7 +43,7 @@ export function applyTransaction<F extends Fn>(
 			`🛬`,
 			`transaction`,
 			child.transactionMeta.update.token.key,
-			`Finished applying transaction.`,
+			`applied`,
 		)
 	} else if (isChildStore(parent)) {
 		parent.transactionMeta.update.subEvents.push(child.transactionMeta.update)

package/src/internal/transaction/assign-transaction-to-continuity.ts

@@ -1,15 +1,10 @@
-import type { Store } from "../store"
-import { isRootStore } from "./is-root-store"
+import type { RootStore } from "./is-root-store"
 
 export function assignTransactionToContinuity(
-	store: Store,
+	store: RootStore,
 	continuityKey: string,
 	transactionKey: string,
 ): void {
-	const isRoot = isRootStore(store)
-	if (!isRoot) {
-		return
-	}
 	const { epoch, actionContinuities } = store.transactionMeta
 	actionContinuities.set(continuityKey, transactionKey)
 	if (!epoch.has(continuityKey)) {