atom.io 0.12.1 → 0.13.0

package/internal/src/set-state/copy-mutable-in-transaction.ts

@@ -1,7 +1,7 @@
 import type { AtomFamily } from "atom.io"
 import type { Json, JsonInterface } from "atom.io/json"
-import { readOrComputeValue } from ".."
-import type { Store, StoreCore } from ".."
+import { newest } from ".."
+import type { Store } from ".."
 import type { Atom } from "../atom"
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 
@@ -10,27 +10,21 @@ export function copyMutableIfWithinTransaction<T>(
 	atom: Atom<T> | (Atom<T> & JsonInterface<T, Json.Serializable>),
 	store: Store,
 ): T {
-	if (
-		store.transactionStatus.phase === `building` ||
-		store.transactionStatus.phase === `applying`
-	) {
+	const target = newest(store)
+	const parent = target.parent
+	if (parent !== null) {
 		if (`toJson` in atom && `fromJson` in atom) {
-			const copiedValue = copyMutableIfNeeded(
-				atom,
-				atom,
-				store,
-				store.transactionStatus.core,
-			)
+			const copiedValue = copyMutableIfNeeded(atom, atom, parent, target)
 			return copiedValue
 		}
 		if (`family` in atom) {
-			const family = store.transactionStatus.core.families.get(atom.family.key)
+			const family = parent.families.get(atom.family.key)
 			if (family && family.type === `atom_family`) {
 				const result = copyMutableFamilyMemberWithinTransaction<T>(
 					atom,
 					family,
-					store,
-					store.transactionStatus.core,
+					parent,
+					target,
 				)
 				if (result) {
 					return result
@@ -47,7 +41,7 @@ export function copyMutableFamilyMemberWithinTransaction<T>(
 		| AtomFamily<T, any>
 		| (AtomFamily<T, any> & JsonInterface<T, Json.Serializable>),
 	origin: Store,
-	target: StoreCore,
+	target: Store,
 ): T | null {
 	if (`toJson` in family && `fromJson` in family) {
 		const copyCreated = copyMutableIfNeeded(atom, family, origin, target)

package/internal/src/set-state/copy-mutable-into-new-store.ts

@@ -1,6 +1,6 @@
 import type { AtomFamily } from "atom.io"
 import type { Json, JsonInterface } from "atom.io/json"
-import type { Store, StoreCore } from ".."
+import type { Store } from ".."
 import type { Atom } from "../atom"
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 

package/internal/src/set-state/evict-downstream.ts

@@ -1,12 +1,12 @@
 import type { Atom } from "../atom"
 import { evictCachedValue } from "../caching"
+import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
-import { target } from "../transaction"
 
 export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
-	const core = target(store)
-	const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key)
+	const target = newest(store)
+	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key)
 	store.logger.info(
 		`🧹`,
 		atom.type,
@@ -17,12 +17,12 @@ export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
 		downstreamKeys ?? `to evict`,
 	)
 	if (downstreamKeys) {
-		if (core.operation.open) {
+		if (target.operation.open) {
 			store.logger.info(
 				`🧹`,
 				atom.type,
 				atom.key,
-				`[ ${[...core.operation.done].join(`, `)} ] already done`,
+				`[ ${[...target.operation.done].join(`, `)} ] already done`,
 			)
 		}
 		for (const key of downstreamKeys) {

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

@@ -1,6 +1,7 @@
 import type { Atom } from "../atom"
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
+import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
@@ -15,6 +16,7 @@ export const setAtom = <T>(
 	next: T | ((oldValue: T) => T),
 	store: Store,
 ): void => {
+	const target = newest(store)
 	const oldValue = readOrComputeValue(atom, store)
 	let newValue = copyMutableIfWithinTransaction(oldValue, atom, store)
 	newValue = become(next)(newValue)
@@ -26,7 +28,10 @@ export const setAtom = <T>(
 	markDone(atom.key, store)
 	evictDownStream(atom, store)
 	const update = { oldValue, newValue }
-	if (store.transactionStatus.phase !== `building`) {
+	if (
+		target.transactionMeta === null ||
+		target.transactionMeta.phase === `applying`
+	) {
 		emitUpdate(atom, update, store)
 	} else {
 		stowUpdate(atom, update, store)

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

@@ -1,6 +1,7 @@
 import type { KeyedStateUpdate, StateUpdate } from "atom.io"
 
 import type { Atom } from "../atom"
+import { newest } from "../lineage"
 import { isTransceiver } from "../mutable"
 import type { Store } from "../store"
 
@@ -22,7 +23,11 @@ export const stowUpdate = <T>(
 	store: Store,
 ): void => {
 	const { key } = state
-	if (store.transactionStatus.phase !== `building`) {
+	const target = newest(store)
+	if (
+		target.transactionMeta === null ||
+		target.transactionMeta.phase !== `building`
+	) {
 		store.logger.error(
 			`🐞`,
 			`atom`,
@@ -39,7 +44,7 @@ export const stowUpdate = <T>(
 	if (state.family) {
 		atomUpdate.family = state.family
 	}
-	store.transactionStatus.atomUpdates.push(atomUpdate)
+	target.transactionMeta.update.updates.push(atomUpdate)
 	store.logger.info(
 		`📁`,
 		`atom`,

package/internal/src/store/store.ts

@@ -1,4 +1,4 @@
-import { AtomIOLogger, simpleLogger } from "atom.io"
+import { AtomIOLogger } from "atom.io"
 import type {
 	AtomFamily,
 	AtomToken,
@@ -15,31 +15,35 @@ import type {
 import { Junction } from "~/packages/rel8/junction/src"
 
 import type { Atom } from "../atom"
+import type { Lineage } from "../lineage"
 import type { MutableAtom, Tracker, Transceiver } from "../mutable"
 import type { OperationProgress } from "../operation"
 import type { ReadonlySelector, Selector } from "../selector"
-import { Subject } from "../subject"
+import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
-import type { Transaction, TransactionStatus } from "../transaction"
-
-export type StoreCore = Pick<
-	Store,
-	| `atoms`
-	| `atomsThatAreDefault`
-	| `families`
-	| `operation`
-	| `readonlySelectors`
-	| `selectorAtoms`
-	| `selectorGraph`
-	| `selectors`
-	| `timelineAtoms`
-	| `timelines`
-	| `trackers`
-	| `transactions`
-	| `valueMap`
->
-
-export class Store {
+import type { Transaction, TransactionMeta } from "../transaction"
+
+// export type StoreCore = Pick<
+// 	Store,
+// 	| `atoms`
+// 	| `atomsThatAreDefault`
+// 	| `families`
+// 	| `operation`
+// 	| `readonlySelectors`
+// 	| `selectorAtoms`
+// 	| `selectorGraph`
+// 	| `selectors`
+// 	| `timelineAtoms`
+// 	| `timelines`
+// 	| `trackers`
+// 	| `transactions`
+// 	| `valueMap`
+// >
+
+export class Store implements Lineage {
+	public parent: Store | null = null
+	public child: Store | null = null
+
 	public valueMap = new Map<string, any>()
 
 	public atoms = new Map<string, Atom<any> | MutableAtom<any>>()
@@ -88,10 +92,11 @@ export class Store {
 		>(),
 		transactionCreation: new Subject<TransactionToken<ƒn>>(),
 		timelineCreation: new Subject<TimelineToken>(),
+		transactionApplying: new StatefulSubject<TransactionMeta<ƒn> | null>(null),
 		operationStatus: new Subject<OperationProgress>(),
 	}
 	public operation: OperationProgress = { open: false }
-	public transactionStatus: TransactionStatus<ƒn> = { phase: `idle` }
+	public transactionMeta: TransactionMeta<ƒn> | null = null
 
 	public config: {
 		name: string
@@ -118,7 +123,9 @@ export class Store {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
-			this.transactionStatus = { ...store?.transactionStatus }
+			this.transactionMeta = store?.transactionMeta
+				? { ...store?.transactionMeta }
+				: null
 			this.config = {
 				...store?.config,
 				name,

package/internal/src/store/withdraw-new-family-member.ts

@@ -5,8 +5,7 @@ import type {
 	StateToken,
 } from "atom.io"
 import type { Atom, ReadonlySelector, Selector, Store } from ".."
-import { withdraw } from ".."
-import { target } from "../transaction"
+import { newest, withdraw } from ".."
 
 export function withdrawNewFamilyMember<T>(
 	token: AtomToken<T>,
@@ -43,8 +42,8 @@ export function withdrawNewFamilyMember<T>(
 			token.key,
 			`creating new family member in store "${store.config.name}"`,
 		)
-		const core = target(store)
-		const family = core.families.get(token.family.key)
+		const target = newest(store)
+		const family = target.families.get(token.family.key)
 		if (family) {
 			const jsonSubKey = JSON.parse(token.family.subKey)
 			family(jsonSubKey)

package/internal/src/store/withdraw.ts

@@ -9,11 +9,10 @@ import type {
 } from "atom.io"
 
 import type { Atom } from "../atom"
+import { newest } from "../lineage"
 import type { ReadonlySelector, Selector } from "../selector"
-import { addAtomToTimeline } from "../timeline"
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
-import { target } from "../transaction"
 import type { Store } from "./store"
 
 export function withdraw<T>(
@@ -58,67 +57,67 @@ export function withdraw<T>(
 	| Timeline
 	| Transaction<T extends ƒn ? T : never>
 	| undefined {
-	let core = target(store)
-	let state =
-		core.atoms.get(token.key) ??
-		core.selectors.get(token.key) ??
-		core.readonlySelectors.get(token.key) ??
-		core.transactions.get(token.key) ??
-		core.timelines.get(token.key)
+	const target = newest(store)
+	const state =
+		target.atoms.get(token.key) ??
+		target.selectors.get(token.key) ??
+		target.readonlySelectors.get(token.key) ??
+		target.transactions.get(token.key) ??
+		target.timelines.get(token.key)
 	if (state) {
 		return state
 	}
-	if (store.transactionStatus.phase === `applying`) {
-		core = store.transactionStatus.core
-		state =
-			core.atoms.get(token.key) ??
-			core.selectors.get(token.key) ??
-			core.readonlySelectors.get(token.key) ??
-			core.transactions.get(token.key) ??
-			core.timelines.get(token.key)
+	// if (target.transactionMeta?.phase === `applying`) {
 
-		if (state) {
-			store.logger.info(
-				`🛠️`,
-				token.type,
-				token.key,
-				`add ${token.type} "${token.key}"`,
-			)
-			switch (state.type) {
-				case `atom`: {
-					store.atoms.set(token.key, state)
-					store.valueMap.set(token.key, state.default)
-					const stateKey = state.key
-					const familyKey = state.family?.key
-					let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
-					if (timelineKey === undefined && typeof familyKey === `string`) {
-						timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
-					}
-					const timeline =
-						typeof timelineKey === `string`
-							? store.timelines.get(timelineKey)
-							: undefined
+	// 	state =
+	// 		target.atoms.get(token.key) ??
+	// 		core.selectors.get(token.key) ??
+	// 		core.readonlySelectors.get(token.key) ??
+	// 		core.transactions.get(token.key) ??
+	// 		core.timelines.get(token.key)
 
-					if (timeline) {
-						addAtomToTimeline(state, timeline, store)
-					}
-					break
-				}
-				case `selector`:
-					core.selectors.set(token.key, state)
-					break
-				case `readonly_selector`:
-					core.readonlySelectors.set(token.key, state)
-					break
-				case `transaction`:
-					core.transactions.set(token.key, state)
-					break
-				case `timeline`:
-					core.timelines.set(token.key, state)
-					break
-			}
-			return state
-		}
-	}
+	// 	if (state) {
+	// 		store.logger.info(
+	// 			`🛠️`,
+	// 			token.type,
+	// 			token.key,
+	// 			`add ${token.type} "${token.key}"`,
+	// 		)
+	// 		switch (state.type) {
+	// 			case `atom`: {
+	// 				store.atoms.set(token.key, state)
+	// 				store.valueMap.set(token.key, state.default)
+	// 				const stateKey = state.key
+	// 				const familyKey = state.family?.key
+	// 				let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
+	// 				if (timelineKey === undefined && typeof familyKey === `string`) {
+	// 					timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
+	// 				}
+	// 				const timeline =
+	// 					typeof timelineKey === `string`
+	// 						? store.timelines.get(timelineKey)
+	// 						: undefined
+
+	// 				if (timeline) {
+	// 					addAtomToTimeline(state, timeline, store)
+	// 				}
+	// 				break
+	// 			}
+	// 			case `selector`:
+	// 				core.selectors.set(token.key, state)
+	// 				break
+	// 			case `readonly_selector`:
+	// 				core.readonlySelectors.set(token.key, state)
+	// 				break
+	// 			case `transaction`:
+	// 				core.transactions.set(token.key, state)
+	// 				break
+	// 			case `timeline`:
+	// 				core.timelines.set(token.key, state)
+	// 				break
+	// 		}
+	// 		return state
+	// 	}
+	// }
 	return undefined
 }

package/internal/src/subject.ts

@@ -19,3 +19,17 @@ export class Subject<T> {
 		}
 	}
 }
+
+export class StatefulSubject<T> extends Subject<T> {
+	public state: T
+
+	public constructor(initialState: T) {
+		super()
+		this.state = initialState
+	}
+
+	public next(value: T): void {
+		this.state = value
+		super.next(value)
+	}
+}

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

@@ -1,21 +1,21 @@
 import type { Atom } from "../atom"
+import { newest } from "../lineage"
 import type { ReadonlySelector, Selector } from "../selector"
 import type { Store } from "../store"
-import { target } from "../transaction"
 
 export const recallState = <T>(
 	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
 	store: Store,
 ): T => {
-	const core = target(store)
-	if (!core.operation.open) {
+	const target = newest(store)
+	if (!target.operation.open) {
 		store.logger.warn(
 			`🐞`,
 			state.type,
 			state.key,
 			`recall called outside of an operation. This is probably a bug.`,
 		)
-		return core.valueMap.get(state.key)
+		return target.valueMap.get(state.key)
 	}
-	return core.operation.prev.get(state.key)
+	return target.operation.prev.get(state.key)
 }

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

@@ -1,8 +1,9 @@
+import type { TransactionUpdate, ƒn } from "atom.io"
 import type { AtomToken, TimelineUpdate } from "atom.io"
 
+import { newest } from "../lineage"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import { target } from "../transaction"
 import type {
 	Timeline,
 	TimelineAtomUpdate,
@@ -21,6 +22,7 @@ export const addAtomToTimeline = (
 		)
 	}
 	atom.subject.subscribe(`timeline`, (update) => {
+		const target = newest(store)
 		const currentSelectorKey =
 			store.operation.open && store.operation.token.type === `selector`
 				? store.operation.token.key
@@ -30,13 +32,8 @@ export const addAtomToTimeline = (
 				? store.operation.time
 				: null
 		const currentTransactionKey =
-			store.transactionStatus.phase === `applying`
-				? store.transactionStatus.key
-				: null
-		const currentTransactionTime =
-			store.transactionStatus.phase === `applying`
-				? store.transactionStatus.time
-				: null
+			target.subject.transactionApplying.state?.update.key
+		const currentTransactionTime = target.subject.transactionApplying.state?.time
 
 		store.logger.info(
 			`⏳`,
@@ -54,7 +51,6 @@ export const addAtomToTimeline = (
 				  ? `in selector "${currentSelectorKey}"`
 				  : ``,
 		)
-
 		if (tl.timeTraveling === null) {
 			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
 				const mostRecentUpdate: TimelineUpdate | undefined = tl.history.at(-1)
@@ -64,10 +60,7 @@ export const addAtomToTimeline = (
 					)
 				}
 			}
-			if (
-				currentTransactionKey &&
-				store.transactionStatus.phase === `applying`
-			) {
+			if (currentTransactionKey) {
 				const currentTransaction = withdraw(
 					{ key: currentTransactionKey, type: `transaction` },
 					store,
@@ -96,26 +89,43 @@ export const addAtomToTimeline = (
 									tl.history.splice(tl.at)
 								}
 
-								const atomUpdates = update.atomUpdates.filter((atomUpdate) => {
-									const core = target(store)
-									const atomOrFamilyKeys = core.timelineAtoms.getRelatedKeys(
-										tl.key,
-									)
+								const filterUpdates = (
+									updates: TransactionUpdate<ƒn>[`updates`],
+								) =>
+									updates
+										.filter((updateFromTx) => {
+											const target = newest(store)
+											if (`updates` in updateFromTx) {
+												return true
+											}
+											const atomOrFamilyKeys =
+												target.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),
+												}
+											}
+											return updateFromTx
+										})
 
-									return atomOrFamilyKeys
-										? [...atomOrFamilyKeys].some(
-												(key) =>
-													key === atomUpdate.key ||
-													key === atomUpdate.family?.key,
-										  )
-										: false
-								})
+								const updates = filterUpdates(update.updates)
 
 								const timelineTransactionUpdate: TimelineTransactionUpdate = {
 									type: `transaction_update`,
 									timestamp: currentTransactionTime,
 									...update,
-									atomUpdates,
+									updates,
 								}
 								const willCapture =
 									tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true

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

@@ -8,9 +8,9 @@ import type {
 	ƒn,
 } from "atom.io"
 
+import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { target } from "../transaction"
 import { addAtomToTimeline } from "./add-atom-to-timeline"
 
 export type TimelineAtomUpdate = StateUpdate<unknown> & {
@@ -71,9 +71,9 @@ export function createTimeline(
 		tl.shouldCapture = options.shouldCapture
 	}
 
-	const core = target(store)
+	const target = newest(store)
 	for (const tokenOrFamily of options.atoms) {
-		const timelineKey = core.timelineAtoms.getRelatedKey(tokenOrFamily.key)
+		const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key)
 		if (timelineKey) {
 			store.logger.error(
 				`❌`,
@@ -86,11 +86,9 @@ export function createTimeline(
 		if (tokenOrFamily.type === `atom_family`) {
 			const family = tokenOrFamily
 			family.subject.subscribe(`timeline:${options.key}`, (token) => {
-				// if (!core.atoms.has(token.key)) {
 				addAtomToTimeline(token, tl, store)
-				// }
 			})
-			for (const atom of core.atoms.values()) {
+			for (const atom of target.atoms.values()) {
 				if (atom.family?.key === family.key) {
 					addAtomToTimeline(atom, tl, store)
 				}
@@ -98,7 +96,7 @@ export function createTimeline(
 		} else {
 			const token = tokenOrFamily
 			if (`family` in token && token.family) {
-				const familyTimelineKey = core.timelineAtoms.getRelatedKey(
+				const familyTimelineKey = target.timelineAtoms.getRelatedKey(
 					token.family.key,
 				)
 				if (familyTimelineKey) {
@@ -113,7 +111,7 @@ export function createTimeline(
 			}
 			addAtomToTimeline(token, tl, store)
 		}
-		core.timelineAtoms = core.timelineAtoms.set({
+		target.timelineAtoms = target.timelineAtoms.set({
 			atomKey: tokenOrFamily.key,
 			timelineKey: options.key,
 		})

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

@@ -1,4 +1,4 @@
-import type { TimelineToken } from "atom.io"
+import type { KeyedStateUpdate, TimelineToken, TransactionUpdate } from "atom.io"
 import { setState } from "atom.io"
 
 import type { Store } from "../store"
@@ -50,19 +50,33 @@ export const timeTravel = (
 	}
 
 	const update = timelineData.history[timelineData.at]
-	const updateValues = (atomUpdate: any) => {
+	const updateValues = (atomUpdate: KeyedStateUpdate<any>) => {
 		const { key, newValue, oldValue } = atomUpdate
 		const value = direction === `forward` ? newValue : oldValue
 		setState({ key, type: `atom` }, value, store)
 	}
+	const updateValuesFromTransactionUpdate = (
+		transactionUpdate: TransactionUpdate<any>,
+	) => {
+		const updates =
+			direction === `forward`
+				? transactionUpdate.updates
+				: [...transactionUpdate.updates].reverse()
+		for (const updateFromTransaction of updates) {
+			if (`newValue` in updateFromTransaction) {
+				updateValues(updateFromTransaction)
+			} else {
+				updateValuesFromTransactionUpdate(updateFromTransaction)
+			}
+		}
+	}
 
 	switch (update.type) {
 		case `atom_update`: {
 			updateValues(update)
 			break
 		}
-		case `selector_update`:
-		case `transaction_update`: {
+		case `selector_update`: {
 			const updates =
 				direction === `forward`
 					? update.atomUpdates
@@ -72,6 +86,10 @@ export const timeTravel = (
 			}
 			break
 		}
+		case `transaction_update`: {
+			updateValuesFromTransactionUpdate(update)
+			break
+		}
 	}
 
 	if (direction === `forward`) {