atom.io 0.22.0 → 0.23.0

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

@@ -1,6 +1,5 @@
 import type {
 	FamilyMetadata,
-	MutableAtomOptions,
 	RegularAtomOptions,
 	RegularAtomToken,
 	UpdateHandler,
@@ -85,6 +84,5 @@ export function createRegularAtom<T>(
 			}
 		}
 	}
-	store.on.atomCreation.next(token)
 	return token
 }

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

@@ -27,7 +27,11 @@ export function createStandaloneAtom<T>(
 	const isMutable = `mutable` in options
 
 	if (isMutable) {
-		return createMutableAtom(options, undefined, store)
+		const state = createMutableAtom(options, undefined, store)
+		store.on.atomCreation.next(state)
+		return state
 	}
-	return createRegularAtom(options, undefined, store)
+	const state = createRegularAtom(options, undefined, store)
+	store.on.atomCreation.next(state)
+	return state
 }

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

@@ -1,7 +1,13 @@
 import type { AtomToken } from "atom.io"
 
 import type { Store } from ".."
-import { disposeSelector, getUpdateToken, newest } from ".."
+import {
+	disposeSelector,
+	getUpdateToken,
+	isChildStore,
+	newest,
+	withdraw,
+} from ".."
 
 export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
@@ -18,6 +24,13 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()
+		const lastValue = store.valueMap.get(atom.key)
+		const family = withdraw({ key: atom.family.key, type: `atom_family` }, store)
+		family.subject.next({
+			type: `state_disposal`,
+			token: atomToken,
+			value: lastValue,
+		})
 		target.atoms.delete(key)
 		target.valueMap.delete(key)
 		const selectorKeys = target.selectorAtoms.getRelatedKeys(key)
@@ -40,6 +53,13 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			store.trackers.delete(key)
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)
-		store.on.atomDisposal.next(atomToken)
+		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+			target.transactionMeta.update.updates.push({
+				type: `state_disposal`,
+				token: atomToken,
+			})
+		} else {
+			store.on.atomDisposal.next(atomToken)
+		}
 	}
 }

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

