atom.io 0.30.7 → 0.31.1

package/internal/src/store/store.ts

@@ -1,16 +1,16 @@
 import type {
 	AtomToken,
 	Logger,
-	MoleculeCreationModern,
-	MoleculeDisposalModern,
-	MoleculeFamily,
-	MoleculeToken,
+	MoleculeCreation,
+	MoleculeDisposal,
 	ReadonlySelectorToken,
 	TimelineToken,
 	TransactionToken,
 	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
+import type { Join } from "atom.io/data"
+import type { Canonical, stringified } from "atom.io/json"
 
 import type {
 	Atom,
@@ -77,6 +77,7 @@ export class Store implements Lineage {
 		| RegularAtomFamily<any, any>
 		| WritableSelectorFamily<any, any>
 	>()
+	public joins = new Map<string, Join<any, any, any, any, any, any>>()
 
 	public transactions = new Map<string, Transaction<Func>>()
 	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {
@@ -101,9 +102,50 @@ export class Store implements Lineage {
 
 	public disposalTraces = new CircularBuffer<{ key: string; trace: string }>(100)
 
-	public molecules = new Map<string, Molecule<any>>()
-	public moleculeFamilies = new Map<string, MoleculeFamily<any>>()
-	public moleculeInProgress: string | null = null
+	public molecules = new Map<string, Molecule<Canonical>>()
+	public moleculeJoins = new Junction<
+		`moleculeKey`,
+		stringified<Canonical>,
+		`joinKey`,
+		string
+	>(
+		{
+			between: [`moleculeKey`, `joinKey`],
+			cardinality: `n:n`,
+		},
+		{
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		},
+	)
+	public moleculeGraph = new Junction<
+		`upstreamMoleculeKey`,
+		stringified<Canonical> | `root`,
+		`downstreamMoleculeKey`,
+		stringified<Canonical>,
+		{ source: stringified<Canonical> }
+	>(
+		{
+			between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
+			cardinality: `n:n`,
+		},
+		{
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		},
+	)
+	public moleculeData = new Junction<
+		`moleculeKey`,
+		stringified<Canonical>,
+		`stateFamilyKey`,
+		string
+	>(
+		{
+			between: [`moleculeKey`, `stateFamilyKey`],
+			cardinality: `n:n`,
+		},
+		{
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		},
+	)
 	public miscResources = new Map<string, Disposable>()
 
 	public on = {
@@ -121,11 +163,8 @@ export class Store implements Lineage {
 			null,
 		),
 		operationClose: new Subject<OperationProgress>(),
-		moleculeCreationStart: new Subject<
-			MoleculeCreationModern | MoleculeToken<any>
-		>(),
-		moleculeCreationDone: new Subject<MoleculeToken<any>>(),
-		moleculeDisposal: new Subject<MoleculeDisposalModern | MoleculeToken<any>>(),
+		moleculeCreation: new Subject<MoleculeCreation>(),
+		moleculeDisposal: new Subject<MoleculeDisposal>(),
 	}
 	public operation: OperationProgress = { open: false }
 

package/internal/src/store/withdraw.ts

@@ -1,10 +1,7 @@
 import type {
 	AtomFamilyToken,
+	AtomIOToken,
 	AtomToken,
-	MoleculeConstructor,
-	MoleculeFamily,
-	MoleculeFamilyToken,
-	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -24,13 +21,12 @@ import type {
 	WritableToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
 
 import type {
 	Atom,
 	AtomFamily,
+	AtomIOInternalResource,
 	Func,
-	Molecule,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -52,28 +48,6 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export type Withdrawable =
-	| Atom<any>
-	| AtomFamily<any, any>
-	| Molecule<any>
-	| MoleculeFamily<any>
-	| MutableAtom<any, any>
-	| MutableAtomFamily<any, any, any>
-	| ReadableFamily<any, any>
-	| ReadableState<any>
-	| ReadonlySelector<any>
-	| ReadonlySelectorFamily<any, any>
-	| RegularAtom<any>
-	| RegularAtomFamily<any, any>
-	| Selector<any>
-	| SelectorFamily<any, any>
-	| Timeline<any>
-	| Transaction<any>
-	| WritableFamily<any, any>
-	| WritableSelector<any>
-	| WritableSelectorFamily<any, any>
-	| WritableState<any>
-
 export function withdraw<T>(
 	token: RegularAtomToken<T>,
 	store: Store,
@@ -138,15 +112,6 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 ): WritableFamily<T, any>
 
-export function withdraw<M extends MoleculeConstructor>(
-	token: MoleculeToken<M>,
-	store: Store,
-): Molecule<M>
-export function withdraw<M extends MoleculeConstructor>(
-	token: MoleculeFamilyToken<M>,
-	store: Store,
-): MoleculeFamily<M>
-
 export function withdraw<T extends Func>(
 	token: TransactionToken<T>,
 	store: Store,
@@ -156,26 +121,25 @@ export function withdraw<T>(
 	store: Store,
 ): Timeline<T extends TimelineManageable ? T : never>
 
-export function withdraw<T, M extends MoleculeConstructor>(
-	token: MoleculeToken<M> | ReadableToken<T>,
+export function withdraw<T>(
+	token: WritableToken<T>,
 	store: Store,
-): Molecule<M> | ReadableState<T>
+): WritableState<T>
+export function withdraw<T>(
+	token: ReadableToken<T>,
+	store: Store,
+): ReadableState<T>
+
+export function withdraw(
+	token: AtomIOToken,
+	store: Store,
+): AtomIOInternalResource
 
 export function withdraw(
-	token:
-		| MoleculeFamilyToken<any>
-		| MoleculeToken<any>
-		| MutableAtomFamilyToken<any, any, any>
-		| MutableAtomToken<any, any>
-		| RegularAtomFamilyToken<any, any>
-		| RegularAtomToken<any>
-		| SelectorFamilyToken<any, any>
-		| SelectorToken<any>
-		| TimelineToken<any>
-		| TransactionToken<any>,
-	store: Store,
-): Withdrawable {
-	let withdrawn: Withdrawable | undefined
+	token: AtomIOToken,
+	store: Store,
+): AtomIOInternalResource {
+	let withdrawn: AtomIOInternalResource | undefined
 	let target: Store | null = store
 	while (target !== null) {
 		switch (token.type) {
@@ -201,12 +165,6 @@ export function withdraw(
 			case `transaction`:
 				withdrawn = target.transactions.get(token.key)
 				break
-			case `molecule`:
-				withdrawn = target.molecules.get(stringifyJson(token.key))
-				break
-			case `molecule_family`:
-				withdrawn = target.moleculeFamilies.get(token.key)
-				break
 		}
 		if (withdrawn) {
 			return withdrawn

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

@@ -2,10 +2,8 @@ import type {
 	AtomFamilyToken,
 	AtomToken,
 	FamilyMetadata,
-	MoleculeConstructor,
 	MoleculeCreation,
 	MoleculeDisposal,
-	MoleculeFamilyToken,
 	ReadableToken,
 	StateCreation,
 	StateDisposal,
@@ -55,8 +53,8 @@ export type TimelineStateCreation<T extends ReadableToken<any>> = Flat<
 export type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<
 	StateDisposal<T> & { timestamp: number }
 >
-export type TimelineMoleculeCreation<M extends MoleculeConstructor> = Flat<
-	MoleculeCreation<M> & { timestamp: number }
+export type TimelineMoleculeCreation = Flat<
+	MoleculeCreation & { timestamp: number }
 >
 export type TimelineMoleculeDisposal = Flat<
 	MoleculeDisposal & { timestamp: number }
@@ -157,24 +155,24 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 				}
 				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
+			// 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
 		}
 	}
 
@@ -205,126 +203,129 @@ function addAtomToTimeline(
 
 	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)
-						}
+		atom.subject.subscribe(
+			`timeline`,
+			function timelineCapturesAtomUpdate(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
 
-						tl.history.push(latestUpdate)
+				const txUpdateInProgress = target.on.transactionApplying.state?.update
 
-						store.logger.info(
-							`⌛`,
-							`timeline`,
-							tl.key,
-							`got a selector_update "${currentSelectorKey}" with`,
-							latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
-						)
+				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)
 
-						tl.at = tl.history.length
-						tl.selectorTime = currentSelectorTime
-					} else {
-						if (latestUpdate?.type === `selector_update`) {
+						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,
-								`set selector_update "${currentSelectorKey}" to`,
-								latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
+								`got a selector_update "${currentSelectorKey}" with`,
+								latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
 							)
-						}
-					}
-					if (latestUpdate) {
-						const willCaptureSelectorUpdate =
-							tl.shouldCapture?.(latestUpdate, tl) ?? true
-						if (willCaptureSelectorUpdate) {
-							tl.subject.next(latestUpdate)
+
+							tl.at = tl.history.length
+							tl.selectorTime = currentSelectorTime
 						} else {
-							tl.history.pop()
+							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)
 						}
 					}
-				} 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)
-					}
 				}
-			}
-		}),
+			},
+		),
 	)
 }
 
