atom.io 0.41.1 → 0.42.1

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/mutable/transceiver.ts

@@ -1,7 +1,7 @@
 import type { Json } from "atom.io/json"
 
 export interface Transceiver<
-	V,
+	V extends { subscribe: (key: string, fn: (update: S) => void) => () => void },
 	S extends Json.Serializable,
 	J extends Json.Serializable,
 > {
@@ -9,8 +9,6 @@ export interface Transceiver<
 	do: (update: S) => number | `OUT_OF_RANGE` | null
 	undo: (update: S) => void
 	subscribe: (key: string, fn: (update: S) => void) => () => void
-	// cacheUpdateNumber: number
-	// getUpdateNumber: (update: S) => number
 	toJSON: () => J
 }
 
@@ -31,8 +29,6 @@ export function isTransceiver(
 		`do` in value &&
 		`undo` in value &&
 		`subscribe` in value &&
-		// `cacheUpdateNumber` in value &&
-		// `getUpdateNumber` in value &&
 		`READONLY_VIEW` in value &&
 		`toJSON` in value
 	)

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

@@ -127,7 +127,7 @@ export function dispatchOrDeferStateUpdate<T, E>(
 		if (hasRole(state, `tracker:signal`)) {
 			const keyOfMutable = key.slice(1)
 			const mutable = target.atoms.get(keyOfMutable) as MutableAtom<
-				Transceiver<unknown, any, any>
+				Transceiver<any, any, any>
 			>
 			const transceiver = readOrComputeValue<Transceiver<any, any, any>, never>(
 				target,

package/src/internal/store/store.ts

@@ -80,7 +80,7 @@ export class Store implements Lineage {
 		| PureSelectorFamily<any, any, any>
 		| RegularAtomFamily<any, any, any>
 	> = new Map()
-	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
+	public joins: Map<string, Join<any, any, any, any, any>> = new Map()
 
 	public transactions: Map<string, Transaction<Fn>> = new Map()
 	public transactionMeta: TransactionEpoch | TransactionProgress<Fn> = {
@@ -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>[]
 }