atom.io 0.24.5 → 0.24.7

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

@@ -1,11 +1,13 @@
 import type {
 	AtomFamilyToken,
+	AtomToken,
 	FamilyMetadata,
 	Flat,
 	Func,
 	MoleculeConstructor,
 	MoleculeCreation,
 	MoleculeDisposal,
+	MoleculeFamilyToken,
 	ReadableToken,
 	StateCreation,
 	StateDisposal,
@@ -15,15 +17,16 @@ import type {
 	TimelineToken,
 	TimelineUpdate,
 	TokenType,
+	TransactionToken,
 	TransactionUpdate,
+	TransactionUpdateContent,
 } from "atom.io"
 import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
-import { getUpdateToken, isMutable } from "../mutable"
+import { getUpdateToken } from "../mutable"
 import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
-import { addAtomToTimeline } from "./add-atom-to-timeline"
 
 export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<
 	StateUpdate<TokenType<ManagedAtom>> & {
@@ -100,56 +103,27 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 	}
 	const timelineKey = options.key
 	const target = newest(store)
-	for (const tokenOrFamily of options.scope) {
-		let atomKey = tokenOrFamily.key
-		switch (tokenOrFamily.type) {
-			case `atom_family`:
-			case `mutable_atom_family`:
-				{
-					const familyToken: AtomFamilyToken<any> = tokenOrFamily
-					const family = withdraw(familyToken, store)
-					const familyKey = family.key
-					target.timelineAtoms.set({ atomKey: familyKey, timelineKey })
-					tl.subscriptions.set(
-						family.key,
-						family.subject.subscribe(
-							`timeline:${options.key}`,
-							(creationOrDisposal) => {
-								handleStateLifecycleEvent(creationOrDisposal, tl, store)
-							},
-						),
-					)
-					for (const atom of target.atoms.values()) {
-						if (atom.family?.key === familyKey) {
-							addAtomToTimeline(atom, tl, store)
-						}
-					}
-				}
-				break
+	for (const initialTopic of options.scope) {
+		switch (initialTopic.type) {
 			case `atom`:
 			case `mutable_atom`:
 				{
-					let atom = withdraw(tokenOrFamily, store)
-					if (isMutable(atom)) {
-						const updateAtom = withdraw(getUpdateToken(atom), store)
-						atom = updateAtom
-						atomKey = atom.key
-					}
-					if (`family` in atom) {
-						const familyTimelineKey = target.timelineAtoms.getRelatedKey(
-							atom.family.key,
-						)
-						if (familyTimelineKey) {
+					const atomToken: AtomToken<ManagedAtom> = initialTopic
+					const atomKey = atomToken.key
+					let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey)
+					if (`family` in atomToken) {
+						const familyKey = atomToken.family.key
+						existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey)
+						if (existingTimelineKey) {
 							store.logger.error(
 								`❌`,
 								`timeline`,
 								options.key,
-								`Failed to add atom "${atom.key}" because its family "${atom.family.key}" already belongs to timeline "${familyTimelineKey}"`,
+								`Failed to add atom "${atomKey}" because its family "${familyKey}" already belongs to timeline "${existingTimelineKey}"`,
 							)
 							continue
 						}
 					}
-					const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey)
 					if (existingTimelineKey) {
 						store.logger.error(
 							`❌`,
@@ -159,72 +133,46 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 						)
 						continue
 					}
-					addAtomToTimeline(atom, tl, store)
+					addAtomToTimeline(atomToken, tl, store)
 				}
 				break
-			case `molecule_family`:
+
+			case `atom_family`:
+			case `mutable_atom_family`:
 				{
-					const family = store.moleculeFamilies.get(tokenOrFamily.key)
-					if (family) {
-						tl.subscriptions.set(
-							tokenOrFamily.key,
-							family.subject.subscribe(
-								`timeline:${options.key}`,
-								(creationOrDisposal) => {
-									switch (creationOrDisposal.type) {
-										case `molecule_creation`:
-											{
-												const molecule = store.molecules.get(
-													stringifyJson(creationOrDisposal.token.key),
-												)
-												if (molecule) {
-													const event = Object.assign(creationOrDisposal, {
-														timestamp: Date.now(),
-													})
-													tl.history.push(event)
-													tl.at = tl.history.length
-													tl.subject.next(event)
+					const familyToken: AtomFamilyToken<any, any> = initialTopic
+					const familyKey = familyToken.key
+					const existingTimelineKey =
+						target.timelineTopics.getRelatedKey(familyKey)
+					if (existingTimelineKey) {
+						store.logger.error(
+							`❌`,
+							`timeline`,
+							options.key,
+							`Failed to add atom family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`,
+						)
+						continue
+					}
+					addAtomFamilyToTimeline(familyToken, tl, store)
+				}
+				break
 
-													for (const token of molecule.tokens.values()) {
-														switch (token.type) {
-															case `atom`:
-															case `mutable_atom`:
-																addAtomToTimeline(token, tl, store)
-																break
-														}
-													}
-													tl.subscriptions.set(
-														molecule.key,
-														molecule.subject.subscribe(
-															`timeline:${options.key}`,
-															(stateCreationOrDisposal) => {
-																handleStateLifecycleEvent(
-																	stateCreationOrDisposal,
-																	tl,
-																	store,
-																)
-															},
-														),
-													)
-												}
-											}
-											break
-										case `molecule_disposal`:
-											tl.subscriptions.get(creationOrDisposal.token.key)?.()
-											tl.subscriptions.delete(creationOrDisposal.token.key)
-											for (const familyKey of creationOrDisposal.familyKeys) {
-												const stateKey = `${familyKey}(${stringifyJson(
-													creationOrDisposal.token.key,
-												)})`
-												tl.subscriptions.get(stateKey)?.()
-												tl.subscriptions.delete(stateKey)
-											}
-											break
-									}
-								},
-							),
+			case `molecule_family`:
+				{
+					const familyToken: MoleculeFamilyToken<any> = initialTopic
+					const familyKey = familyToken.key
+					const existingTimelineKey =
+						target.timelineTopics.getRelatedKey(familyKey)
+					if (existingTimelineKey) {
+						store.logger.error(
+							`❌`,
+							`timeline`,
+							options.key,
+							`Failed to add molecule family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`,
 						)
+						continue
 					}
+					addMoleculeFamilyToTimeline(familyToken, tl, store)
 				}
 				break
 		}
@@ -239,6 +187,353 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 	return token
 }
 
+function addAtomToTimeline(
+	atomToken: AtomToken<any>,
+	tl: Timeline<any>,
+	store: Store,
+): void {
+	let maybeAtom = withdraw(atomToken, store)
+	if (maybeAtom.type === `mutable_atom`) {
+		const updateToken = getUpdateToken(maybeAtom)
+		maybeAtom = withdraw(updateToken, store)
+	}
+	const atom = maybeAtom
+	store.timelineTopics.set(
+		{ topicKey: atom.key, timelineKey: tl.key },
+		{ topicType: `atom` },
+	)
+
+	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 txUpdateInProgress = target.on.transactionApplying.state?.update
+
+			store.logger.info(
+				`⏳`,
+				`timeline`,
+				tl.key,
+				`atom`,
+				atomToken.key,
+				`went`,
+				update.oldValue,
+				`->`,
+				update.newValue,
+				txUpdateInProgress
+					? `in transaction "${txUpdateInProgress.key}"`
+					: currentSelectorKey
+						? `in selector "${currentSelectorKey}"`
+						: ``,
+			)
+			if (tl.timeTraveling === null) {
+				if (txUpdateInProgress) {
+					joinTransaction(tl, txUpdateInProgress, store)
+				} 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,
+								`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()
+							tl.at = tl.history.length
+						}
+					}
+				} 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)
+					}
+				}
+			}
+		}),
+	)
+}
+
+function addAtomFamilyToTimeline(
+	atomFamilyToken: AtomFamilyToken<any, any>,
+	tl: Timeline<any>,
+	store: Store,
+): void {
+	const family = withdraw(atomFamilyToken, store)
+	store.timelineTopics.set(
+		{ topicKey: family.key, timelineKey: tl.key },
+		{ topicType: `atom_family` },
+	)
+	tl.subscriptions.set(
+		family.key,
+		family.subject.subscribe(`timeline`, (creationOrDisposal) => {
+			handleStateLifecycleEvent(creationOrDisposal, tl, store)
+		}),
+	)
+	for (const atom of store.atoms.values()) {
+		if (atom.family?.key === family.key) {
+			addAtomToTimeline(atom, tl, store)
+		}
+	}
+}
+
+function addMoleculeFamilyToTimeline(
+	familyToken: MoleculeFamilyToken<any>,
+	tl: Timeline<any>,
+	store: Store,
+): void {
+	store.timelineTopics.set(
+		{ topicKey: familyToken.key, timelineKey: tl.key },
+		{ topicType: `molecule_family` },
+	)
+	const family = store.moleculeFamilies.get(familyToken.key)
+	if (family) {
+		tl.subscriptions.set(
+			familyToken.key,
+			family.subject.subscribe(`timeline:${tl.key}`, (creationOrDisposal) => {
+				store.logger.info(
+					`🐞`,
+					`timeline`,
+					tl.key,
+					`got a molecule creation or disposal`,
+					creationOrDisposal,
+				)
+				switch (creationOrDisposal.type) {
+					case `molecule_creation`:
+						{
+							store.timelineTopics.set(
+								{
+									topicKey: creationOrDisposal.token.key,
+									timelineKey: tl.key,
+								},
+								{ topicType: `molecule` },
+							)
+							const txUpdateInProgress =
+								newest(store).on.transactionApplying.state?.update
+							if (txUpdateInProgress) {
+								joinTransaction(tl, txUpdateInProgress, store)
+							} else if (tl.timeTraveling === null) {
+								const event = Object.assign(creationOrDisposal, {
+									timestamp: Date.now(),
+								})
+								tl.history.push(event)
+								tl.at = tl.history.length
+								tl.subject.next(event)
+							}
+							const molecule = withdraw(creationOrDisposal.token, store)
+
+							for (const token of molecule.tokens.values()) {
+								switch (token.type) {
+									case `atom`:
+									case `mutable_atom`:
+										addAtomToTimeline(token, tl, store)
+										break
+								}
+							}
+							tl.subscriptions.set(
+								molecule.key,
+								molecule.subject.subscribe(
+									`timeline:${tl.key}`,
+									(stateCreationOrDisposal) => {
+										handleStateLifecycleEvent(stateCreationOrDisposal, tl, store)
+									},
+								),
+							)
+						}
+						break
+					case `molecule_disposal`:
+						{
+							const txUpdateInProgress =
+								newest(store).on.transactionApplying.state?.update
+							if (txUpdateInProgress) {
+								joinTransaction(tl, txUpdateInProgress, store)
+							} else if (tl.timeTraveling === null) {
+								const event = Object.assign(creationOrDisposal, {
+									timestamp: Date.now(),
+								})
+								tl.history.push(event)
+								tl.at = tl.history.length
+								tl.subject.next(event)
+							}
+							const moleculeKey = creationOrDisposal.token.key
+							tl.subscriptions.get(moleculeKey)?.()
+							tl.subscriptions.delete(moleculeKey)
+							for (const [familyKey] of creationOrDisposal.values) {
+								const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`
+								tl.subscriptions.get(stateKey)?.()
+								tl.subscriptions.delete(stateKey)
+								store.timelineTopics.delete(stateKey)
+							}
+						}
+						break
+				}
+			}),
+		)
+	}
+}
+
+function joinTransaction(
+	tl: Timeline<any>,
+	txUpdateInProgress: TransactionUpdate<Func>,
+	store: Store,
+) {
+	const currentTxKey = txUpdateInProgress.key
+	const currentTxInstanceId = txUpdateInProgress.id
+	const currentTxToken: TransactionToken<any> = {
+		key: currentTxKey,
+		type: `transaction`,
+	}
+	const currentTransaction = withdraw(currentTxToken, store)
+	if (currentTxKey && tl.transactionKey === null) {
+		tl.transactionKey = currentTxKey
+		const unsubscribe = currentTransaction.subject.subscribe(
+			`timeline:${tl.key}`,
+			(transactionUpdate) => {
+				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)!
+
+					const updates = filterTransactionUpdates(
+						transactionUpdate.updates,
+						timelineTopics,
+					)
+
+					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)
+					}
+				}
+			},
+		)
+	}
+}
+
+function filterTransactionUpdates(
+	updates: TransactionUpdateContent[],
+	timelineTopics: Set<string>,
+): TransactionUpdateContent[] {
+	return updates
+		.filter((updateFromTx) => {
+			if (updateFromTx.type === `transaction_update`) {
+				return true
+			}
+
+			let key: string
+			switch (updateFromTx.type) {
+				case `state_creation`:
+				case `state_disposal`:
+				case `molecule_creation`:
+				case `molecule_disposal`:
+					key = updateFromTx.token.key
+					break
+				default:
+					key = updateFromTx.key
+					break
+			}
+			return timelineTopics.has(key)
+		})
+		.map((updateFromTx) => {
+			if (`updates` in updateFromTx) {
+				return {
+					...updateFromTx,
+					updates: filterTransactionUpdates(
+						updateFromTx.updates,
+						timelineTopics,
+					),
+				}
+			}
+			return updateFromTx
+		})
+}
+
 function handleStateLifecycleEvent(
 	event: StateCreation<any> | StateDisposal<any>,
 	tl: Timeline<any>,
@@ -249,9 +544,14 @@ function handleStateLifecycleEvent(
 		timestamp,
 	}) as TimelineUpdate<any>
 	if (!tl.timeTraveling) {
-		tl.history.push(timelineEvent)
-		tl.at = tl.history.length
-		tl.subject.next(timelineEvent)
+		const txUpdateInProgress = newest(store).on.transactionApplying.state?.update
+		if (txUpdateInProgress) {
+			joinTransaction(tl, txUpdateInProgress, store)
+		} else {
+			tl.history.push(timelineEvent)
+			tl.at = tl.history.length
+			tl.subject.next(timelineEvent)
+		}
 	}
 	switch (event.type) {
 		case `state_creation`:

package/internal/src/timeline/index.ts

@@ -1,3 +1,2 @@
-export * from "./add-atom-to-timeline"
 export * from "./create-timeline"
 export * from "./time-travel"

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

@@ -38,7 +38,7 @@ export const buildTransaction = (
 		operation: { open: false },
 		readonlySelectors: new LazyMap(parent.readonlySelectors),
 		timelines: new LazyMap(parent.timelines),
-		timelineAtoms: new Junction(parent.timelineAtoms.toJSON()),
+		timelineTopics: new Junction(parent.timelineTopics.toJSON()),
 		trackers: new Map(),
 		transactions: new LazyMap(parent.transactions),
 		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
@@ -49,6 +49,7 @@ export const buildTransaction = (
 		valueMap: new LazyMap(parent.valueMap),
 		molecules: new LazyMap(parent.molecules),
 		moleculeFamilies: new LazyMap(parent.moleculeFamilies),
+		moleculeInProgress: parent.moleculeInProgress,
 		miscResources: new LazyMap(parent.miscResources),
 	}
 	const epoch = getEpochNumberOfAction(key, store)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.24.5",
+  "version": "0.24.7",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -56,8 +56,8 @@
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.3",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "7.13.1",
-    "@typescript-eslint/rule-tester": "7.13.1",
+    "@typescript-eslint/parser": "7.14.1",
+    "@typescript-eslint/rule-tester": "7.14.1",
     "@vitest/coverage-v8": "1.6.0",
     "@vitest/ui": "1.6.0",
     "concurrently": "8.2.2",
@@ -73,7 +73,7 @@
     "preact": "10.22.0",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.23.1",
+    "react-router-dom": "6.24.0",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",

package/src/transaction.ts

@@ -57,7 +57,7 @@ export type MoleculeDisposal = {
 	token: MoleculeToken<any>
 	family: MoleculeFamilyToken<any>
 	context: MoleculeToken<any>[]
-	familyKeys: string[]
+	values: [key: string, value: any][]
 }
 
 export type TransactionUpdateContent =