atom.io 0.23.5 → 0.24.0

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

@@ -1,6 +1,10 @@
 import type {
 	AtomFamilyToken,
 	AtomToken,
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -16,14 +20,9 @@ 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 ".."
+import type { Molecule, ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { deposit, type Store } from "../store"
@@ -81,20 +80,17 @@ 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,
+export function seekInStore<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
 	store: Store,
-): MoleculeToken<K, S, any[]> | undefined
+): MoleculeKey<M> | undefined
 
 export function seekInStore(
-	token: MoleculeFamilyToken<any, any, any> | ReadableFamilyToken<any, any>,
+	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 	store: Store,
-): MoleculeToken<any, any, any> | ReadableToken<any> | undefined {
+): MoleculeToken<any> | ReadableToken<any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const target = newest(store)

package/internal/src/get-environment-data.ts

@@ -1,15 +1,11 @@
 import type { Store } from "./store"
 
 export type EnvironmentData = {
-	window: typeof window | undefined
-	global: typeof global | undefined
 	store: Store
 }
 
 export function getEnvironmentData(store: Store): EnvironmentData {
 	return {
-		window: typeof window === `undefined` ? undefined : window,
-		global: typeof global === `undefined` ? undefined : global,
 		store,
 	}
 }

package/internal/src/index.ts

@@ -16,6 +16,7 @@ export * from "./ingest-updates"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./lineage"
+export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"

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

