atom.io 0.24.4 → 0.24.6

package/internal/src/atom/dispose-atom.ts

@@ -31,6 +31,10 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			token: atomToken,
 			value: lastValue,
 		})
+		const molecule = target.molecules.get(atom.family.subKey)
+		if (molecule) {
+			molecule.tokens.delete(key)
+		}
 		target.atoms.delete(key)
 		target.valueMap.delete(key)
 		const selectorKeys = target.selectorAtoms.getRelatedKeys(key)
@@ -46,7 +50,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		}
 		target.selectorAtoms.delete(key)
 		target.atomsThatAreDefault.delete(key)
-		target.timelineAtoms.delete(key)
+		target.timelineTopics.delete(key)
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
 			disposeAtom(updateToken, store)

package/internal/src/families/init-family-member.ts

@@ -22,7 +22,7 @@ import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
-import { isChildStore } from "../transaction"
+import { isChildStore, isRootStore } from "../transaction"
 
 export function initFamilyMemberInStore<
 	T extends Transceiver<any>,
@@ -101,13 +101,8 @@ export function initFamilyMemberInStore(
 	}
 	const state = family(key)
 	const target = newest(store)
-	if (state.family) {
-		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
-			target.transactionMeta.update.updates.push({
-				type: `state_creation`,
-				token: state,
-			})
-		} else {
+	if (state.family && target.moleculeInProgress === null) {
+		if (isRootStore(target)) {
 			switch (state.type) {
 				case `atom`:
 				case `mutable_atom`:
@@ -118,6 +113,14 @@ export function initFamilyMemberInStore(
 					store.on.selectorCreation.next(state)
 					break
 			}
+		} else if (
+			isChildStore(target) &&
+			target.on.transactionApplying.state === null
+		) {
+			target.transactionMeta.update.updates.push({
+				type: `state_creation`,
+				token: state,
+			})
 		}
 	}
 	return state

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -5,11 +5,12 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import { parseJson } from "atom.io/json"
+import { parseJson, stringifyJson } from "atom.io/json"
 
 import { disposeFromStore, initFamilyMemberInStore } from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
-import type { Store } from "../store"
+import { setIntoStore } from "../set-state"
+import { type Store, withdraw } from "../store"
 
 export function ingestCreationEvent(
 	update: StateCreation<any>,
@@ -72,7 +73,7 @@ export function ingestMoleculeCreationEvent(
 		case `newValue`:
 			makeMoleculeInStore(
 				store,
-				update.context[0],
+				update.context,
 				update.family,
 				update.token.key,
 				...update.params,
@@ -93,12 +94,24 @@ export function ingestMoleculeDisposalEvent(
 			disposeFromStore(update.token, store)
 			break
 		case `oldValue`:
-			makeMoleculeInStore(
-				store,
-				update.context[0],
-				update.family,
-				update.token.key,
-			)
+			{
+				const moleculeToken = makeMoleculeInStore(
+					store,
+					update.context,
+					update.family,
+					update.token.key,
+				)
+				for (const [familyKey, value] of update.values) {
+					const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`
+					const molecule = withdraw(moleculeToken, store)
+					const alreadyCreated = molecule.tokens.has(memberKey)
+					const family = store.families.get(familyKey)
+					if (family && !alreadyCreated) {
+						growMoleculeInStore(molecule, family, store)
+					}
+					store.valueMap.set(memberKey, value)
+				}
+			}
 			break
 	}
 }

package/internal/src/molecule/dispose-molecule.ts

@@ -1,3 +1,4 @@
+import { stringifyJson } from "anvl/json"
 import type {
 	MoleculeConstructor,
 	MoleculeDisposal,
@@ -31,34 +32,44 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 	}
 	const { family } = token
 
-	for (const state of molecule.tokens.values()) {
-		disposeFromStore(state, store)
+	const context: MoleculeToken<any>[] = []
+	for (const above of molecule.above.values()) {
+		context.push(deposit(above))
 	}
-	for (const child of molecule.below.values()) {
-		if (child.family?.dependsOn === `all`) {
-			disposeMolecule(child, store)
-		} else {
-			child.above.delete(molecule.stringKey)
-			if (child.above.size === 0) {
-				disposeMolecule(child, store)
-			}
-		}
+	const values: [string, any][] = []
+	for (const stateToken of molecule.tokens.values()) {
+		// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
+		const tokenFamily = stateToken.family!
+		values.push([tokenFamily.key, store.valueMap.get(stateToken.key)])
 	}
-	molecule.below.clear()
+
 	if (family) {
 		const Formula = withdraw(family, store)
 		const disposalEvent: MoleculeDisposal = {
 			type: `molecule_disposal`,
 			token,
 			family,
-			context: [...molecule.above.values()].map((m) => deposit(m)),
-			familyKeys: [...molecule.tokens.values()]
-				.map((t) => t.family?.key)
-				.filter((k): k is string => typeof k === `string`),
+			context,
+			values,
 		}
 		if (token.family) {
 			disposalEvent.family = token.family
 		}
+		for (const state of molecule.tokens.values()) {
+			disposeFromStore(state, store)
+		}
+		for (const child of molecule.below.values()) {
+			if (child.family?.dependsOn === `all`) {
+				disposeMolecule(child, store)
+			} else {
+				child.above.delete(molecule.stringKey)
+				if (child.above.size === 0) {
+					disposeMolecule(child, store)
+				}
+			}
+		}
+		molecule.below.clear()
+
 		const isTransaction =
 			isChildStore(store) && store.transactionMeta.phase === `building`
 		if (isTransaction) {

package/internal/src/molecule/grow-molecule-in-store.ts

@@ -77,12 +77,8 @@ export function growMoleculeInStore(
 	molecule.tokens.set(stateToken.key, stateToken)
 	const isTransaction =
 		isChildStore(store) && store.transactionMeta.phase === `building`
-	if (isTransaction) {
-		store.transactionMeta.update.updates.push({
-			type: `state_creation`,
-			token: stateToken,
-		})
-	} else {
+	const moleculeInProgress = store.moleculeInProgress === molecule.key
+	if (!isTransaction && !moleculeInProgress) {
 		molecule.subject.next({ type: `state_creation`, token: stateToken })
 	}
 	return stateToken

package/internal/src/molecule/make-molecule-in-store.ts

@@ -22,7 +22,7 @@ import { getJsonToken } from "../mutable"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import { actUponStore, isChildStore } from "../transaction"
+import { actUponStore, isChildStore, isRootStore } from "../transaction"
 import { growMoleculeInStore } from "./grow-molecule-in-store"
 import { Molecule } from "./molecule-internal"
 
@@ -35,11 +35,7 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 ): MoleculeToken<M> {
 	const target = newest(store)
 
-	const token = {
-		type: `molecule`,
-		key,
-		family: familyToken,
-	} as const satisfies MoleculeToken<M>
+	target.moleculeInProgress = key
 
 	const contextArray = Array.isArray(context) ? context : [context]
 	const owners = contextArray.map<Molecule<M>>((ctx) => {
@@ -57,8 +53,7 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 		return molecule
 	})
 
-	const family = withdraw(familyToken, store)
-	const molecule = new Molecule(owners, key, family)
+	const molecule = new Molecule(owners, key, familyToken)
 	target.molecules.set(stringifyJson(key), molecule)
 	for (const owner of owners) {
 		owner.below.set(molecule.stringKey, molecule)
@@ -116,25 +111,36 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 				...p,
 			),
 	} satisfies MoleculeTransactors<MK<M>>
+
+	const family = withdraw(familyToken, store)
 	const Constructor = family.new
 
-	molecule.instance = new Constructor(transactors, token.key, ...params)
+	molecule.instance = new Constructor(transactors, key, ...params)
+
+	const token = {
+		type: `molecule`,
+		key,
+		family: familyToken,
+	} as const satisfies MoleculeToken<M>
 
 	const update = {
 		type: `molecule_creation`,
 		token,
-		family,
+		family: familyToken,
 		context: contextArray,
 		params,
 	} satisfies MoleculeCreation<M>
 
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.updates.push(update)
-	} else {
+	if (isRootStore(target)) {
 		family.subject.next(update)
+	} else if (
+		isChildStore(target) &&
+		target.on.transactionApplying.state === null
+	) {
+		target.transactionMeta.update.updates.push(update)
 	}
 
+	target.moleculeInProgress = null
+
 	return token
 }

package/internal/src/mutable/tracker.ts

@@ -98,7 +98,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		subscribeToState(
 			latestUpdateState,
 			({ newValue, oldValue }) => {
-				const timelineId = target.timelineAtoms.getRelatedKey(
+				const timelineId = target.timelineTopics.getRelatedKey(
 					latestUpdateState.key,
 				)
 

package/internal/src/selector/create-writable-selector.ts

@@ -8,10 +8,10 @@ import type { WritableSelector } from ".."
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
 import { markDone } from "../operation"
-import { become } from "../set-state/become"
+import { become } from "../set-state"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { isRootStore } from "../transaction/is-root-store"
+import { isRootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export const createWritableSelector = <T>(
@@ -25,14 +25,15 @@ export const createWritableSelector = <T>(
 	const { find, get, seek, json } = transactors
 	const readonlyTransactors = { find, get, seek, json }
 
-	const getSelf = () => {
+	const getSelf = (innerTarget = newest(store)): T => {
 		const value = options.get(readonlyTransactors)
-		cacheValue(options.key, value, subject, newest(store))
+		cacheValue(options.key, value, subject, innerTarget)
 		return value
 	}
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
-		const oldValue = getSelf()
+		const innerTarget = newest(store)
+		const oldValue = getSelf(innerTarget)
 		const newValue = become(next)(oldValue)
 		store.logger.info(
 			`📝`,
@@ -44,9 +45,9 @@ export const createWritableSelector = <T>(
 			newValue,
 			`)`,
 		)
-		cacheValue(options.key, newValue, subject, store)
-		markDone(options.key, store)
-		if (isRootStore(target)) {
+		cacheValue(options.key, newValue, subject, innerTarget)
+		markDone(options.key, innerTarget)
+		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })
 		}
 		options.set(transactors, newValue)

package/internal/src/selector/dispose-selector.ts

@@ -25,6 +25,10 @@ export function disposeSelector(
 			`Standalone selectors cannot be disposed.`,
 		)
 	} else {
+		const molecule = target.molecules.get(selector.family.subKey)
+		if (molecule) {
+			molecule.tokens.delete(key)
+		}
 		switch (selectorToken.type) {
 			case `selector`:
 				{

package/internal/src/selector/register-selector.ts

@@ -43,8 +43,9 @@ export const registerSelector = (
 		return dependencyValue
 	},
 	set: (WritableToken, newValue) => {
-		const state = withdraw(WritableToken, store)
-		setAtomOrSelector(state, newValue, store)
+		const target = newest(store)
+		const state = withdraw(WritableToken, target)
+		setAtomOrSelector(state, newValue, target)
 	},
 	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
 	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,

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

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

package/internal/src/store/store.ts

@@ -35,7 +35,7 @@ import type {
 	TransactionEpoch,
 	TransactionProgress,
 } from "../transaction"
-import { isRootStore } from "../transaction/is-root-store"
+import { isRootStore } from "../transaction"
 
 export class Store implements Lineage {
 	public parent: Store | null = null
@@ -47,24 +47,7 @@ export class Store implements Lineage {
 	public selectors = new Map<string, WritableSelector<any>>()
 	public readonlySelectors = new Map<string, ReadonlySelector<any>>()
 
-	public trackers = new Map<string, Tracker<Transceiver<any>>>()
-	public families = new Map<
-		string,
-		| MutableAtomFamily<any, any, any>
-		| ReadonlySelectorFamily<any, any>
-		| RegularAtomFamily<any, any>
-		| WritableSelectorFamily<any, any>
-	>()
-
-	public timelines = new Map<string, Timeline<any>>()
-	public transactions = new Map<string, Transaction<Func>>()
-
 	public atomsThatAreDefault = new Set<string>()
-
-	public timelineAtoms = new Junction({
-		between: [`timelineKey`, `atomKey`],
-		cardinality: `1:n`,
-	})
 	public selectorAtoms = new Junction({
 		between: [`selectorKey`, `atomKey`],
 		cardinality: `n:n`,
@@ -82,9 +65,37 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
+	public trackers = new Map<string, Tracker<Transceiver<any>>>()
+	public families = new Map<
+		string,
+		| MutableAtomFamily<any, any, any>
+		| ReadonlySelectorFamily<any, any>
+		| RegularAtomFamily<any, any>
+		| WritableSelectorFamily<any, any>
+	>()
+
+	public transactions = new Map<string, Transaction<Func>>()
+	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {
+		epoch: new Map<string, number>(),
+		actionContinuities: new Junction({
+			between: [`continuity`, `action`],
+			cardinality: `1:n`,
+		}),
+	}
+
+	public timelines = new Map<string, Timeline<any>>()
+	public timelineTopics = new Junction<
+		`timelineKey`,
+		`topicKey`,
+		{ topicType: `atom_family` | `atom` | `molecule_family` | `molecule` }
+	>({
+		between: [`timelineKey`, `topicKey`],
+		cardinality: `1:n`,
+	})
 
 	public molecules = new Map<string, Molecule<any>>()
 	public moleculeFamilies = new Map<string, MoleculeFamily<any>>()
+	public moleculeInProgress: string | null = null
 	public miscResources = new Map<string, Disposable>()
 
 	public on = {
@@ -107,13 +118,6 @@ export class Store implements Lineage {
 		moleculeDisposal: new Subject<MoleculeToken<any>>(),
 	}
 	public operation: OperationProgress = { open: false }
-	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {
-		epoch: new Map<string, number>(),
-		actionContinuities: new Junction({
-			between: [`continuity`, `action`],
-			cardinality: `1:n`,
-		}),
-	}
 
 	public config: {
 		name: string