atom.io 0.24.4 → 0.24.6

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/apply-transaction.ts

@@ -38,14 +38,6 @@ export const applyTransaction = <F extends Func>(
 		`Applying transaction with ${updates.length} updates:`,
 		updates,
 	)
-	for (const tracker of child.trackers.values()) {
-		const mutableKey = tracker.mutableState.key
-		if (!parent.atoms.has(mutableKey)) {
-			const atom = child.atoms.get(mutableKey)
-			atom?.install(parent)
-		}
-		tracker.dispose()
-	}
 
 	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
 

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.4",
+  "version": "0.24.6",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,

package/realtime-server/dist/index.cjs

@@ -369,67 +369,6 @@ function realtimeActionReceiver({
     };
   };
 }
-AtomIO.selectorFamily({
-  key: `perspectiveRedactor`,
-  get: ({ userId, syncGroupKey }) => ({ get, find }) => {
-    const syncGroup = realtime.SyncGroup.existing.get(syncGroupKey);
-    if (!syncGroup) {
-      throw new Error(
-        `Tried to create a synchronizer for a sync group that does not exist.`
-      );
-    }
-    const userPerspectiveTokens = syncGroup.perspectives.flatMap(
-      ({ viewAtoms }) => {
-        const userPerspectiveToken = find(viewAtoms, userId);
-        const userPerspective = get(userPerspectiveToken);
-        const visibleTokens = [...userPerspective].map((token) => {
-          return token.type === `mutable_atom` ? internal.getUpdateToken(token).key : token.key;
-        });
-        internal.IMPLICIT.STORE.logger.info(
-          `\u{1F52D}`,
-          `continuity`,
-          syncGroupKey,
-          `${userId} can see ${visibleTokens.length} tokens in ${viewAtoms.key}`,
-          visibleTokens
-        );
-        return visibleTokens;
-      }
-    );
-    const filterTransactionUpdate = (visible, transactionUpdate) => {
-      internal.IMPLICIT.STORE.logger.info(
-        `\u{1F58C}`,
-        `continuity`,
-        syncGroupKey,
-        `redacting updates from ${transactionUpdate.epoch}:${transactionUpdate.key}:${transactionUpdate.id}`,
-        visible,
-        transactionUpdate.updates
-      );
-      const updates = transactionUpdate.updates.filter((update) => {
-        if (`newValue` in update) {
-          return visible.includes(update.key);
-        }
-        return true;
-      }).map((update) => {
-        if (`updates` in update) {
-          return filterTransactionUpdate(visible, update);
-        }
-        return update;
-      });
-      const filtered = __spreadProps(__spreadValues({}, transactionUpdate), {
-        updates
-      });
-      return filtered;
-    };
-    const filter = (update) => {
-      const visibleKeys = syncGroup.globals.map(
-        (atomToken) => atomToken.type === `mutable_atom` ? internal.getUpdateToken(atomToken).key : atomToken.key
-      );
-      visibleKeys.push(...userPerspectiveTokens);
-      return filterTransactionUpdate(visibleKeys, update);
-    };
-    return filter;
-  }
-});
 var roomArgumentsAtoms = AtomIO.atomFamily({
   key: `roomArguments`,
   default: [`echo`, [`Hello World!`]]