atom.io 0.42.0 → 0.42.1

package/src/internal/join/join-internal.ts

@@ -1,15 +1,14 @@
-import type {
-	findState,
-	getState,
-	JoinOptions,
-	MutableAtomFamilyToken,
-	ReadonlyPureSelectorFamilyToken,
-	setState,
-	Write,
-	WriterToolkit,
+import {
+	type findState,
+	type getState,
+	type JoinOptions,
+	type MutableAtomFamilyToken,
+	type ReadonlyPureSelectorFamilyToken,
+	type setState,
+	simpleCompound,
+	type Write,
+	type WriterToolkit,
 } from "atom.io"
-import { Anarchy } from "atom.io"
-import { stringifyJson } from "atom.io/json"
 import { UList } from "atom.io/transceivers/u-list"
 
 import { capitalize } from "../capitalize"
@@ -86,7 +85,6 @@ export class Join<
 	}
 
 	public store: Store
-	public realm: Anarchy
 
 	public [Symbol.dispose](): void {}
 
@@ -97,13 +95,10 @@ export class Join<
 		type AB = A & B
 
 		this.store = store
-		this.realm = new Anarchy(store)
 		this.options = options
 
 		this.store.miscResources.set(`join:${options.key}`, this)
 
-		this.realm.allocate(`root`, options.key)
-
 		this.toolkit = {
 			get: ((...ps: Parameters<typeof getState>) =>
 				getFromStore(store, ...ps)) as typeof getState,
@@ -179,9 +174,9 @@ export class Join<
 							})
 						}
 						for (const previousOwner of previousOwnersToDispose) {
-							const [x, y] = [newRelationB, previousOwner].sort()
-							const compositeKey = `${x}:${y}`
-							store.moleculeJoins.delete(compositeKey)
+							store.keyRefsInJoins.delete(
+								simpleCompound(newRelationB, previousOwner),
+							)
 						}
 					}
 					if (!newRelationBIsAlreadyRelated) {
@@ -222,14 +217,9 @@ export class Join<
 			getRelatedKeys: (key) =>
 				this.toolkit.get(relatedKeysAtoms, key) as UList<A> | UList<B>,
 			addRelation: (a, b) => {
-				this.store.moleculeJoins.set(`"${a}"`, options.key)
-				this.store.moleculeJoins.set(`"${b}"`, options.key)
-				if (!this.store.molecules.has(stringifyJson(a))) {
-					this.realm.allocate(options.key, a)
-				}
-				if (!this.store.molecules.has(stringifyJson(b))) {
-					this.realm.allocate(options.key, b)
-				}
+				this.store.keyRefsInJoins.set(`"${a}"`, options.key)
+				this.store.keyRefsInJoins.set(`"${b}"`, options.key)
+				this.store.keyRefsInJoins.set(simpleCompound(a, b), options.key)
 				this.toolkit.set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b))
 				this.toolkit.set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a))
 			},
@@ -242,9 +232,8 @@ export class Join<
 					bKeys.delete(a)
 					return bKeys
 				})
-				const [x, y] = [a, b].sort()
-				const compositeKey = `${x}:${y}`
-				this.store.moleculeJoins.delete(compositeKey)
+				const compositeKey = simpleCompound(a, b)
+				this.store.keyRefsInJoins.delete(compositeKey)
 			},
 			replaceRelationsSafely: (a, bs) => {
 				replaceRelationsSafely(this.toolkit, a, bs)
@@ -262,24 +251,6 @@ export class Join<
 			externalStore,
 			isAType: options.isAType,
 			isBType: options.isBType,
-			// makeContentKey: (...args) => {
-			// 	const [a, b] = args
-			// 	const [x, y] = args.sort()
-			// 	const compositeKey = `${x}:${y}`
-			// 	const aMolecule = store.molecules.get(stringifyJson(a))
-			// 	const bMolecule = store.molecules.get(stringifyJson(b))
-			// 	if (!aMolecule) {
-			// 		this.realm.allocate(options.key, a)
-			// 	}
-			// 	if (!bMolecule) {
-			// 		this.realm.allocate(options.key, b)
-			// 	}
-
-			// 	this.realm.allocate(a, compositeKey, `all`)
-			// 	this.realm.claim(b, compositeKey)
-			// 	this.store.moleculeJoins.set(compositeKey, options.key)
-			// 	return compositeKey
-			// },
 		})
 
 		const createSingleKeySelectorFamily = () =>

package/src/internal/molecule.ts

@@ -1,15 +1,17 @@
-import type {
-	Above,
-	Claim,
-	CompoundFrom,
-	CompoundTypedKey,
-	Hierarchy,
-	MoleculeCreationEvent,
-	MoleculeDisposalEvent,
-	MoleculeTransferEvent,
-	SingularTypedKey,
-	TransactionToken,
-	Vassal,
+import {
+	type Above,
+	type CompoundFrom,
+	type CompoundTypedKey,
+	decomposeCompound,
+	type Hierarchy,
+	type MoleculeCreationEvent,
+	type MoleculeDisposalEvent,
+	type MoleculeTransferEvent,
+	simpleCompound,
+	type SingularTypedKey,
+	type TransactionToken,
+	type ValidKey,
+	type Vassal,
 } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 import { parseJson, stringifyJson } from "atom.io/json"
@@ -19,6 +21,7 @@ import { getFromStore } from "./get-state"
 import { getTrace } from "./get-trace"
 import { newest } from "./lineage"
 import type { Store } from "./store"
+import { Subject } from "./subject"
 import type { RootStore } from "./transaction"
 import { createTransaction, isChildStore } from "./transaction"
 
@@ -26,6 +29,7 @@ export type Molecule<K extends Canonical> = {
 	readonly key: K
 	readonly stringKey: stringified<K>
 	readonly dependsOn: `all` | `any`
+	readonly subject: Subject<void>
 }
 
 export function makeRootMoleculeInStore<S extends string>(
@@ -36,6 +40,7 @@ export function makeRootMoleculeInStore<S extends string>(
 		key,
 		stringKey: stringifyJson(key),
 		dependsOn: `any`,
+		subject: new Subject(),
 	} satisfies Molecule<S>
 	store.molecules.set(stringifyJson(key), molecule)
 	return key
@@ -50,7 +55,7 @@ export function allocateIntoStore<
 	provenance: A,
 	key: V,
 	dependsOn: `all` | `any` = `any`,
-): Claim<V> {
+): ValidKey<V> {
 	const origin = provenance as Canonical | [Canonical, Canonical]
 	const stringKey = stringifyJson(key)
 	const invalidKeys: stringified<Canonical>[] = []
@@ -75,8 +80,9 @@ export function allocateIntoStore<
 			invalidKeys.push(claimString)
 		}
 	}
+	const subject = new Subject<void>()
 	if (invalidKeys.length === 0) {
-		target.molecules.set(stringKey, { key, stringKey, dependsOn })
+		target.molecules.set(stringKey, { key, stringKey, dependsOn, subject })
 	}
 
 	const creationEvent: MoleculeCreationEvent = {
@@ -109,7 +115,7 @@ export function allocateIntoStore<
 		)
 	}
 
-	return key as Claim<V>
+	return key as ValidKey<V>
 }
 
 export function fuseWithinStore<
@@ -123,7 +129,7 @@ export function fuseWithinStore<
 	type: T,
 	sideA: SingularTypedKey<A>,
 	sideB: SingularTypedKey<B>,
