atom.io 0.22.0 → 0.23.0

package/immortal/src/molecule.ts

@@ -7,30 +7,58 @@ import type {
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
+	StateCreation,
+	StateDisposal,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import { disposeState } from "atom.io"
 import type { Join, JoinToken } from "atom.io/data"
 import { getJoin } from "atom.io/data"
 import type { Store, Transceiver } from "atom.io/internal"
-import { getJsonFamily, IMPLICIT, initFamilyMember } from "atom.io/internal"
+import {
+	disposeFromStore,
+	getJsonFamily,
+	initFamilyMember,
+	newest,
+	Subject,
+} from "atom.io/internal"
 import { type Json, stringifyJson } from "atom.io/json"
 
+import type { MoleculeFamilyToken, MoleculeToken } from "./make-molecule"
+
 export class Molecule<Key extends Json.Serializable> {
+	public readonly type = `molecule`
+	public get key(): Key {
+		return this.token.key
+	}
+	public readonly family?: MoleculeFamilyToken<Key, any, any>
+	public readonly above: Molecule<any>[]
 	public readonly below: Molecule<any>[] = []
 	public readonly tokens: ReadableToken<any>[] = []
 	public readonly joins: Join<any, any, any, any>[] = []
+	public readonly subject = new Subject<
+		StateCreation<any> | StateDisposal<any>
+	>()
 	public constructor(
-		public readonly key: Key,
-		public readonly above: Molecule<any>[] = [],
-		public readonly store: Store = IMPLICIT.STORE,
+		public readonly store: Store,
+		above: Molecule<any> | Molecule<any>[] | undefined,
+		public readonly token: MoleculeToken<Key, any, any>,
 	) {
-		store.molecules.set(stringifyJson(key), this)
-		for (const parent of above) {
-			parent.below.push(this)
+		// store.molecules.set(stringifyJson(key), this) // consider removing this
+		if (above) {
+			if (Array.isArray(above)) {
+				this.above = above
+				for (const parent of above) {
+					parent.below.push(this)
+				}
+			} else {
+				this.above = [above]
+				above.below.push(this)
+			}
+		} else {
+			this.above = []
 		}
 	}
 
@@ -55,24 +83,28 @@ export class Molecule<Key extends Json.Serializable> {
 		token: ReadableFamilyToken<T, K>,
 	): ReadableToken<T>
 	public bond(token: ReadableFamilyToken<any, any>): ReadableToken<any> {
-		const state = initFamilyMember(token, this.key, this.store)
+		const state = initFamilyMember(token, this.token.key, this.store)
 		if (token.type === `mutable_atom_family`) {
 			const jsonFamily = getJsonFamily(token, this.store)
-			const jsonState = initFamilyMember(jsonFamily, this.key, this.store)
+			const jsonState = initFamilyMember(jsonFamily, this.token.key, this.store)
 			this.tokens.push(jsonState)
 		}
 		this.tokens.push(state)
+		this.subject.next({ type: `state_creation`, token: state })
 		return state
 	}
 
 	public spawn<K extends Json.Serializable>(key: K): Molecule<K> {
-		const child = new Molecule(key, [this], this.store)
+		const child = new Molecule(this.store, this, { key, type: `molecule` })
 		return child
 	}
 
 	public with(molecule: Molecule<any>): (key: string) => Molecule<any> {
 		return (key) => {
-			const child = new Molecule(key, [this, molecule], this.store)
+			const child = new Molecule(this.store, [this, molecule], {
+				key,
+				type: `molecule`,
+			})
 			return child
 		}
 	}
@@ -106,26 +138,27 @@ export class Molecule<Key extends Json.Serializable> {
 		while (this.tokens.length > 0) {
 			const token = this.tokens.pop()
 			if (token) {
-				disposeState(token, this.store)
+				disposeFromStore(token, this.store)
 			}
 		}
 		while (this.joins.length > 0) {
 			const join = this.joins.pop()
 			if (join) {
-				join.molecules.delete(stringifyJson(this.key))
+				join.molecules.delete(stringifyJson(this.token.key))
 			}
 		}
 	}
 
 	public join(token: JoinToken<any, any, any, any>): void {
 		const join = getJoin(token, this.store)
-		join.molecules.set(stringifyJson(this.key), this)
+		join.molecules.set(stringifyJson(this.token.key), this)
 		this.joins.push(join)
 	}
 
 	private [Symbol.dispose](): void {
 		this.clear()
-		this.store.molecules.delete(stringifyJson(this.key))
+		const target = newest(this.store)
+		target.molecules.delete(stringifyJson(this.token.key))
 		for (const parent of this.above) {
 			parent.detach(this)
 		}

package/immortal/src/seek-state.ts

@@ -16,6 +16,8 @@ import type { Transceiver } from "atom.io/internal"
 import { IMPLICIT, seekInStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
+import type { MoleculeFamilyToken, MoleculeToken } from "./make-molecule"
+
 export function seekState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
@@ -51,10 +53,21 @@ export function seekState<T, K extends Json.Serializable, Key extends K>(
 	key: Key,
 ): ReadableToken<T> | undefined
 
+export function seekState<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+>(
+	token: MoleculeFamilyToken<K, S, any[]>,
+	key: K,
+): MoleculeToken<K, S, any[]> | undefined
+
 export function seekState(
-	token: ReadableFamilyToken<any, any>,
+	token: MoleculeFamilyToken<any, any, any> | ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
-): ReadableToken<any> | undefined {
+): MoleculeToken<any, any, any> | ReadableToken<any> | undefined {
+	if (token.type === `molecule_family`) {
+		return seekInStore(token, key, IMPLICIT.STORE)
+	}
 	const state = seekInStore(token, key, IMPLICIT.STORE)
 	return state
 }