@@ -1,4 +1,3 @@
-import { parseJson } from "anvl/json"
 import type {
 	MoleculeCreation,
 	MoleculeDisposal,
@@ -6,9 +5,10 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import { disposeMolecule, makeMoleculeInStore } from "atom.io/immortal"
+import { parseJson } from "atom.io/json"
 
-import { disposeFromStore, initFamilyMember } from "../families"
+import { disposeFromStore, initFamilyMemberInStore } from "../families"
+import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
 import type { Store } from "../store"
 
 export function ingestCreationEvent(
@@ -52,13 +52,13 @@ function createInStore(token: ReadableToken<any>, store: Store): void {
 		if (family) {
 			const molecule = store.molecules.get(token.family.subKey)
 			if (molecule) {
-				molecule.bond(family)
+				growMoleculeInStore(molecule, family, store)
 				return
 			}
 			if (store.config.lifespan === `immortal`) {
 				throw new Error(`No molecule found for key "${token.family.subKey}"`)
 			}
-			initFamilyMember(family, parseJson(token.family.subKey), store)
+			initFamilyMemberInStore(family, parseJson(token.family.subKey), store)
 		}
 	}
 }
@@ -79,18 +79,18 @@ export function ingestMoleculeCreationEvent(
 			)
 			break
 		case `oldValue`:
-			disposeMolecule(update.token, store)
+			disposeFromStore(update.token, store)
 			break
 	}
 }
 export function ingestMoleculeDisposalEvent(
-	update: MoleculeDisposal<any>,
+	update: MoleculeDisposal,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
 	switch (applying) {
 		case `newValue`:
-			disposeMolecule(update.token, store)
+			disposeFromStore(update.token, store)
 			break
 		case `oldValue`:
 			makeMoleculeInStore(

package/internal/src/molecule/create-molecule-family.ts

@@ -0,0 +1,30 @@
+import type {
+	MoleculeConstructor,
+	MoleculeCreation,
+	MoleculeFamily,
+	MoleculeFamilyOptions,
+	MoleculeFamilyToken,
+} from "atom.io"
+
+import type { Store } from "../store"
+import { Subject } from "../subject"
+
+export function createMoleculeFamily<M extends MoleculeConstructor>(
+	options: MoleculeFamilyOptions<M>,
+	store: Store,
+): MoleculeFamilyToken<M> {
+	const subject = new Subject<MoleculeCreation<M>>()
+
+	const token = {
+		type: `molecule_family`,
+		key: options.key,
+		dependsOn: options.dependsOn ?? `all`,
+	} as const satisfies MoleculeFamilyToken<M>
+	const family = {
+		...token,
+		subject,
+		new: options.new,
+	} satisfies MoleculeFamily<M>
+	store.moleculeFamilies.set(options.key, family)
+	return token
+}

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

@@ -0,0 +1,76 @@
+import type {
+	MoleculeConstructor,
+	MoleculeDisposal,
+	MoleculeToken,
+} from "atom.io"
+
+import { disposeFromStore } from "../families"
+import type { Store } from "../store"
+import { deposit, withdraw } from "../store"
+import { isChildStore } from "../transaction"
+import type { Molecule } from "./molecule-internal"
+
+export function disposeMolecule<M extends MoleculeConstructor>(
+	token: MoleculeToken<M>,
+	store: Store,
+): void {
+	let molecule: Molecule<M>
+	try {
+		molecule = withdraw(token, store)
+	} catch (thrown) {
+		if (thrown instanceof Error) {
+			store.logger.error(
+				`🐞`,
+				`molecule`,
+				JSON.stringify(token.key),
+				`Failed to dispose molecule, because it was not found in the store.`,
+				thrown.message,
+			)
+		}
+		return
+	}
+	const { family } = token
+	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`),
+		}
+		if (token.family) {
+			disposalEvent.family = token.family
+		}
+		const isTransaction =
+			isChildStore(store) && store.transactionMeta.phase === `building`
+		if (isTransaction) {
+			store.transactionMeta.update.updates.push(disposalEvent)
+		} else {
+			Formula.subject.next(disposalEvent)
+		}
+		store.molecules.delete(molecule.stringKey)
+	}
+
+	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)
+			}
+		}
+	}
+	for (const join of molecule.joins.values()) {
+		join.molecules.delete(molecule.stringKey)
+	}
+	for (const parent of molecule.above.values()) {
+		parent.below.delete(molecule.stringKey)
+	}
+}

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

@@ -0,0 +1,89 @@
+import type {
+	AtomFamily,
+	AtomToken,
+	MutableAtomFamily,
+	MutableAtomToken,
+	ReadableFamily,
+	ReadableToken,
+	ReadonlySelectorFamily,
+	ReadonlySelectorToken,
+	RegularAtomFamily,
+	RegularAtomToken,
+	SelectorFamily,
+	SelectorToken,
+	WritableFamily,
+	WritableSelectorFamily,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { initFamilyMemberInStore } from "../families"
+import type { Transceiver } from "../mutable"
+import type { Store } from "../store"
+import { isChildStore } from "../transaction"
+import type { Molecule } from "./molecule-internal"
+
+export function growMoleculeInStore<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+>(
+	molecule: Molecule<any>,
+	family: MutableAtomFamily<T, J, K>,
+	store: Store,
+): MutableAtomToken<T, J>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: RegularAtomFamily<T, K>,
+	store: Store,
+): RegularAtomToken<T>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: AtomFamily<T, K>,
+	store: Store,
+): AtomToken<T>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: WritableSelectorFamily<T, K>,
+	store: Store,
+): WritableSelectorToken<T>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: ReadonlySelectorFamily<T, K>,
+	store: Store,
+): ReadonlySelectorToken<T>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: SelectorFamily<T, K>,
+	store: Store,
+): SelectorToken<T>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: WritableFamily<T, K>,
+	store: Store,
+): WritableToken<T>
+export function growMoleculeInStore<T, K extends Json.Serializable>(
+	molecule: Molecule<any>,
+	family: ReadableFamily<T, K>,
+	store: Store,
+): ReadableToken<T>
+export function growMoleculeInStore(
+	molecule: Molecule<any>,
+	family: ReadableFamily<any, any>,
+	store: Store,
+): ReadableToken<any> {
+	const stateToken = initFamilyMemberInStore(family, molecule.key, store)
+	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 {
+		molecule.subject.next({ type: `state_creation`, token: stateToken })
+	}
+	return stateToken
+}

package/internal/src/molecule/index.ts

@@ -0,0 +1,5 @@
+export * from "./create-molecule-family"
+export * from "./dispose-molecule"
+export * from "./grow-molecule-in-store"
+export * from "./make-molecule-in-store"
+export * from "./molecule-internal"

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

@@ -0,0 +1,122 @@
+import type {
+	MK,
+	MoleculeConstructor,
+	MoleculeCreation,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeParams,
+	MoleculeToken,
+	MoleculeTransactors,
+	ReadableFamilyToken,
+} from "atom.io"
+import { getJoin, type JoinToken } from "atom.io/data"
+import type { seekState } from "atom.io/immortal"
+import { stringifyJson } from "atom.io/json"
+
+import { arbitrary } from "../arbitrary"
+import { disposeFromStore, seekInStore } from "../families"
+import { getEnvironmentData } from "../get-environment-data"
+import { getFromStore } from "../get-state"
+import { newest } from "../lineage"
+import { getJsonToken } from "../mutable"
+import { setIntoStore } from "../set-state"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import { actUponStore, isChildStore } from "../transaction"
+import { growMoleculeInStore } from "./grow-molecule-in-store"
+import { Molecule } from "./molecule-internal"
+
+export function makeMoleculeInStore<M extends MoleculeConstructor>(
+	store: Store,
+	context: MoleculeToken<M> | MoleculeToken<M>[],
+	familyToken: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+	...params: MoleculeParams<M>
+): MoleculeToken<M> {
+	const target = newest(store)
+
+	const token = {
+		type: `molecule`,
+		key,
+		family: familyToken,
+	} as const satisfies MoleculeToken<M>
+
+	const contextArray = Array.isArray(context) ? context : [context]
+	const owners = contextArray.map<Molecule<M>>((ctx) => {
+		if (ctx instanceof Molecule) {
+			return ctx
+		}
+		const stringKey = stringifyJson(ctx.key)
+		const molecule = store.molecules.get(stringKey)
+
+		if (!molecule) {
+			throw new Error(
+				`Molecule ${stringKey} not found in store "${store.config.name}"`,
+			)
+		}
+		return molecule
+	})
+
+	const family = withdraw(familyToken, store)
+	const molecule = new Molecule(owners, key, family)
+	target.molecules.set(stringifyJson(key), molecule)
+	for (const owner of owners) {
+		owner.below.set(molecule.stringKey, molecule)
+	}
+
+	const transactors = {
+		get: (t) => getFromStore(t, newest(store)),
+		set: (t, newValue) => {
+			setIntoStore(t, newValue, newest(store))
+		},
+		seek: ((t, k) => seekInStore(t, k, newest(store))) as typeof seekState,
+		json: (t) => getJsonToken(t, newest(store)),
+		run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
+		make: (ctx, f, k, ...args) =>
+			makeMoleculeInStore(newest(store), ctx, f, k, ...args),
+		dispose: (t) => {
+			disposeFromStore(t, newest(store))
+		},
+		env: () => getEnvironmentData(newest(store)),
+		bond: ((f: ReadableFamilyToken<any, any>) =>
+			growMoleculeInStore(
+				molecule,
+				withdraw(f, store),
+				newest(store),
+			)) as MoleculeTransactors<MK<M>>[`bond`],
+		join: (joinToken: JoinToken<any, any, any, any>) => {
+			const join = getJoin(joinToken, store)
+			join.molecules.set(stringifyJson(key), molecule)
+			molecule.joins.set(joinToken.key, join)
+		},
+		spawn: (f: MoleculeFamilyToken<any>, k: any, ...p: any[]) =>
+			makeMoleculeInStore(
+				newest(store),
+				[molecule],
+				withdraw(f, store),
+				k,
+				...p,
+			),
+	} satisfies MoleculeTransactors<MK<M>>
+	const Constructor = family.new
+
+	molecule.instance = new Constructor(transactors, token.key, ...params)
+
+	const update = {
+		type: `molecule_creation`,
+		token,
+		family,
+		context: contextArray,
+		params,
+	} satisfies MoleculeCreation<M>
+
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.updates.push(update)
+	} else {
+		family.subject.next(update)
+	}
+
+	return token
+}

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

@@ -0,0 +1,48 @@
+import type {
+	MK,
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeToken,
+	ReadableToken,
+	StateCreation,
+	StateDisposal,
+} from "atom.io"
+import type { Join } from "atom.io/data"
+import { stringifyJson } from "atom.io/json"
+
+import { Subject } from "../subject"
+
+export class Molecule<M extends MoleculeConstructor>
+	implements MoleculeToken<M>
+{
+	public readonly type = `molecule`
+	public stringKey: string
+	public family?: MoleculeFamilyToken<M>
+	public readonly subject = new Subject<
+		StateCreation<any> | StateDisposal<any>
+	>()
+	public tokens = new Map<string, ReadableToken<any>>()
+	public above = new Map<string, Molecule<any>>()
+	public below = new Map<string, Molecule<any>>()
+	public joins = new Map<string, Join<any, any, any, any>>()
+	public instance: InstanceType<M>
+	public constructor(
+		ctx: Molecule<any> | Molecule<any>[] | undefined,
+		public readonly key: MK<M>,
+		family?: MoleculeFamilyToken<M>,
+	) {
+		this.stringKey = stringifyJson(key)
+		if (family) {
+			this.family = family
+		}
+		if (ctx) {
+			if (Array.isArray(ctx)) {
+				for (const molecule of ctx) {
+					this.above.set(molecule.stringKey, molecule)
+				}
+			} else {
+				this.above.set(ctx.stringKey, ctx)
+			}
+		}
+	}
+}

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

@@ -1,18 +1,19 @@
 import type {
+	MoleculeFamilyToken,
+	MoleculeToken,
 	ReadableFamilyToken,
 	ReadableToken,
 	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>
+	| MoleculeFamilyToken<any>
+	| MoleculeToken<any>
 	| ReadableFamilyToken<any, any>
 	| ReadableToken<any>
 	| TimelineToken<any>

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

@@ -1,7 +1,6 @@
 import type { StateUpdate } from "atom.io"
-import type { Store } from "atom.io/internal"
 
-import type { Atom, Selector } from ".."
+import type { Atom, Selector, Store } from ".."
 
 export const emitUpdate = <T>(
 	state: Atom<T> | Selector<T>,

package/internal/src/store/deposit.ts

@@ -1,6 +1,9 @@
 import type {
 	AtomToken,
 	Func,
+	MoleculeFamily,
+	MoleculeFamilyToken,
+	MoleculeToken,
 	MutableAtomToken,
 	ReadableToken,
 	ReadonlySelectorToken,
@@ -10,16 +13,11 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type {
-	Molecule,
-	MoleculeFamily,
-	MoleculeFamilyToken,
-	MoleculeToken,
-} from "atom.io/immortal"
 import type { Json } from "atom.io/json"
 
 import type {
 	Atom,
+	Molecule,
 	MutableAtom,
 	ReadableState,
 	ReadonlySelector,
@@ -44,12 +42,12 @@ export function deposit<
 	K extends Json.Serializable,
 	S extends { [key: string]: any },
 	P extends any[],
->(state: Molecule<K>): MoleculeToken<K, S, P>
+>(state: Molecule<any>): MoleculeToken<any>
 export function deposit<
 	K extends Json.Serializable,
 	S extends { [key: string]: any },
 	P extends any[],
->(state: MoleculeFamily<K, S, P>): MoleculeFamilyToken<K, S, P>
+>(state: MoleculeFamily<any>): MoleculeFamilyToken<any>
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
@@ -57,7 +55,7 @@ export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T>(
 	state:
 		| Molecule<any>
-		| MoleculeFamily<any, any, any>
+		| MoleculeFamily<any>
 		| ReadableState<T>
 		| ReadonlySelector<T>
 		| RegularAtom<T>
@@ -65,30 +63,18 @@ export function deposit<T>(
 		| WritableSelector<T>
 		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
 ):
-	| MoleculeFamilyToken<any, any, any>
-	| MoleculeToken<any, any, any>
+	| MoleculeFamilyToken<any>
+	| MoleculeToken<any>
 	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
 	| RegularAtomToken<T>
 	| SelectorToken<T>
 	| TransactionToken<T extends Func ? T : never> {
-	const { type } = state
-	switch (type) {
-		case `atom`:
-		case `molecule_family`:
-		case `mutable_atom`:
-		case `selector`:
-		case `readonly_selector`:
-		case `transaction`: {
-			const token = {
-				key: state.key,
-				type: state.type,
-			} as any
-			if (`family` in state) {
-				token.family = state.family
-			}
-			return token
-		}
-		case `molecule`:
-			return state.token
+	const token = {
+		key: state.key,
+		type: state.type,
+	} as any
+	if (`family` in state) {
+		token.family = state.family
 	}
+	return token
 }

package/internal/src/store/store.ts

@@ -2,8 +2,8 @@ import type {
 	AtomToken,
 	Func,
 	Logger,
-	MoleculeCreation,
-	MoleculeDisposal,
+	MoleculeFamily,
+	MoleculeToken,
 	MutableAtomFamily,
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
@@ -14,17 +14,12 @@ import type {
 	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
-import type { Molecule } from "atom.io/immortal"
-import type { Json } from "atom.io/json"
 
-import type {
-	MoleculeFamily,
-	MoleculeToken,
-} from "~/packages/atom.io/immortal/src/make-molecule"
 import { Junction } from "~/packages/rel8/junction/src"
 
 import type {
 	Atom,
+	Molecule,
 	ReadonlySelector,
 	Tracker,
 	Transceiver,
@@ -89,7 +84,7 @@ export class Store implements Lineage {
 	)
 
 	public molecules = new Map<string, Molecule<any>>()
-	public moleculeFamilies = new Map<string, MoleculeFamily<any, any, any>>()
+	public moleculeFamilies = new Map<string, MoleculeFamily<any>>()
 	public miscResources = new Map<string, Disposable>()
 
 	public on = {
@@ -107,9 +102,9 @@ export class Store implements Lineage {
 			null,
 		),
 		operationClose: new Subject<OperationProgress>(),
-		moleculeCreationStart: new Subject<MoleculeToken<any, any, any>>(),
-		moleculeCreationDone: new Subject<MoleculeToken<any, any, any>>(),
-		moleculeDisposal: new Subject<MoleculeToken<any, any, any>>(),
+		moleculeCreationStart: new Subject<MoleculeToken<any>>(),
+		moleculeCreationDone: new Subject<MoleculeToken<any>>(),
+		moleculeDisposal: new Subject<MoleculeToken<any>>(),
 	}
 	public operation: OperationProgress = { open: false }
 	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {