atom.io 0.21.1 → 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)
@@ -12,10 +18,19 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			`❌`,
 			`atom`,
 			key,
-			`Tried to delete atom, but it does not exist in the store.`,
+			`Tried to dispose atom, but it does not exist in the store.`,
 		)
+	} else if (!atom.family) {
+		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)
@@ -35,8 +50,16 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
 			disposeAtom(updateToken, store)
+			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"
@@ -10,32 +12,35 @@ import { stringifyJson } from "atom.io/json"
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
-import { deposit } from "../store"
 import { Subject } from "../subject"
 
 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> => {
-			const target = newest(store)
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = target.readonlySelectors.get(fullKey)
-			if (existing) {
-				return deposit(existing)
-			}
-			return createReadonlySelector(
+			const target = newest(store)
+
+			const token = createReadonlySelector(
 				{
 					key: fullKey,
 					get: options.get(key),
 				},
 				family,
-				store,
+				target,
 			)
+
+			subject.next({ type: `state_creation`, token })
+			return token
 		},
 		{
 			key: options.key,
@@ -43,7 +48,7 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createReadonlySelectorFamily(options, s),
 		} as const,
-	) as ReadonlySelectorFamily<T, K>
+	) satisfies ReadonlySelectorFamily<T, K>
 	store.families.set(options.key, readonlySelectorFamily)
 	return readonlySelectorFamily
 }

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,31 +19,29 @@ 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> => {
 			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: RegularAtomToken<any>
-			if (atomAlreadyCreated) {
-				token = { type: `atom`, key: fullKey, family }
-			} else {
-				const individualOptions: RegularAtomOptions<any> = {
-					key: fullKey,
-					default:
-						options.default instanceof Function
-							? options.default(key)
-							: options.default,
-				}
-				if (options.effects) {
-					individualOptions.effects = options.effects(key)
-				}
-				token = createRegularAtom(individualOptions, family, store)
-				subject.next(token)
+
+			const def = options.default
+			const individualOptions: RegularAtomOptions<T> = {
+				key: fullKey,
+				default: def instanceof Function ? def(key) : def,
+			}
+			if (options.effects) {
+				individualOptions.effects = options.effects(key)
 			}
+
+			const token = createRegularAtom(individualOptions, family, target)
+
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{
@@ -50,8 +50,7 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createRegularAtomFamily(options, s),
 		} as const,
-	)
-	const target = newest(store)
-	target.families.set(options.key, atomFamily)
+	) satisfies RegularAtomFamily<T, K>
+	store.families.set(options.key, atomFamily)
 	return atomFamily
 }

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

@@ -1,5 +1,7 @@
 import type {
 	FamilyMetadata,
+	StateCreation,
+	StateDisposal,
 	WritableSelectorFamily,
 	WritableSelectorFamilyOptions,
 	WritableSelectorToken,
@@ -7,26 +9,27 @@ import type {
 import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import { newest } from "../lineage"
 import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
-import { deposit } from "../store"
 import { Subject } from "../subject"
 
 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> => {
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = store.selectors.get(fullKey)
-			if (existing) {
-				return deposit(existing)
-			}
+			const target = newest(store)
+
 			const token = createWritableSelector(
 				{
 					key: fullKey,
@@ -34,9 +37,10 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 					set: options.set(key),
 				},
 				family,
-				store,
+				target,
 			)
-			subject.next(token)
+
+			subject.next({ type: `state_creation`, token })
 			return token
 		},
 		{
@@ -45,7 +49,7 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createWritableSelectorFamily(options, s),
 		} as const,
-	) as WritableSelectorFamily<T, K>
+	) satisfies WritableSelectorFamily<T, K>
 	store.families.set(options.key, selectorFamily)
 	return selectorFamily
 }

package/{src/dispose.ts → internal/src/families/dispose-from-store.ts}

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

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

@@ -19,8 +19,9 @@ 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"
 
 export function findInStore<
 	T extends Transceiver<any>,
@@ -80,11 +81,15 @@ export function findInStore(
 	key: Json.Serializable,
 	store: Store,
 ): ReadableToken<any> {
-	const familyKey = token.key
-	const family = store.families.get(familyKey)
-	if (family === undefined) {
-		throw new NotFoundError(token, store)
+	if (store.config.lifespan === `immortal`) {
+		throw new Error(
+			`Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`,
+		)
 	}
-	const state = family(key)
+	let state = seekInStore(token, key, store)
+	if (state) {
+		return state
+	}
+	state = initFamilyMember(token, key, store)
 	return state
 }

package/internal/src/families/index.ts

@@ -2,4 +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

@@ -0,0 +1,112 @@
+import type {
+	AtomFamilyToken,
+	AtomToken,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} 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 { isChildStore } from "../transaction"
+
+export function initFamilyMember<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+	store: Store,
+): MutableAtomToken<T, J>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): RegularAtomToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableSelectorToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadonlySelectorToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadableToken<T>
+
+export function initFamilyMember(
+	token: ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+	store: Store,
+): ReadableToken<any> {
+	const familyKey = token.key
+	const family = store.families.get(familyKey)
+	if (family === undefined) {
+		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

@@ -0,0 +1,123 @@
+import type {
+	AtomFamilyToken,
+	AtomToken,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	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 ".."
+import { newest } from "../lineage"
+import type { Transceiver } from "../mutable"
+import { deposit, type Store } from "../store"
+
+export function seekInStore<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+	store: Store,
+): MutableAtomToken<T, J> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): RegularAtomToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableSelectorToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadonlySelectorToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	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: MoleculeFamilyToken<any, any, any> | ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+	store: Store,
+): MoleculeToken<any, any, any> | ReadableToken<any> | undefined {
+	const subKey = stringifyJson(key)
+	const fullKey = `${token.key}(${subKey})`
+	const target = newest(store)
+	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`:
+			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)
+	}
+	return state
+}

package/internal/src/get-state/get-from-store.ts

@@ -1,10 +1,10 @@
 import type { ReadableToken } from "atom.io"
 
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
 export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {
-	const state = withdrawOrCreate(token, store)
+	const state = withdraw(token, store)
 	return readOrComputeValue(state, store)
 }

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"