@@ -3,6 +3,8 @@ import type {
 	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyOptions,
 	ReadonlySelectorToken,
+	StateCreation,
+	StateDisposal,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -16,7 +18,10 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K> {
-	const subject = new Subject<ReadonlySelectorToken<T>>()
+	const subject = new Subject<
+		| StateCreation<ReadonlySelectorToken<T>>
+		| StateDisposal<ReadonlySelectorToken<T>>
+	>()
 
 	const readonlySelectorFamily = Object.assign(
 		(key: K): ReadonlySelectorToken<T> => {
@@ -34,7 +39,7 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 				target,
 			)
 
-			subject.next(token)
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{

package/internal/src/families/create-regular-atom-family.ts

@@ -4,6 +4,8 @@ import type {
 	RegularAtomFamilyOptions,
 	RegularAtomOptions,
 	RegularAtomToken,
+	StateCreation,
+	StateDisposal,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -17,7 +19,9 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
 ): RegularAtomFamily<T, K> {
-	const subject = new Subject<RegularAtomToken<T>>()
+	const subject = new Subject<
+		StateCreation<RegularAtomToken<T>> | StateDisposal<RegularAtomToken<T>>
+	>()
 
 	const atomFamily: RegularAtomFamily<T, K> = Object.assign(
 		(key: K): RegularAtomToken<any> => {
@@ -37,7 +41,7 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 
 			const token = createRegularAtom(individualOptions, family, target)
 
-			subject.next(token)
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{

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

@@ -1,5 +1,7 @@
 import type {
 	FamilyMetadata,
+	StateCreation,
+	StateDisposal,
 	WritableSelectorFamily,
 	WritableSelectorFamilyOptions,
 	WritableSelectorToken,
@@ -16,7 +18,10 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
 ): WritableSelectorFamily<T, K> {
-	const subject = new Subject<WritableSelectorToken<T>>()
+	const subject = new Subject<
+		| StateCreation<WritableSelectorToken<T>>
+		| StateDisposal<WritableSelectorToken<T>>
+	>()
 
 	const selectorFamily = Object.assign(
 		(key: K): WritableSelectorToken<T> => {
@@ -35,7 +40,7 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 				target,
 			)
 
-			subject.next(token)
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{

package/internal/src/families/dispose-from-store.ts

@@ -0,0 +1,22 @@
+import type { ReadableToken } from "atom.io"
+import { disposeMolecule, type MoleculeToken } from "atom.io/immortal"
+import * as Internal from "atom.io/internal"
+
+export function disposeFromStore(
+	token: MoleculeToken<any, any, any> | ReadableToken<any>,
+	store: Internal.Store = Internal.IMPLICIT.STORE,
+): void {
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+			Internal.disposeAtom(token, store)
+			break
+		case `selector`:
+		case `readonly_selector`:
+			Internal.disposeSelector(token, store)
+			break
+		case `molecule`:
+			disposeMolecule(token, store)
+			break
+	}
+}

package/internal/src/families/find-in-store.ts

@@ -19,7 +19,6 @@ import type {
 import type { Json } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
-import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { initFamilyMember } from "./init-family-member"
 import { seekInStore } from "./seek-in-store"

package/internal/src/families/index.ts

@@ -2,6 +2,7 @@ export * from "./create-atom-family"
 export * from "./create-readonly-selector-family"
 export * from "./create-regular-atom-family"
 export * from "./create-selector-family"
+export * from "./dispose-from-store"
 export * from "./find-in-store"
 export * from "./init-family-member"
 export * from "./seek-in-store"

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

@@ -18,10 +18,11 @@ import type {
 } from "atom.io"
 import type { Json } from "atom.io/json"
 
+import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
-import { seekInStore } from "./seek-in-store"
+import { isChildStore } from "../transaction"
 
 export function initFamilyMember<
 	T extends Transceiver<any>,
@@ -87,5 +88,25 @@ export function initFamilyMember(
 		throw new NotFoundError(token, store)
 	}
 	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 {
+			switch (state.type) {
+				case `atom`:
+				case `mutable_atom`:
+					store.on.atomCreation.next(state)
+					break
+				case `selector`:
+				case `readonly_selector`:
+					store.on.selectorCreation.next(state)
+					break
+			}
+		}
+	}
 	return state
 }

package/internal/src/families/seek-in-store.ts

@@ -16,6 +16,11 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
+import type {
+	Molecule,
+	MoleculeFamilyToken,
+	MoleculeToken,
+} from "atom.io/immortal"
 import { type Json, stringifyJson } from "atom.io/json"
 
 import type { ReadableState } from ".."
@@ -76,28 +81,40 @@ export function seekInStore<T, K extends Json.Serializable, Key extends K>(
 	store: Store,
 ): ReadableToken<T> | undefined
 
+export function seekInStore<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+>(
+	token: MoleculeFamilyToken<K, S, any[]>,
+	key: K,
+	store: Store,
+): MoleculeToken<K, S, any[]> | undefined
+
 export function seekInStore(
-	token: ReadableFamilyToken<any, any>,
+	token: MoleculeFamilyToken<any, any, any> | ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 	store: Store,
-): ReadableToken<any> | undefined {
+): MoleculeToken<any, any, any> | ReadableToken<any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const target = newest(store)
-	let state: ReadableState<any> | undefined
+	let state: Molecule<any> | ReadableState<any> | undefined
 	switch (token.type) {
 		case `atom_family`:
 		case `mutable_atom_family`:
 			state = target.atoms.get(fullKey)
 			break
-
-		case `selector_family`: {
+		case `selector_family`:
 			state = target.selectors.get(fullKey)
 			break
-		}
 		case `readonly_selector_family`:
 			state = target.readonlySelectors.get(fullKey)
 			break
+		case `molecule_family`:
+			state = target.molecules.get(stringifyJson(key))
+			if (state) {
+				return deposit(state)
+			}
 	}
 	if (state) {
 		return deposit(state)

package/internal/src/ingest-updates/index.ts

@@ -1,3 +1,4 @@
 export * from "./ingest-atom-update"
+export * from "./ingest-creation-disposal.ts"
 export * from "./ingest-selector-update"
 export * from "./ingest-transaction-update"

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,7 +25,9 @@ export function createMutableAtomFamily<
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
 ): MutableAtomFamily<T, J, K> {
-	const subject = new Subject<MutableAtomToken<T, J>>()
+	const subject = new Subject<
+		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
+	>()
 
 	const atomFamily = Object.assign(
 		(key: K): MutableAtomToken<T, J> => {
@@ -45,7 +49,7 @@ export function createMutableAtomFamily<
 
 			const token = createMutableAtom(individualOptions, family, target)
 
-			subject.next(token)
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{

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

@@ -92,7 +92,5 @@ export function createMutableAtom<
 		selectJson(token, options, store)
 	}
 
-	store.on.atomCreation.next(token)
-
 	return token
 }

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

@@ -1,6 +1,5 @@
 import type {
 	MutableAtomToken,
-	WritableSelectorFamily,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 } from "atom.io"

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

@@ -38,19 +38,19 @@ export class FamilyTracker<
 		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
+			(event) => {
+				if (event.token.family) {
+					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
 					seekInStore(this.latestUpdateAtoms, key, store)
-					new Tracker<Core>(atomToken, store)
+					new Tracker<Core>(event.token, store)
 				}
 			},
 		)
 		this.latestUpdateAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
-			(atomToken) => {
-				if (atomToken.family) {
-					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
+			(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,12 +4,15 @@ 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>
@@ -19,6 +22,8 @@ function prettyPrintTokenType(token: AtomIOToken) {
 	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`:

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, seek } = registerSelector(options.key, target)
+	const { get, find, seek, json } = registerSelector(options.key, target)
 	const getSelf = () => {
-		const value = options.get({ get, find, seek })
+		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, seek } = transactors
-	const readonlyTransactors = { find, get, seek }
+	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>,
@@ -11,7 +11,7 @@ export function disposeSelector(
 	const { key } = selectorToken
 	const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key)
 	if (!selector) {
-		store.logger.error(
+		store.logger.info(
 			`❌`,
 			`selector`,
 			key,
@@ -27,10 +27,30 @@ export function disposeSelector(
 	} else {
 		switch (selectorToken.type) {
 			case `selector`:
-				target.selectors.delete(key)
+				{
+					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)
+				{
+					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)
@@ -50,6 +70,13 @@ export function disposeSelector(
 		}
 		target.selectorGraph.delete(key)
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
-		store.on.selectorDisposal.next(selectorToken)
+		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+			target.transactionMeta.update.updates.push({
+				type: `state_disposal`,
+				token: selectorToken,
+			})
+		} else {
+			store.on.selectorDisposal.next(selectorToken)
+		}
 	}
 }