atom.io 0.21.1 → 0.23.0

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

@@ -0,0 +1,104 @@
+import { parseJson } from "anvl/json"
+import type {
+	MoleculeCreation,
+	MoleculeDisposal,
+	ReadableToken,
+	StateCreation,
+	StateDisposal,
+} from "atom.io"
+import { disposeMolecule, makeMoleculeInStore } from "atom.io/immortal"
+
+import { disposeFromStore, initFamilyMember } from "../families"
+import type { Store } from "../store"
+
+export function ingestCreationEvent(
+	update: StateCreation<any>,
+	applying: `newValue` | `oldValue`,
+	store: Store,
+): void {
+	switch (applying) {
+		case `newValue`: {
+			createInStore(update.token, store)
+			break
+		}
+		case `oldValue`: {
+			disposeFromStore(update.token, store)
+			break
+		}
+	}
+}
+
+export function ingestDisposalEvent(
+	update: StateDisposal<any>,
+	applying: `newValue` | `oldValue`,
+	store: Store,
+): void {
+	switch (applying) {
+		case `newValue`: {
+			disposeFromStore(update.token, store)
+			break
+		}
+		case `oldValue`: {
+			createInStore(update.token, store)
+			store.valueMap.set(update.token.key, update.value)
+			break
+		}
+	}
+}
+
+function createInStore(token: ReadableToken<any>, store: Store): void {
+	if (token.family) {
+		const family = store.families.get(token.family.key)
+		if (family) {
+			const molecule = store.molecules.get(token.family.subKey)
+			if (molecule) {
+				molecule.bond(family)
+				return
+			}
+			if (store.config.lifespan === `immortal`) {
+				throw new Error(`No molecule found for key "${token.family.subKey}"`)
+			}
+			initFamilyMember(family, parseJson(token.family.subKey), store)
+		}
+	}
+}
+
+export function ingestMoleculeCreationEvent(
+	update: MoleculeCreation<any>,
+	applying: `newValue` | `oldValue`,
+	store: Store,
+): void {
+	switch (applying) {
+		case `newValue`:
+			makeMoleculeInStore(
+				store,
+				update.context[0],
+				update.family,
+				update.token.key,
+				...update.params,
+			)
+			break
+		case `oldValue`:
+			disposeMolecule(update.token, store)
+			break
+	}
+}
+export function ingestMoleculeDisposalEvent(
+	update: MoleculeDisposal<any>,
+	applying: `newValue` | `oldValue`,
+	store: Store,
+): void {
+	switch (applying) {
+		case `newValue`:
+			disposeMolecule(update.token, store)
+			break
+		case `oldValue`:
+			makeMoleculeInStore(
+				store,
+				update.context[0],
+				update.family,
+				update.token.key,
+			)
+			break
+	}
+}

package/internal/src/ingest-updates/ingest-transaction-update.ts

@@ -2,6 +2,12 @@ import type { TransactionUpdate } from "atom.io"
 
 import type { Store } from "../store"
 import { ingestAtomUpdate } from "./ingest-atom-update"