@@ -340,9 +341,12 @@ function addAtomFamilyToTimeline(
 	)
 	tl.subscriptions.set(
 		family.key,
-		family.subject.subscribe(`timeline`, (creationOrDisposal) => {
-			handleStateLifecycleEvent(creationOrDisposal, tl, store)
-		}),
+		family.subject.subscribe(
+			`timeline`,
+			function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
+				handleStateLifecycleEvent(creationOrDisposal, tl, store)
+			},
+		),
 	)
 	for (const atom of store.atoms.values()) {
 		if (atom.family?.key === family.key) {
@@ -351,108 +355,6 @@ function addAtomFamilyToTimeline(
 	}
 }
 
-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,
-				)
-				if (creationOrDisposal.subType === `classic`) {
-					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 = stringifyJson(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>,
@@ -523,14 +425,8 @@ function filterTransactionUpdates(
 					break
 				case `molecule_creation`:
 				case `molecule_disposal`:
-					switch (updateFromTx.subType) {
-						case `classic`:
-							key = updateFromTx.token.key
-							break
-						case `modern`:
-							return true // always include
-					}
-					break
+				case `molecule_transfer`:
+					return true // always include
 				default:
 					key = updateFromTx.key
 					familyKey = updateFromTx.family?.key

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

@@ -76,14 +76,7 @@ export const timeTravel = (
 			ingestDisposalEvent(update, applying, store)
 			break
 		}
-		case `molecule_creation`: {
-			ingestMoleculeCreationEvent(update, applying, store)
-			break
-		}
-		case `molecule_disposal`: {
-			ingestMoleculeDisposalEvent(update, applying, store)
-			break
-		}
+		// consider adding molecule events
 	}
 
 	if (action === `redo`) {