-): Claim<CompoundTypedKey<T, A, B>> {
+): ValidKey<CompoundTypedKey<T, A, B>> {
 	const compoundKey: CompoundTypedKey<T, A, B> =
 		`T$--${type}==${sideA}++${sideB}`
 	const above = [sideA, sideB] as Above<Vassal<H>, H>
@@ -139,10 +145,10 @@ export function fuseWithinStore<
 export function createDeallocateTX<
 	H extends Hierarchy,
 	V extends Exclude<Vassal<H>, CompoundTypedKey>,
->(store: RootStore): TransactionToken<(claim: Claim<V>) => void> {
+>(store: RootStore): TransactionToken<(claim: ValidKey<V>) => void> {
 	return createTransaction(store, {
 		key: `[Internal] deallocate`,
-		do: (_, claim: Claim<V>): void => {
+		do: (_, claim: ValidKey<V>): void => {
 			deallocateFromStore<H, V>(newest(store), claim)
 		},
 	})
@@ -150,7 +156,7 @@ export function createDeallocateTX<
 
 export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 	target: Store,
-	claim: Claim<V>,
+	claim: ValidKey<V>,
 ): void {
 	const stringKey = stringifyJson(claim)
 
@@ -171,8 +177,9 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		)
 		return
 	}
+	molecule.subject.next()
 
-	const joinKeys = target.moleculeJoins.getRelatedKeys(stringKey)
+	const joinKeys = target.keyRefsInJoins.getRelatedKeys(stringKey)
 	if (joinKeys) {
 		for (const joinKey of joinKeys) {
 			const join = target.joins.get(joinKey)
@@ -180,8 +187,20 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 				join.relations.delete(claim)
 			}
 		}
+	} else {
+		const compound = decomposeCompound(claim)
+		if (compound) {
+			const [, a, b] = compound
+			const joinKey = target.keyRefsInJoins.getRelatedKey(simpleCompound(a, b))
+			if (joinKey) {
+				const join = target.joins.get(joinKey)
+				if (join) {
+					join.relations.delete(a, b)
+				}
+			}
+		}
 	}
-	target.moleculeJoins.delete(stringKey)
+	target.keyRefsInJoins.delete(stringKey)
 
 	const provenance: stringified<Canonical>[] = []
 
@@ -225,7 +244,7 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 	}
 
 	target.moleculeGraph.delete(molecule.stringKey)