+import {
+	ingestCreationEvent,
+	ingestDisposalEvent,
+	ingestMoleculeCreationEvent,
+	ingestMoleculeDisposalEvent,
+} from "./ingest-creation-disposal"
 
 export function ingestTransactionUpdate(
 	applying: `newValue` | `oldValue`,
@@ -13,10 +19,26 @@ export function ingestTransactionUpdate(
 			? transactionUpdate.updates
 			: [...transactionUpdate.updates].reverse()
 	for (const updateFromTransaction of updates) {
-		if (`newValue` in updateFromTransaction) {
-			ingestAtomUpdate(applying, updateFromTransaction, store)
-		} else {
-			ingestTransactionUpdate(applying, updateFromTransaction, store)
+		switch (updateFromTransaction.type) {
+			case `atom_update`:
+			case `selector_update`:
+				ingestAtomUpdate(applying, updateFromTransaction, store)
+				break
+			case `state_creation`:
+				ingestCreationEvent(updateFromTransaction, applying, store)
+				break
+			case `state_disposal`:
+				ingestDisposalEvent(updateFromTransaction, applying, store)
+				break
+			case `molecule_creation`:
+				ingestMoleculeCreationEvent(updateFromTransaction, applying, store)
+				break
+			case `molecule_disposal`:
+				ingestMoleculeDisposalEvent(updateFromTransaction, applying, store)
+				break
+			case `transaction_update`:
+				ingestTransactionUpdate(applying, updateFromTransaction, store)
+				break
 		}
 	}
 }

package/internal/src/mutable/create-mutable-atom-family.ts

@@ -4,6 +4,8 @@ import type {
 	MutableAtomFamilyOptions,
 	MutableAtomOptions,
 	MutableAtomToken,
+	StateCreation,
+	StateDisposal,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
@@ -23,33 +25,31 @@ export function createMutableAtomFamily<
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
 ): MutableAtomFamily<T, J, K> {
-	const subject = new Subject<MutableAtomToken<T, J>>()
-	const atomFamily: MutableAtomFamily<T, J, K> = Object.assign(
+	const subject = new Subject<
+		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
+	>()
+
+	const atomFamily = Object.assign(
 		(key: K): MutableAtomToken<T, J> => {
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
 			const target = newest(store)
-			const atomAlreadyCreated = target.atoms.has(fullKey)
-			let token: MutableAtomToken<T, J>
-			if (atomAlreadyCreated) {
-				token = { type: `mutable_atom`, key: fullKey, family }
-			} else {
-				const individualOptions: MutableAtomOptions<T, J> = {
-					key: fullKey,
-					default: () => options.default(key),
-					toJson: options.toJson,
-					fromJson: options.fromJson,
-					mutable: true,
-				}
-				if (options.effects) {
-					individualOptions.effects = options.effects(key)
-				}
-
-				token = createMutableAtom(individualOptions, family, store)
 
-				subject.next(token)
+			const individualOptions: MutableAtomOptions<T, J> = {
+				key: fullKey,
+				default: () => options.default(key),
+				toJson: options.toJson,
+				fromJson: options.fromJson,
+				mutable: true,
+			}
+			if (options.effects) {
+				individualOptions.effects = options.effects(key)
 			}
+
+			const token = createMutableAtom(individualOptions, family, target)
+
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{
@@ -60,10 +60,8 @@ export function createMutableAtomFamily<
 			toJson: options.toJson,
 			fromJson: options.fromJson,
 		} as const,
-	)
-
-	const target = newest(store)
-	target.families.set(options.key, atomFamily)
+	) satisfies MutableAtomFamily<T, J, K>
+	store.families.set(options.key, atomFamily)
 	selectJsonFamily(atomFamily, options, store)
 	new FamilyTracker(atomFamily, store)
 	return atomFamily

package/internal/src/mutable/create-mutable-atom.ts

@@ -88,9 +88,9 @@ export function createMutableAtom<
 	}
 
 	new Tracker(token, store)
-	selectJson(token, options, store)
-
-	store.on.atomCreation.next(token)
+	if (!family) {
+		selectJson(token, options, store)
+	}
 
 	return token
 }

package/internal/src/mutable/get-json-family.ts

@@ -1,4 +1,4 @@
-import type { MutableAtomFamily, WritableSelectorFamily } from "atom.io"
+import type { MutableAtomFamilyToken, WritableSelectorFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -10,7 +10,7 @@ export const getJsonFamily = <
 	SerializableCore extends Json.Serializable,
 	Key extends string,
 >(
-	mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>,
+	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
 	store: Store,
 ): WritableSelectorFamily<SerializableCore, Key> => {
 	const target = newest(store)

package/internal/src/mutable/get-json-token.ts

@@ -1,6 +1,13 @@
-import type { MutableAtomToken, WritableSelectorToken } from "atom.io"
+import type {
+	MutableAtomToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+} from "atom.io"
 import type { Json } from "atom.io/json"
 
+import { findInStore } from "../families"
+import { newest } from "../lineage"
+import { type Store, withdraw } from "../store"
 import type { Transceiver } from "./transceiver"
 
 export const getJsonToken = <
@@ -8,19 +15,26 @@ export const getJsonToken = <
 	SerializableCore extends Json.Serializable,
 >(
 	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
+	store: Store,
 ): WritableSelectorToken<SerializableCore> => {
-	const key = mutableAtomToken.family
-		? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})`
-		: `${mutableAtomToken.key}:JSON`
-	const jsonToken: WritableSelectorToken<SerializableCore> = {
-		type: `selector`,
-		key,
-	}
 	if (mutableAtomToken.family) {
-		jsonToken.family = {
-			key: `${mutableAtomToken.family.key}:JSON`,
-			subKey: mutableAtomToken.family.subKey,
+		const target = newest(store)
+		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`
+		const jsonFamilyToken: WritableSelectorFamilyToken<
+			SerializableCore,
+			string
+		> = {
+			key: jsonFamilyKey,
+			type: `selector_family`,
 		}
+		const family = withdraw(jsonFamilyToken, target)
+		const subKey = JSON.parse(mutableAtomToken.family.subKey)
+		const jsonToken = findInStore(family, subKey, store)
+		return jsonToken
+	}
+	const token: WritableSelectorToken<SerializableCore> = {
+		type: `selector`,
+		key: `${mutableAtomToken.key}:JSON`,
 	}
-	return jsonToken
+	return token
 }

package/internal/src/mutable/tracker-family.ts

@@ -2,7 +2,7 @@ import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import { createRegularAtomFamily } from "../families"
+import { createRegularAtomFamily, seekInStore } from "../families"
 import type { Store } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
@@ -15,44 +15,46 @@ export class FamilyTracker<
 		? Signal
 		: never
 
-	public readonly findLatestUpdateState: RegularAtomFamily<
+	public readonly latestUpdateAtoms: RegularAtomFamily<
 		typeof this.Update | null,
 		FamilyMemberKey
 	>
-	public readonly findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>
+	public readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>
 
 	public constructor(
-		findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>,
+		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
 		store: Store,
 	) {
-		this.findLatestUpdateState = createRegularAtomFamily<
+		this.latestUpdateAtoms = createRegularAtomFamily<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
 			{
-				key: `*${findMutableState.key}`,
+				key: `*${mutableAtoms.key}`,
 				default: null,
 			},
 			store,
 		)
-		this.findMutableState = findMutableState
-		this.findMutableState.subject.subscribe(
+		this.mutableAtoms = mutableAtoms
+		this.mutableAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
-			(atomToken) => {
-				if (atomToken.family) {
-					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
-					this.findLatestUpdateState(key)
-					new Tracker<Core>(atomToken, store)
+			(event) => {
+				if (event.token.family) {
+					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
+					seekInStore(this.latestUpdateAtoms, key, store)
+					new Tracker<Core>(event.token, store)
 				}
 			},
 		)
-		this.findLatestUpdateState.subject.subscribe(
+		this.latestUpdateAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
-			(atomToken) => {
-				if (atomToken.family) {
-					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = this.findMutableState(key)
-					new Tracker<Core>(mutableAtomToken, store)
+			(event) => {
+				if (event.token.family) {
+					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
+					const mutableAtomToken = seekInStore(this.mutableAtoms, key, store)
+					if (mutableAtomToken) {
+						new Tracker<Core>(mutableAtomToken, store)
+					}
 				}
 			},
 		)

package/internal/src/not-found-error.ts

@@ -4,22 +4,35 @@ import type {
 	TimelineToken,
 	TransactionToken,
 } from "atom.io"
+import type { MoleculeFamilyToken, MoleculeToken } from "atom.io/immortal"
 
 import type { Store } from "./store"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 
 type AtomIOToken =
+	| MoleculeFamilyToken<any, any, any>
+	| MoleculeToken<any, any, any>
 	| ReadableFamilyToken<any, any>
 	| ReadableToken<any>
 	| TimelineToken<any>
 	| TransactionToken<any>
 
 function prettyPrintTokenType(token: AtomIOToken) {
-	if (token.type === `readonly_selector`) {
-		return `Readonly Selector`
+	switch (token.type) {
+		case `atom_family`:
+			return `Atom Family`
+		case `molecule_family`:
+			return `Molecule Family`
+		case `readonly_selector`:
+			return `Readonly Selector`
+		case `readonly_selector_family`:
+			return `Readonly Selector Family`
+		case `selector_family`:
+			return `Selector Family`
+		default:
+			return capitalize(token.type)
 	}
-	return capitalize(token.type)
 }
 
 export class NotFoundError extends Error {

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

@@ -19,9 +19,9 @@ export const createReadonlySelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 
-	const { get, find } = registerSelector(options.key, target)
+	const { get, find, seek, json } = registerSelector(options.key, target)
 	const getSelf = () => {
-		const value = options.get({ get, find })
+		const value = options.get({ get, find, seek, json })
 		cacheValue(options.key, value, subject, newest(store))
 		return value
 	}
@@ -50,6 +50,5 @@ export const createReadonlySelector = <T>(
 	if (family) {
 		token.family = family
 	}
-	store.on.selectorCreation.next(token)
 	return token
 }

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

@@ -24,7 +24,11 @@ export function createStandaloneSelector<T>(
 	const isWritable = `set` in options
 
 	if (isWritable) {
-		return createWritableSelector(options, undefined, store)
+		const state = createWritableSelector(options, undefined, store)
+		store.on.selectorCreation.next(state)
+		return state
 	}
-	return createReadonlySelector(options, undefined, store)
+	const state = createReadonlySelector(options, undefined, store)
+	store.on.selectorCreation.next(state)
+	return state
 }

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

@@ -22,8 +22,8 @@ export const createWritableSelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const transactors = registerSelector(options.key, target)
-	const { find, get } = transactors
-	const readonlyTransactors = { find, get }
+	const { find, get, seek, json } = transactors
+	const readonlyTransactors = { find, get, seek, json }
 
 	const getSelf = () => {
 		const value = options.get(readonlyTransactors)
@@ -70,6 +70,5 @@ export const createWritableSelector = <T>(
 	if (family) {
 		token.family = family
 	}
-	store.on.selectorCreation.next(token)
 	return token
 }

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

@@ -1,7 +1,7 @@
 import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 
 import type { Store } from ".."
-import { newest } from ".."
+import { isChildStore, newest, withdraw } from ".."
 
 export function disposeSelector(
 	selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>,
@@ -9,30 +9,74 @@ export function disposeSelector(
 ): void {
 	const target = newest(store)
 	const { key } = selectorToken
-	switch (selectorToken.type) {
-		case `selector`:
-			target.selectors.delete(key)
-			break
-		case `readonly_selector`:
-			target.readonlySelectors.delete(key)
-			break
-	}
-	target.valueMap.delete(key)
-	target.selectorAtoms.delete(key)
-	const downstreamTokens = target.selectorGraph
-		.getRelationEntries({ upstreamSelectorKey: key })
-		.filter(([_, { source }]) => source === key)
-		.map(
-			([downstreamSelectorKey]) =>
-				target.selectors.get(downstreamSelectorKey) ??
-				target.readonlySelectors.get(downstreamSelectorKey),
+	const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key)
+	if (!selector) {
+		store.logger.info(
+			`❌`,
+			`selector`,
+			key,
+			`Tried to dispose selector, but it does not exist in the store.`,
+		)
+	} else if (!selector.family) {
+		store.logger.error(
+			`❌`,
+			`selector`,
+			key,
+			`Standalone selectors cannot be disposed.`,
 		)
-	for (const downstreamToken of downstreamTokens) {
-		if (downstreamToken) {
-			disposeSelector(downstreamToken, store)
+	} else {
+		switch (selectorToken.type) {
+			case `selector`:
+				{
+					target.selectors.delete(key)
+					const family = withdraw(
+						{ key: selector.family.key, type: `selector_family` },
+						store,
+					)
+					family.subject.next({
+						type: `state_disposal`,
+						token: selectorToken,
+					})
+				}
+				break
+			case `readonly_selector`:
+				{
+					target.readonlySelectors.delete(key)
+					const family = withdraw(
+						{ key: selector.family.key, type: `readonly_selector_family` },
+						store,
+					)
+					family.subject.next({
+						type: `state_disposal`,
+						token: selectorToken,
+					})
+				}
+				break
+		}
+		target.valueMap.delete(key)
+		target.selectorAtoms.delete(key)
+		const downstreamTokens = target.selectorGraph
+			.getRelationEntries({ upstreamSelectorKey: key })
+			.filter(([_, { source }]) => source === key)
+			.map(
+				([downstreamSelectorKey]) =>
+					target.selectors.get(downstreamSelectorKey) ??
+					target.readonlySelectors.get(downstreamSelectorKey),
+			)
+		for (const downstreamToken of downstreamTokens) {
+			if (downstreamToken) {
+				disposeSelector(downstreamToken, store)
+			}
+		}
+		target.selectorGraph.delete(key)
+		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
+		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+			target.transactionMeta.update.updates.push({
+				type: `state_disposal`,
+				token: selectorToken,
+			})
+		} else {
+			store.on.selectorDisposal.next(selectorToken)
 		}
 	}
-	target.selectorGraph.delete(key)
-	store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
-	store.on.selectorDisposal.next(selectorToken)
 }

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

@@ -1,11 +1,14 @@
-import type { findState, Transactors } from "atom.io"
+import type { Transactors } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 
-import { findInStore } from "../families"
+import { findInStore, seekInStore } from "../families"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
+import { getJsonToken } from "../mutable"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
@@ -15,7 +18,7 @@ export const registerSelector = (
 	get: (dependency) => {
 		const target = newest(store)
 
-		const dependencyState = withdrawOrCreate(dependency, store)
+		const dependencyState = withdraw(dependency, store)
 		const dependencyValue = readOrComputeValue(dependencyState, store)
 
 		store.logger.info(
@@ -40,8 +43,10 @@ export const registerSelector = (
 		return dependencyValue
 	},
 	set: (WritableToken, newValue) => {
-		const state = withdrawOrCreate(WritableToken, store)
+		const state = withdraw(WritableToken, store)
 		setAtomOrSelector(state, newValue, store)
 	},
 	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
+	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
+	json: (token) => getJsonToken(token, store),
 })

package/internal/src/set-state/set-into-store.ts

@@ -2,7 +2,7 @@ import type { WritableToken } from "atom.io"
 
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
@@ -27,7 +27,7 @@ export function setIntoStore<T, New extends T>(
 		)
 		return
 	}
-	const state = withdrawOrCreate(token, store)
+	const state = withdraw(token, store)
 	setAtomOrSelector(state, value, store)
 	closeOperation(store)
 }

package/internal/src/set-state/stow-update.ts

@@ -38,7 +38,11 @@ export const stowUpdate = <T>(
 	if (!shouldStow) {
 		return
 	}
-	const atomUpdate: KeyedStateUpdate<T> = { key, ...update }
+	const atomUpdate: KeyedStateUpdate<T> = {
+		type: `atom_update`,
+		key,
+		...update,
+	}
 	if (state.family) {
 		atomUpdate.family = state.family
 	}