atom.io 0.12.1 → 0.14.0

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`) {

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

@@ -1,7 +1,9 @@
+import { newest } from "../lineage"
 import type { Store } from "../store"
 
 export const abortTransaction = (store: Store): void => {
-	if (store.transactionStatus.phase === `idle`) {
+	const target = newest(store)
+	if (target.transactionMeta === null || target.parent === null) {
 		store.logger.warn(
 			`🐞`,
 			`transaction`,
@@ -13,8 +15,8 @@ export const abortTransaction = (store: Store): void => {
 	store.logger.info(
 		`🪂`,
 		`transaction`,
-		store.transactionStatus.key,
+		target.transactionMeta.update.key,
 		`Aborting transaction`,
 	)
-	store.transactionStatus = { phase: `idle` }
+	target.parent.child = null
 }

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

@@ -1,14 +1,67 @@
-import type { AtomToken, ƒn } from "atom.io"
-import { setState, transaction } from "atom.io"
+import type { AtomToken, KeyedStateUpdate, TransactionUpdate, ƒn } from "atom.io"
+import { setState } from "atom.io"
 
+import { newest } from "../lineage"
 import { withdraw } from "../store"
 import type { Store } from "../store"
 
+function ingestAtomUpdate(
+	update: KeyedStateUpdate<any>,
+	parent: Store,
+	child: Store,
+): void {
+	const { key, newValue } = update
+	const token: AtomToken<unknown> = { key, type: `atom` }
+	if (!parent.valueMap.has(token.key)) {
+		if (token.family) {
+			const family = parent.families.get(token.family.key)
+			if (family) {
+				family(token.family.subKey)
+			}
+		} else {
+			const newAtom = child.atoms.get(token.key)
+			if (!newAtom) {
+				throw new Error(
+					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${child.transactionMeta?.update.key}" to store "${parent.config.name}"`,
+				)
+			}
+			parent.atoms.set(newAtom.key, newAtom)
+			parent.valueMap.set(newAtom.key, newAtom.default)
+			parent.logger.info(
+				`🔨`,
+				`transaction`,
+				child.transactionMeta?.update.key ?? `???`,
+				`Adding atom "${newAtom.key}"`,
+			)
+		}
+	}
+	setState(token, newValue, parent)
+}
+function ingestTransactionUpdate(
+	transactionUpdate: TransactionUpdate<any>,
+	parent: Store,
+	child: Store,
+): void {
+	for (const update of transactionUpdate.updates) {
+		if (`newValue` in update) {
+			ingestAtomUpdate(update, parent, child)
+		} else {
+			ingestTransactionUpdate(update, parent, child)
+		}
+	}
+}
+
 export const applyTransaction = <ƒ extends ƒn>(
 	output: ReturnType<ƒ>,
 	store: Store,
 ): void => {
-	if (store.transactionStatus.phase !== `building`) {
+	const child = newest(store)
+	const { parent } = child
+	if (
+		parent === null ||
+		child.transactionMeta === null ||
+		child.transactionMeta?.phase !== `building`
+	) {
 		store.logger.warn(
 			`🐞`,
 			`transaction`,
@@ -17,65 +70,34 @@ export const applyTransaction = <ƒ extends ƒn>(
 		)
 		return
 	}
-	store.transactionStatus.phase = `applying`
-	store.transactionStatus.output = output
-	const { atomUpdates } = store.transactionStatus
+	child.transactionMeta.phase = `applying`
+	child.transactionMeta.update.output = output
+	parent.child = null
+	parent.subject.transactionApplying.next(child.transactionMeta)
+	const { updates } = child.transactionMeta.update
 	store.logger.info(
 		`🛄`,
 		`transaction`,
-		store.transactionStatus.key,
-		`Applying transaction with ${atomUpdates.length} updates:`,
-		atomUpdates,
+		child.transactionMeta.update.key,
+		`Applying transaction with ${updates.length} updates:`,
+		updates,
 	)
-
-	for (const { key, newValue } of atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		if (!store.valueMap.has(token.key)) {
-			if (token.family) {
-				const family = store.families.get(token.family.key)
-				if (family) {
-					family(token.family.subKey)
-				}
-			} else {
-				const newAtom = store.transactionStatus.core.atoms.get(token.key)
-				if (!newAtom) {
-					throw new Error(
-						`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`,
-					)
-				}
-				store.atoms.set(newAtom.key, newAtom)
-				store.valueMap.set(newAtom.key, newAtom.default)
-				store.logger.info(
-					`🔨`,
-					`transaction`,
-					store.transactionStatus.key,
-					`Adding atom "${newAtom.key}"`,
-				)
-			}
-		}
-		// if (store.transactionStatus.key === `dealCards`) debugger
-		setState(token, newValue, store)
-	}
-	const myTransaction = withdraw<ƒ>(
-		{ key: store.transactionStatus.key, type: `transaction` },
-		store,
-	)
-	if (myTransaction === undefined) {
-		throw new Error(
-			`Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`,
+	if (parent.transactionMeta === null) {
+		ingestTransactionUpdate(child.transactionMeta.update, parent, child)
+		const myTransaction = withdraw<ƒ>(
+			{ key: child.transactionMeta.update.key, type: `transaction` },
+			store,
 		)
+		myTransaction?.subject.next(child.transactionMeta.update)
+		store.logger.info(
+			`🛬`,
+			`transaction`,
+			child.transactionMeta.update.key,
+			`Finished applying transaction.`,
+		)
+	} else {
+		ingestTransactionUpdate(child.transactionMeta.update, parent, child)
+		parent.transactionMeta.update.updates.push(child.transactionMeta.update)
 	}
-	myTransaction.subject.next({
-		key: store.transactionStatus.key,
-		atomUpdates,
-		output,
-		params: store.transactionStatus.params as Parameters<ƒ>,
-	})
-	store.logger.info(
-		`🛬`,
-		`transaction`,
-		store.transactionStatus.key,
-		`Finished applying transaction.`,
-	)
-	store.transactionStatus = { phase: `idle` }
+	parent.subject.transactionApplying.next(null)
 }

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

@@ -1,6 +1,7 @@
 import { Junction } from "~/packages/rel8/junction/src"
 
 import { LazyMap } from "../lazy-map"
+import { newest } from "../lineage"
 import type { Store } from "../store"
 
 export const buildTransaction = (
@@ -8,30 +9,39 @@ export const buildTransaction = (
 	params: any[],
 	store: Store,
 ): void => {
-	store.transactionStatus = {
-		key,
-		phase: `building`,
-		time: Date.now(),
-		core: {
-			atoms: new LazyMap(store.atoms),
-			atomsThatAreDefault: new Set(store.atomsThatAreDefault),
-			families: new LazyMap(store.families),
-			operation: { open: false },
-			readonlySelectors: new LazyMap(store.readonlySelectors),
-			timelines: new LazyMap(store.timelines),
-			timelineAtoms: new Junction(store.timelineAtoms.toJSON()),
-			trackers: new Map(),
-			transactions: new LazyMap(store.transactions),
-			selectorAtoms: new Junction(store.selectorAtoms.toJSON()),
-			selectorGraph: new Junction(store.selectorGraph.toJSON(), {
-				makeContentKey: (...keys) => keys.sort().join(`:`),
-			}),
-			selectors: new LazyMap(store.selectors),
-			valueMap: new LazyMap(store.valueMap),
+	const parent = newest(store)
+	parent.child = {
+		parent,
+		child: null,
+		subject: parent.subject,
+		loggers: parent.loggers,
+		logger: parent.logger,
+		config: parent.config,
+		transactionMeta: {
+			phase: `building`,
+			time: Date.now(),
+			update: {
+				key,
+				updates: [],
+				params,
+				output: undefined,
+			},
 		},
-		atomUpdates: [],
-		params,
-		output: undefined,
+		atoms: new LazyMap(parent.atoms),
+		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
+		families: new LazyMap(parent.families),
+		operation: { open: false },
+		readonlySelectors: new LazyMap(parent.readonlySelectors),
+		timelines: new LazyMap(parent.timelines),
+		timelineAtoms: new Junction(parent.timelineAtoms.toJSON()),
+		trackers: new Map(),
+		transactions: new LazyMap(parent.transactions),
+		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
+		selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		}),
+		selectors: new LazyMap(parent.selectors),
+		valueMap: new LazyMap(parent.valueMap),
 	}
 	store.logger.info(
 		`🛫`,

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

@@ -4,10 +4,11 @@ import type {
 	TransactionUpdate,
 	ƒn,
 } from "atom.io"
-import { getState, setState } from "atom.io"
+import { getState, runTransaction, setState } from "atom.io"
 
+import { newest } from "../lineage"
 import { deposit } from "../store"
-import type { Store, StoreCore } from "../store"
+import type { Store } from "../store"
 import { Subject } from "../subject"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
@@ -35,6 +36,7 @@ export function createTransaction<ƒ extends ƒn>(
 					{
 						get: (token) => getState(token, store),
 						set: (token, value) => setState(token, value, store),
+						run: (token) => runTransaction(token, store),
 					},
 					...params,
 				)
@@ -49,14 +51,9 @@ export function createTransaction<ƒ extends ƒn>(
 		install: (store) => createTransaction(options, store),
 		subject: new Subject(),
 	}
-	const core = target(store)
-	core.transactions.set(newTransaction.key, newTransaction)
+	const target = newest(store)
+	target.transactions.set(newTransaction.key, newTransaction)
 	const token = deposit(newTransaction)
 	store.subject.transactionCreation.next(token)
 	return token
 }
-
-export const target = (store: Store): StoreCore =>
-	store.transactionStatus.phase === `building`
-		? store.transactionStatus.core
-		: store

package/internal/src/transaction/index.ts

@@ -1,7 +1,5 @@
 import type { TransactionUpdate, ƒn } from "atom.io"
 
-import type { StoreCore } from ".."
-
 export * from "./abort-transaction"
 export * from "./apply-transaction"
 export * from "./build-transaction"
@@ -12,14 +10,8 @@ export * from "./undo-transaction"
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
 export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
 
-export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
+export type TransactionMeta<ƒ extends ƒn> = {
 	phase: `applying` | `building`
 	time: number
-	core: StoreCore
-}
-export type TransactionIdle = {
-	phase: `idle`
+	update: TransactionUpdate<ƒ>
 }
-export type TransactionStatus<ƒ extends ƒn> =
-	| TransactionIdle
-	| TransactionUpdateInProgress<ƒ>

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

@@ -5,18 +5,23 @@ import { withdraw } from "../store"
 import type { Store } from "../store"
 
 export const redoTransactionUpdate = <ƒ extends ƒn>(
-	update: TransactionUpdate<ƒ>,
+	transactionUpdate: TransactionUpdate<ƒ>,
 	store: Store,
 ): void => {
-	store.logger.info(`⏭️`, `transaction`, update.key, `Redo`)
-	for (const { key, newValue } of update.atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		const state = withdraw(token, store)
-		if (state === undefined) {
-			throw new Error(
-				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
-			)
+	store.logger.info(`⏭️`, `transaction`, transactionUpdate.key, `Redo`)
+	for (const update of transactionUpdate.updates) {
+		if (`newValue` in update) {
+			const { key, newValue } = update
+			const token: AtomToken<unknown> = { key, type: `atom` }
+			const state = withdraw(token, store)
+			if (state === undefined) {
+				throw new Error(
+					`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
+				)
+			}
+			setState(state, newValue, store)
+		} else {
+			redoTransactionUpdate(update, store)
 		}
-		setState(state, newValue, store)
 	}
 }

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

@@ -5,24 +5,23 @@ import { withdraw } from "../store"
 import type { Store } from "../store"
 
 export const undoTransactionUpdate = <ƒ extends ƒn>(
-	update: TransactionUpdate<ƒ>,
+	transactionUpdate: TransactionUpdate<ƒ>,
 	store: Store,
 ): void => {
-	store.logger.info(
-		`⏮️`,
-		`transaction`,
-		update.key,
-		`Undoing transaction update`,
-		update,
-	)
-	for (const { key, oldValue } of update.atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		const state = withdraw(token, store)
-		if (state === undefined) {
-			throw new Error(
-				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
-			)
+	store.logger.info(`⏮️`, `transaction`, transactionUpdate.key, `Undo`)
+	for (const update of transactionUpdate.updates.reverse()) {
+		if (`newValue` in update) {
+			const { key, newValue } = update
+			const token: AtomToken<unknown> = { key, type: `atom` }
+			const state = withdraw(token, store)
+			if (state === undefined) {
+				throw new Error(
+					`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
+				)
+			}
+			setState(state, newValue, store)
+		} else {
+			undoTransactionUpdate(update, store)
 		}
-		setState(state, oldValue, store)
 	}
 }

package/introspection/dist/index.cjs

@@ -81,7 +81,7 @@ var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
                 [key]: atomToken
               });
             });
-            if (Internal.target(store).operation.open) {
+            if (Internal.newest(store).operation.open) {
               const unsubscribe = store.subject.operationStatus.subscribe(
                 `introspection: waiting to update atom index`,
                 () => {
@@ -153,7 +153,7 @@ var attachSelectorIndex = (store = Internal.IMPLICIT.STORE) => {
                   [key]: selectorToken
                 });
               });
-              if (Internal.target(store).operation.open) {
+              if (Internal.newest(store).operation.open) {
                 const unsubscribe = store.subject.operationStatus.subscribe(
                   `introspection: waiting to update selector index`,
                   () => {