-	target.moleculeJoins.delete(molecule.stringKey)
+	target.keyRefsInJoins.delete(molecule.stringKey)
 	target.moleculeData.delete(molecule.stringKey)
 
 	if (!isTransaction) {
@@ -244,7 +263,7 @@ export function createClaimTX<
 >(
 	store: RootStore,
 ): TransactionToken<
-	(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`) => void
+	(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`) => void
 > {
 	return createTransaction(store, {
 		key: `[Internal] claim`,
@@ -261,9 +280,9 @@ export function claimWithinStore<
 >(
 	store: Store,
 	newProvenance: A,
-	claim: Claim<V>,
+	claim: ValidKey<V>,
 	exclusive?: `exclusive`,
-): Claim<V> {
+): ValidKey<V> {
 	const stringKey = stringifyJson(claim)
 	const target = newest(store)
 	const molecule = target.molecules.get(stringKey)

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

@@ -5,7 +5,7 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 
-import { newest } from "../lineage"
+import { eldest, newest } from "../lineage"
 import { createStandaloneSelector } from "../selector"
 import { resetInStore, setIntoStore } from "../set-state"
 import type { MutableAtom } from "../state-types"
@@ -58,6 +58,18 @@ export function createMutableAtom<T extends Transceiver<any, any, any>>(
 	}
 	target.atoms.set(newAtom.key, newAtom)
 	const token = deposit(newAtom)
+
+	new Tracker(token, store)
+	if (!family) {
+		createStandaloneSelector(store, {
+			key: `${key}:JSON`,
+			get: ({ get }) => get(token).toJSON(),
+			set: ({ set }, newValue) => {
+				set(token, options.class.fromJSON(newValue))
+			},
+		})
+	}
+
 	if (options.effects) {
 		let effectIndex = 0
 		const cleanupFunctions: (() => void)[] = []
@@ -71,6 +83,8 @@ export function createMutableAtom<T extends Transceiver<any, any, any>>(
 				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(store, token, `effect[${effectIndex}]`, handle),
+				token: token as any,
+				store: eldest(store),
 			})
 			if (cleanup) {
 				cleanupFunctions.push(cleanup)
@@ -84,16 +98,6 @@ export function createMutableAtom<T extends Transceiver<any, any, any>>(
 		}
 	}
 
-	new Tracker(token, store)
-	if (!family) {
-		createStandaloneSelector(store, {
-			key: `${key}:JSON`,
-			get: ({ get }) => get(token).toJSON(),
-			set: ({ set }, newValue) => {
-				set(token, options.class.fromJSON(newValue))
-			},
-		})
-	}
 	store.on.atomCreation.next(token)
 	return token
 }

package/src/internal/store/store.ts

@@ -107,20 +107,7 @@ export class Store implements Lineage {
 		new CircularBuffer(100)
 
 	public molecules: Map<string, Molecule<Canonical>> = new Map()
-	public moleculeJoins: Junction<
-		`moleculeKey`,
-		stringified<Canonical>,
-		`joinKey`,
-		string
-	> = new Junction(
-		{
-			between: [`moleculeKey`, `joinKey`],
-			cardinality: `n:n`,
-		},
-		{
-			makeContentKey: (...keys) => keys.sort().join(`:`),
-		},
-	)
+
 	public moleculeGraph: Junction<
 		`upstreamMoleculeKey`,
 		stringified<Canonical> | `"root"`,
@@ -150,6 +137,20 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
+	public keyRefsInJoins: Junction<
+		`moleculeKey`,
+		stringified<Canonical>,
+		`joinKey`,
+		string
+	> = new Junction(
+		{
+			between: [`moleculeKey`, `joinKey`],
+			cardinality: `n:n`,
+		},
+		{
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		},
+	)
 	public miscResources: Map<string, Disposable> = new Map()
 
 	public on: StoreEventCarrier = {

package/src/internal/transaction/build-transaction.ts

@@ -54,7 +54,7 @@ export const buildTransaction = (
 		molecules: new MapOverlay(parent.molecules),
 		moleculeGraph: parent.moleculeGraph.overlay(),
 		moleculeData: parent.moleculeData.overlay(),
-		moleculeJoins: parent.moleculeJoins.overlay(),
+		keyRefsInJoins: parent.keyRefsInJoins.overlay(),
 		miscResources: new MapOverlay(parent.miscResources),
 	}
 	const epoch = getEpochNumberOfAction(store, token.key)

package/src/main/atom.ts

@@ -1,4 +1,4 @@
-import type { ConstructorOf, Ctor, Transceiver } from "atom.io/internal"
+import type { ConstructorOf, Ctor, Store, Transceiver } from "atom.io/internal"
 import {
 	createMutableAtom,
 	createMutableAtomFamily,
@@ -10,6 +10,7 @@ import type { Canonical } from "atom.io/json"
 
 import type { StateUpdate } from "./events"
 import type {
+	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	RegularAtomFamilyToken,
@@ -22,7 +23,7 @@ export type RegularAtomOptions<T, E = never> = {
 	/** The starting value of the atom */
 	default: T | (() => T)
 	/** Hooks used to run side effects when the atom is set */
-	effects?: readonly AtomEffect<T>[]
+	effects?: readonly AtomEffect<T, E>[]
 	/** The classes of errors that might be thrown when deriving the atom's default value */
 	catch?: readonly Ctor<E>[]
 }
@@ -67,8 +68,10 @@ export function mutableAtom<T extends Transceiver<any, any, any>>(
  * @returns
  * Optionally, a cleanup function that will be called when the atom is disposed
  */
-export type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void
-export type Effectors<T> = {
+export type AtomEffect<T, E = never> = (
+	tools: Effectors<T, E>,
+) => (() => void) | void
+export type Effectors<T, E = never> = {
 	/**
 	 * Reset the value of the atom to its default
 	 */
@@ -79,7 +82,13 @@ export type Effectors<T> = {
 	 */
 	setSelf: <New extends T>(next: New | ((old: T) => New)) => void
 	/** Subscribe to changes to the atom */
-	onSet: (callback: (options: StateUpdate<T>) => void) => void
+	onSet: (callback: (options: StateUpdate<E | T>) => void) => void
+	/** The token of the atom */
+	token: T extends Transceiver<any, any, any>
+		? MutableAtomToken<T>
+		: AtomToken<T, any, E>
+	/** The store in which the atom exists */
+	store: Store
 }
 
 export type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
@@ -88,7 +97,7 @@ export type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
 	/** The starting value of the atom family */
 	default: T | ((key: K) => T)
 	/** Hooks used to run side effects when an atom in the family is set  */
-	effects?: (key: K) => AtomEffect<T>[]
+	effects?: (key: K) => AtomEffect<T, E>[]
 	/** The classes of errors that might be thrown when deriving the atom's default value */
 	catch?: readonly Ctor<E>[]
 }

package/src/main/realm.ts

@@ -14,16 +14,20 @@ import type { Canonical } from "atom.io/json"
 
 import type { TransactionToken } from "./tokens"
 
-export const $claim: unique symbol = Symbol.for(`claim`)
-export type Claim<K extends Canonical> = K & { [$claim]?: true }
+export const $validatedKey: unique symbol = Symbol.for(`claim`)
+export type ValidKey<K extends Canonical> = K & { [$validatedKey]?: true }
+
+export function simpleCompound(a: string, b: string): string {
+	return [a, b].sort().join(`\u001F`)
+}
 
 export class Realm<H extends Hierarchy> {
 	public store: RootStore
-	public deallocateTX: TransactionToken<(claim: Claim<Vassal<H>>) => void>
+	public deallocateTX: TransactionToken<(claim: ValidKey<Vassal<H>>) => void>
 	public claimTX: TransactionToken<
 		<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(
 			newProvenance: A,
-			claim: Claim<V>,
+			claim: ValidKey<V>,
 			exclusive?: `exclusive`,
 		) => void
 	>
@@ -42,13 +46,13 @@ export class Realm<H extends Hierarchy> {
 	 * @param key - A unique identifier for the new subject
 	 * @param attachmentStyle - The attachment style of new subject to its owner(s). `any` means that if any owners remain, the subject will be retained. `all` means that the subject be retained only if all owners remain .
 	 * @returns
-	 * The subject's key, given status as a true {@link Claim}
+	 * The subject's key, given status as a true {@link ValidKey}
 	 */
 	public allocate<V extends Vassal<H>, A extends Above<V, H>>(
 		provenance: A,
 		key: V,
 		attachmentStyle?: `all` | `any`,
-	): Claim<V> {
+	): ValidKey<V> {
 		return allocateIntoStore<H, V, A>(
 			this.store,
 			provenance,
@@ -62,7 +66,7 @@ export class Realm<H extends Hierarchy> {
 	 * @param reagentA - the left reagent of the compound
 	 * @param reagentB - the right reagent of the compound
 	 * @returns
-	 * The compound's key, given status as a true {@link Claim}
+	 * The compound's key, given status as a {@link ValidKey}
 	 */
 	public fuse<
 		C extends CompoundFrom<H>,
@@ -73,14 +77,14 @@ export class Realm<H extends Hierarchy> {
 		type: T,
 		reagentA: SingularTypedKey<A>,
 		reagentB: SingularTypedKey<B>,
-	): Claim<CompoundTypedKey<T, A, B>> {
+	): ValidKey<CompoundTypedKey<T, A, B>> {
 		return fuseWithinStore<H, C, T, A, B>(this.store, type, reagentA, reagentB)
 	}
 	/**
 	 * Remove a subject from the realm
 	 * @param claim - The subject to be deallocated
 	 */
-	public deallocate<V extends Vassal<H>>(claim: Claim<V>): void {
+	public deallocate<V extends Vassal<H>>(claim: ValidKey<V>): void {
 		actUponStore(this.store, this.deallocateTX, arbitrary())(claim)
 	}
 	/**
@@ -89,12 +93,12 @@ export class Realm<H extends Hierarchy> {
 	 * @param claim - The subject to be claimed
 	 * @param exclusive - Whether the subjects previous owners should be detached from it
 	 * @returns
-	 * The subject's key, given status as a true {@link Claim}
+	 * The subject's key, given status as a true {@link ValidKey}
 	 */
 	public claim<
 		V extends Exclude<Vassal<H>, CompoundTypedKey>,
 		A extends Above<V, H>,
-	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): void {
+	>(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`): void {
 		actUponStore(this.store, this.claimTX, arbitrary())(
 			newProvenance,
 			claim,
@@ -157,10 +161,47 @@ export class Anarchy {
 	): void {
 		claimWithinStore<any, any, any>(this.store, newProvenance, key, exclusive)
 	}
+	/**
+	 * Fuse two reagents into a compound
+	 * @param type - the name of the compound that is being fused
+	 * @param reagentA - the left reagent of the compound
+	 * @param reagentB - the right reagent of the compound
+	 * @returns
+	 * The compound's key, given status as a {@link ValidKey}
+	 */
+	public fuse<T extends string, A extends string, B extends string>(
+		type: T,
+		reagentA: SingularTypedKey<A>,
+		reagentB: SingularTypedKey<B>,
+	): ValidKey<CompoundTypedKey<T, A, B>> {
+		return fuseWithinStore<any, any, T, A, B>(
+			this.store,
+			type,
+			reagentA,
+			reagentB,
+		)
+	}
+}
+
+export function decomposeCompound(
+	compound: Canonical,
+): [type: string, a: string, b: string] | null {
+	if ((typeof compound === `string`) === false) {
+		return null
+	}
+	const [typeTag, components] = compound.split(`==`)
+	if (!components) {
+		return null
+	}
+	const type = typeTag.slice(4)
+	const [a, b] = components.split(`++`)
+	if (type && a && b) {
+		return [type, a, b]
+	}
+	return null
 }
 
-export const T$ = `T$`
-export type T$ = typeof T$
+export type T$ = `T$`
 export type TypeTag<T extends string> = `${T$}--${T}`
 export type SingularTypedKey<T extends string = string> = `${T}::${string}`
 export type CompoundTypedKey<

package/src/transceivers/u-list/index.ts

@@ -1 +1,2 @@
 export * from "./u-list"
+export * from "./u-list-disposed-key-cleanup-effect"

package/src/transceivers/u-list/u-list-disposed-key-cleanup-effect.ts

@@ -0,0 +1,47 @@
+import type { AtomEffect } from "atom.io"
+import { getUpdateToken, subscribeInStore } from "atom.io/internal"
+import { type primitive, stringifyJson } from "atom.io/json"
+
+import { UList } from "./u-list"
+
+export const uListDisposedKeyCleanupEffect: AtomEffect<UList<primitive>> = ({
+	token,
+	setSelf,
+	store,
+}) => {
+	const disposalSubscriptions = new Map<primitive, () => void>()
+	const updateToken = getUpdateToken(token)
+	subscribeInStore(
+		store,
+		updateToken,
+		function setAutoDeletionTriggers({ newValue }) {
+			const unpacked = UList.unpackUpdate(newValue)
+			switch (unpacked.type) {
+				case `add`:
+					{
+						const molecule = store.molecules.get(stringifyJson(unpacked.value))
+						if (molecule) {
+							disposalSubscriptions.set(
+								unpacked.value,
+								molecule.subject.subscribe(token.key, () => {
+									setSelf((self) => {
+										self.delete(unpacked.value)
+										return self
+									})
+								}),
+							)
+						}
+					}
+					break
+				case `delete`:
+					disposalSubscriptions.get(unpacked.value)?.()
+					disposalSubscriptions.delete(unpacked.value)
+					break
+				case `clear`:
+					for (const unsub of disposalSubscriptions.values()) unsub()
+					disposalSubscriptions.clear()
+			}
+		},
+		`set-auto-deletion-triggers`,
+	)
+}