atom.io 0.35.0 → 0.36.0

package/src/internal/mutable/tracker.ts

@@ -1,5 +1,4 @@
 import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
-import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
 import {
@@ -11,20 +10,18 @@ import {
 } from ".."
 import { createRegularAtom } from "../atom"
 import { isChildStore } from "../transaction/is-root-store"
-import type { Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
  * subscribe to the transceiver's inner value. When the inner value changes,
  * the tracker will update its own state to reflect the change.
  */
-export class Tracker<Mutable extends Transceiver<any>> {
+export class Tracker<T extends Transceiver<any, any>> {
 	private initializeState(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
+		mutableState: MutableAtomToken<T>,
 		store: Store,
-	): RegularAtomToken<
-		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-	> {
+	): RegularAtomToken<SignalFrom<T> | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
 		store.atoms.delete(latestUpdateStateKey)
 		store.valueMap.delete(latestUpdateStateKey)
@@ -34,9 +31,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subKey: mutableState.family.subKey,
 				}
 			: undefined
-		const latestUpdateState = createRegularAtom<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>(
+		const latestUpdateState = createRegularAtom<SignalFrom<T> | null>(
 			store,
 			{
 				key: latestUpdateStateKey,
@@ -54,46 +49,41 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	private unsubscribeFromInnerValue!: () => void
 	private unsubscribeFromState!: () => void
-	private observeCore(
-		mutableState: MutableAtomToken<Mutable, any>,
-		latestUpdateState: RegularAtomToken<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>,
+	private captureSignalsFromCore(
+		mutableState: MutableAtomToken<T, any>,
+		latestUpdateState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
+		const trackerCapturesOutboundSignal = (update: SignalFrom<T>) => {
+			setIntoStore(target, latestUpdateState, update)
+		}
 		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
-			(update) => {
-				setIntoStore(target, latestUpdateState, update)
-			},
+			trackerCapturesOutboundSignal,
 		)
 		this.unsubscribeFromState = subscribeToState(
 			target,
 			mutableState,
 			subscriptionKey,
-			(update) => {
+			function trackerLooksForNewReference(update: SignalFrom<T>) {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue()
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
-						(transceiverUpdate) => {
-							setIntoStore(target, latestUpdateState, transceiverUpdate)
-						},
+						trackerCapturesOutboundSignal,
 					)
 				}
-			},
+			}.bind(this),
 		)
 	}
 
-	private updateCore<Core extends Transceiver<any>>(
-		mutableState: MutableAtomToken<Core, Json.Serializable>,
-		latestUpdateState: RegularAtomToken<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>,
+	private supplySignalsToCore(
+		mutableState: MutableAtomToken<T>,
+		latestUpdateState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
@@ -103,85 +93,71 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			target,
 			latestUpdateState,
 			subscriptionKey,
-			({ newValue, oldValue }) => {
+			function trackerCapturesInboundSignal({ newValue, oldValue }) {
 				const timelineId = target.timelineTopics.getRelatedKey(
 					latestUpdateState.key,
 				)
 
-				if (timelineId) {
-					const timelineData = target.timelines.get(timelineId)
-					if (timelineData?.timeTraveling) {
-						const unsubscribe = subscribeToTimeline(
-							target,
-							{ key: timelineId, type: `timeline` },
-							subscriptionKey,
-							(update) => {
-								unsubscribe()
-								setIntoStore(target, mutableState, (transceiver) => {
-									if (update === `redo` && newValue) {
-										transceiver.do(newValue)
-									} else if (update === `undo` && oldValue) {
-										transceiver.undo(oldValue)
-									}
-									return transceiver
-								})
-							},
-						)
-						return
-					}
+				if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
+					const unsubscribe = subscribeToTimeline(
+						target,
+						{ key: timelineId, type: `timeline` },
+						subscriptionKey,
+						function trackerWaitsForTimeTravelToFinish(update) {
+							unsubscribe()
+							setIntoStore(target, mutableState, (transceiver) => {
+								if (update === `redo` && newValue) {
+									transceiver.do(newValue)
+								} else if (update === `undo` && oldValue) {
+									transceiver.undo(oldValue)
+								}
+								return transceiver
+							})
+						},
+					)
+					return
 				}
 
-				const unsubscribe = target.on.operationClose.subscribe(
-					subscriptionKey,
-					() => {
-						unsubscribe()
-						const mutable = getFromStore(target, mutableState)
-						const updateNumber =
-							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
-						const eventOffset = updateNumber - mutable.cacheUpdateNumber
-						if (newValue && eventOffset === 1) {
-							setIntoStore(
-								target,
-								mutableState,
-								(transceiver) => (transceiver.do(newValue), transceiver),
-							)
-						} else {
-							target.logger.info(
-								`❌`,
-								`mutable_atom`,
-								mutableState.key,
-								`could not be updated. Expected update number ${
-									mutable.cacheUpdateNumber + 1
-								}, but got ${updateNumber}`,
-							)
-						}
-					},
-				)
+				const mutable = getFromStore(target, mutableState)
+				const updateNumber = mutable.getUpdateNumber(newValue)
+				const eventOffset = updateNumber - mutable.cacheUpdateNumber
+				if (newValue && eventOffset === 1) {
+					setIntoStore(
+						target,
+						mutableState,
+						(transceiver) => (transceiver.do(newValue), transceiver),
+					)
+				} else {
+					target.logger.info(
+						`❌`,
+						`mutable_atom`,
+						mutableState.key,
+						`could not be updated. Expected update number ${
+							mutable.cacheUpdateNumber + 1
+						}, but got ${updateNumber}`,
+					)
+				}
 			},
 		)
 	}
 
-	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
-	public latestUpdateState: RegularAtomToken<
-		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-	>
+	public mutableAtomToken: MutableAtomToken<T>
+	public latestSignalToken: RegularAtomToken<SignalFrom<T> | null>
 
 	public [Symbol.dispose]!: () => void
 
-	public constructor(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
-		store: Store,
-	) {
-		this.mutableState = mutableState
+	public constructor(mutableAtomToken: MutableAtomToken<T>, store: Store) {
 		const target = newest(store)
-		this.latestUpdateState = this.initializeState(mutableState, target)
-		this.observeCore(mutableState, this.latestUpdateState, target)
-		this.updateCore(mutableState, this.latestUpdateState, target)
-		target.trackers.set(mutableState.key, this)
+		const latestSignalToken = this.initializeState(mutableAtomToken, target)
+		this.mutableAtomToken = mutableAtomToken
+		this.latestSignalToken = latestSignalToken
+		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target)
+		this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target)
+		target.trackers.set(mutableAtomToken.key, this)
 		this[Symbol.dispose] = () => {
 			this.unsubscribeFromInnerValue()
 			this.unsubscribeFromState()
-			target.trackers.delete(mutableState.key)
+			target.trackers.delete(mutableAtomToken.key)
 		}
 	}
 }

package/src/internal/mutable/transceiver.ts

@@ -1,16 +1,28 @@
 import type { Json } from "atom.io/json"
 
-export interface Transceiver<S extends Json.Serializable> {
+export interface Transceiver<
+	S extends Json.Serializable,
+	J extends Json.Serializable,
+> {
 	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
 }
 
+// biome-ignore format: intersection
+export type TransceiverConstructor<
+  J extends Json.Serializable,
+  T extends Transceiver<any, J>
+> =
+	& ( new () => T )
+	& { fromJSON: (json: J) => T }
+
 export function isTransceiver(
 	value: unknown,
-): value is Transceiver<Json.Serializable> {
+): value is Transceiver<Json.Serializable, Json.Serializable> {
 	return (
 		typeof value === `object` &&
 		value !== null &&
@@ -22,17 +34,28 @@ export function isTransceiver(
 
 export type TransceiverMode = `playback` | `record` | `transaction`
 
-export type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<
-	infer S
+export type SignalFrom<T extends Transceiver<any, any>> = T extends Transceiver<
+	infer S,
+	any
 >
 	? S
 	: never
 
+export type AsJSON<T extends Transceiver<any, any>> = T extends Transceiver<
+	any,
+	infer J
+>
+	? J
+	: never
+
+export type ConstructorOf<T extends Transceiver<any, any>> =
+	TransceiverConstructor<AsJSON<T>, T>
+
 /*
 A transceiver may also keep a list of updates that have been applied to it.
 This is useful for undo/redo functionality, especially in the context of
-revising history. It is a good idea to accept a cache limit in your 
-constructor, and overwrite old updates. Here's an example of how we 
+revising history. It is a good idea to accept a cache limit in your
+constructor, and overwrite old updates. Here's an example of how we
 might set that up:
 
 myTransceiver = Transceiver {
@@ -48,7 +71,7 @@ myTransceiver = Transceiver {
 
 CONFIRM/NO-OP
 Update `27=del:"x"` is passed to myTransceiver.do:
-- [updateNumber = 27, update = `del:"x"`]	
+- [updateNumber = 27, update = `del:"x"`]
 - updateOffset = updateNumber - cacheUpdateNumber // 0
 - eventOffset < 1 // true (we're validating the past)
 - |eventOffset| < cacheLimit // true (we remember this update)
@@ -75,7 +98,7 @@ Update `29=del:"x"` is passed to myTransceiver.do:
 - eventOffset === 1 // false (we're NOT ready to apply this update)
 - updateIdx := cacheIdx + updateOffset // 3
 - updateIdx %= cacheLimit // 0
-- cache[updateIdx] = update // cache = <{ 0 => del:"x" }> 
+- cache[updateIdx] = update // cache = <{ 0 => del:"x" }>
 - expectedUpdateNumber = cacheUpdateNumber + 1 // 28
 - return expectedUpdateNumber // 🤨👂
 
@@ -110,3 +133,7 @@ Update `24=add:"z"` is passed to myTransceiver.do:
 - return `OUT_OF_RANGE` // 😵‍💫👂
 
 */
+
+// The function wants a constructor C
+// - that has a static fromJSON(json) returning an instance of C
+// - and whose instances have toJSON() whose return type matches fromJSON's param

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

@@ -8,9 +8,8 @@ export function disposeSelector(
 	selectorToken: SelectorToken<unknown>,
 ): void {
 	const target = newest(store)
-	const { key, type } = selectorToken
-	const selector = withdraw(target, selectorToken)
-	if (!selector.family) {
+	const { key, type, family: familyMeta } = selectorToken
+	if (!familyMeta) {
 		store.logger.error(
 			`❌`,
 			type,
@@ -18,9 +17,9 @@ export function disposeSelector(
 			`Standalone selectors cannot be disposed.`,
 		)
 	} else {
-		const molecule = target.molecules.get(selector.family.subKey)
+		const molecule = target.molecules.get(familyMeta.subKey)
 		if (molecule) {
-			target.moleculeData.delete(selector.family.subKey, selector.family.key)
+			target.moleculeData.delete(familyMeta.subKey, familyMeta.key)
 		}
 		let familyToken: SelectorFamilyToken<any, any>
 		switch (selectorToken.type) {
@@ -28,7 +27,7 @@ export function disposeSelector(
 				{
 					target.writableSelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `writable_held_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -43,7 +42,7 @@ export function disposeSelector(
 				{
 					target.writableSelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `writable_pure_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -58,7 +57,7 @@ export function disposeSelector(
 				{
 					target.readonlySelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `readonly_held_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -73,7 +72,7 @@ export function disposeSelector(
 				{
 					target.readonlySelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `readonly_pure_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -89,6 +88,7 @@ export function disposeSelector(
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
 		target.selectorGraph.delete(key)
+		target.moleculeData.delete(familyMeta.key, familyMeta.subKey)
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
 			target.transactionMeta.update.updates.push({

package/src/internal/set-state/copy-mutable-if-needed.ts

@@ -2,12 +2,14 @@ import type { MutableAtom, Transceiver } from ".."
 import { Tracker } from "../mutable"
 import type { Store } from "../store"
 
-export function copyMutableIfNeeded<T extends Transceiver<any>>(
+export function copyMutableIfNeeded<T extends Transceiver<any, any>>(
 	target: Store,
-	atom: MutableAtom<T, any>,
+	atom: MutableAtom<T>,
 	origin: Store,
 ): T {
-	const originValue = origin.valueMap.get(atom.key)
+	const originValue = origin.valueMap.get(atom.key) as
+		| Transceiver<any, any>
+		| undefined
 	const targetValue = target.valueMap.get(atom.key)
 
 	if (originValue !== targetValue) {
@@ -15,12 +17,12 @@ export function copyMutableIfNeeded<T extends Transceiver<any>>(
 	}
 
 	if (originValue === undefined) {
-		return atom.default()
+		return new atom.class()
 	}
 
 	origin.logger.info(`📃`, `atom`, atom.key, `copying`)
-	const jsonValue = atom.toJson(originValue)
-	const copiedValue = atom.fromJson(jsonValue)
+	const jsonValue = originValue.toJSON()
+	const copiedValue = atom.class.fromJSON(jsonValue)
 	target.valueMap.set(atom.key, copiedValue)
 	new Tracker(atom, origin)
 	return copiedValue

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -4,11 +4,18 @@ import type { Store } from "../store"
 import { setAtom } from "./set-atom"
 
 function resetAtom(store: Store, state: Atom<any>) {
-	let def = state.default
-	if (def instanceof Function) {
-		def = def()
+	switch (state.type) {
+		case `mutable_atom`:
+			setAtom(store, state, new state.class())
+			return
+		case `atom`: {
+			let def = state.default
+			if (def instanceof Function) {
+				def = def()
+			}
+			setAtom(store, state, def)
+		}
 	}
-	setAtom(store, state, def)
 }
 
 export function resetAtomOrSelector(

package/src/internal/set-state/set-atom.ts

@@ -60,7 +60,7 @@ export const setAtom = <T>(
 	} else if (atom.key.startsWith(`*`)) {
 		const mutableKey = atom.key.slice(1)
 		const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
-		let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
+		let transceiver: Transceiver<any, any> = target.valueMap.get(mutableKey)
 		if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
 			const { parent } = target
 			const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent)

package/src/internal/store/counterfeit.ts

@@ -16,7 +16,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
@@ -32,11 +32,10 @@ export const FAMILY_MEMBER_TOKEN_TYPES = {
 } as const
 
 export function counterfeit<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
->(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
 
 export function counterfeit<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,

package/src/internal/store/deposit.ts

@@ -20,7 +20,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
@@ -47,9 +47,9 @@ import type {
 import type { Transaction } from "../transaction"
 
 export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
-export function deposit<T extends Transceiver<any>>(
-	state: MutableAtom<T, any>,
-): MutableAtomToken<T, any>
+export function deposit<T extends Transceiver<any, any>>(
+	state: MutableAtom<T>,
+): MutableAtomToken<T>
 export function deposit<T>(state: Atom<T>): AtomToken<T>
 export function deposit<T>(
 	state: WritablePureSelector<T>,
@@ -64,11 +64,9 @@ export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T, K extends Canonical>(
 	state: RegularAtomFamily<T, K>,
 ): RegularAtomFamilyToken<T, K>
-export function deposit<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
+export function deposit<T extends Transceiver<any, any>, K extends Canonical>(
+	state: MutableAtomFamily<T, K>,
+): MutableAtomFamilyToken<T, K>
 export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
 export function deposit<T>(
 	state: WritablePureSelectorFamily<T, any>,

package/src/internal/store/store.ts

@@ -70,11 +70,11 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public trackers: Map<string, Tracker<Transceiver<any>>> = new Map()
+	public trackers: Map<string, Tracker<Transceiver<any, any>>> = new Map()
 	public families: Map<
 		string,
 		| HeldSelectorFamily<any, any>
-		| MutableAtomFamily<any, any, any>
+		| MutableAtomFamily<any, any>
 		| PureSelectorFamily<any, any>
 		| RegularAtomFamily<any, any>
 	> = new Map()

package/src/internal/store/withdraw.ts

@@ -32,7 +32,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
@@ -76,10 +76,10 @@ export function withdraw<T>(
 	store: Store,
 	token: RegularAtomToken<T>,
 ): RegularAtom<T>
-export function withdraw<T extends Transceiver<any>>(
+export function withdraw<T extends Transceiver<any, any>>(
 	store: Store,
 	token: MutableAtomToken<T, any>,
-): MutableAtom<T, any>
+): MutableAtom<T>
 export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
 export function withdraw<T>(
 	store: Store,
@@ -127,14 +127,10 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 ): RegularAtomFamily<T, K>
-export function withdraw<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
-): MutableAtomFamily<T, J, K>
+export function withdraw<T extends Transceiver<any, any>, K extends Canonical>(
+	store: Store,
+	token: MutableAtomFamilyToken<T, K>,
+): MutableAtomFamily<T, K>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,

package/src/json/index.ts

@@ -1,6 +1,4 @@
 export * from "./entries"
-export * from "./select-json"
-export * from "./select-json-family"
 
 export type primitive = boolean | number | string | null