atom.io 0.36.3 → 0.37.0

package/src/internal/selector/get-selector-dependency-keys.ts

@@ -3,14 +3,10 @@ import { isStateKey } from "../keys"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 
-export const getSelectorDependencyKeys = (
+export function getSelectorDependencyKeys(
 	store: Store,
 	key: string,
-): (
-	| AtomKey<unknown>
-	| ReadonlySelectorKey<unknown>
-	| SelectorKey<unknown>
-)[] => {
+): (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[] {
 	const sources = newest(store)
 		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
 		.filter(([_, { source }]) => source !== key)

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

@@ -7,18 +7,18 @@ import type {
 	WritableToken,
 	WriterToolkit,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import { findInStore } from "../families"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
-import { setAtomOrSelector } from "../set-state"
+import { operateOnStore } from "../set-state/operate-on-store"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
-export const registerSelector = (
+export function registerSelector(
 	store: Store,
 	selectorType:
 		| `readonly_held_selector`
@@ -27,78 +27,68 @@ export const registerSelector = (
 		| `writable_pure_selector`,
 	selectorKey: string,
 	covered: Set<string>,
-): WriterToolkit => ({
-	get: (
-		...params:
-			| [ReadableFamilyToken<any, any>, Json.Serializable]
-			| [ReadableToken<any>]
-	) => {
-		const target = newest(store)
-		let dependency: ReadableToken<any>
+): WriterToolkit {
+	return {
+		get: (
+			...params:
+				| [ReadableFamilyToken<any, any>, Json.Serializable]
+				| [ReadableToken<any>]
+		) => {
+			const target = newest(store)
+			let dependency: ReadableToken<any>
 
-		if (params.length === 2) {
-			const [family, key] = params
-			dependency = findInStore(store, family, key)
-		} else {
-			;[dependency] = params
-		}
+			if (params.length === 2) {
+				const [family, key] = params
+				dependency = findInStore(store, family, key)
+			} else {
+				;[dependency] = params
+			}
 
-		const dependencyState = withdraw(store, dependency)
-		const dependencyValue = readOrComputeValue(store, dependencyState)
-		const dependencyKey = dependency.key
+			const dependencyState = withdraw(store, dependency)
+			const dependencyValue = readOrComputeValue(store, dependencyState)
+			const dependencyKey = dependency.key
 
-		store.logger.info(
-			`🔌`,
-			selectorType,
-			selectorKey,
-			`registers dependency ( "${dependencyKey}" =`,
-			dependencyValue,
-			`)`,
-		)
+			store.logger.info(
+				`🔌`,
+				selectorType,
+				selectorKey,
+				`registers dependency ( "${dependencyKey}" =`,
+				dependencyValue,
+				`)`,
+			)
 
-		target.selectorGraph.set(
-			{
-				upstreamSelectorKey: dependencyKey,
-				downstreamSelectorKey: selectorKey,
-			},
-			{
-				source: dependency.key,
-			},
-		)
-		updateSelectorAtoms(
-			store,
-			selectorType,
-			selectorKey,
-			dependency as any,
-			covered,
-		)
-		return dependencyValue
-	},
-	set: (<T, New extends T>(
-		...params:
-			| [
-					token: WritableFamilyToken<T, any>,
-					key: Json.Serializable,
-					value: New | ((oldValue: any) => New),
-			  ]
-			| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
-	) => {
-		let token: WritableToken<T>
-		let value: New | ((oldValue: T) => New)
-		if (params.length === 2) {
-			token = params[0]
-			value = params[1]
-		} else {
-			const family = params[0]
-			const key = params[1]
-			value = params[2]
-			token = findInStore(store, family, key)
-		}
-		const target = newest(store)
-		const state = withdraw(target, token)
-		setAtomOrSelector(target, state, value)
-	}) as typeof setState,
-	find: ((...args: Parameters<typeof findState>) =>
-		findInStore(store, ...args)) as typeof findState,
-	json: (token) => getJsonToken(store, token),
-})
+			target.selectorGraph.set(
+				{
+					upstreamSelectorKey: dependencyKey,
+					downstreamSelectorKey: selectorKey,
+				},
+				{
+					source: dependency.key,
+				},
+			)
+			updateSelectorAtoms(
+				store,
+				selectorType,
+				selectorKey,
+				dependency as any,
+				covered,
+			)
+			return dependencyValue
+		},
+		set: (<T, K extends Canonical, New extends T, Key extends K>(
+			...params:
+				| [
+						token: WritableFamilyToken<T, K>,
+						key: Key,
+						value: New | ((oldValue: any) => New),
+				  ]
+				| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
+		) => {
+			const target = newest(store)
+			operateOnStore(target, false, ...params)
+		}) as typeof setState,
+		find: ((...args: Parameters<typeof findState>) =>
+			findInStore(store, ...args)) as typeof findState,
+		json: (token) => getJsonToken(store, token),
+	}
+}

package/src/internal/selector/trace-selector-atoms.ts

@@ -2,11 +2,11 @@ import type { Atom, Store } from ".."
 import { isAtomKey } from "../keys"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
-export const traceRootSelectorAtoms = (
+export function traceRootSelectorAtoms(
 	store: Store,
 	selectorKey: string,
 	covered: Set<string> = new Set<string>(),
-): Map<string, Atom<unknown>> => {
+): Map<string, Atom<unknown>> {
 	const dependencies = getSelectorDependencyKeys(store, selectorKey)
 
 	const roots = new Map<string, Atom<unknown>>()

package/src/internal/selector/update-selector-atoms.ts

@@ -4,7 +4,7 @@ import { newest } from "../lineage"
 import type { Store } from "../store"
 import { traceRootSelectorAtoms } from "./trace-selector-atoms"
 
-export const updateSelectorAtoms = (
+export function updateSelectorAtoms(
 	store: Store,
 	selectorType:
 		| `readonly_held_selector`
@@ -14,7 +14,7 @@ export const updateSelectorAtoms = (
 	selectorKey: string,
 	dependency: ReadonlyPureSelectorToken<unknown> | WritableToken<unknown>,
 	covered: Set<string>,
-): void => {
+): void {
 	const target = newest(store)
 	const { type: dependencyType, key: dependencyKey } = dependency
 	if (dependencyType === `atom` || dependencyType === `mutable_atom`) {

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

@@ -0,0 +1,101 @@
+import type {
+	AtomToken,
+	AtomUpdateEvent,
+	StateUpdate,
+	WritableToken,
+} from "atom.io"
+
+import type { MutableAtom, WritableState } from ".."
+import { hasRole } from "../atom"
+import { readOrComputeValue } from "../get-state"
+import type { Transceiver } from "../mutable"
+import { isTransceiver } from "../mutable"
+import type { OpenOperation } from "../operation"
+import { deposit, type Store } from "../store"
+import { isChildStore, isRootStore } from "../transaction"
+import { evictDownstreamFromAtom } from "./evict-downstream"
+
+export function dispatchOrDeferStateUpdate<T>(
+	target: Store & { operation: OpenOperation<any> },
+	state: WritableState<T>,
+	[oldValue, newValue]: [T, T],
+	_stateIsNewlyCreated: boolean,
+): void {
+	const { key, subject, type } = state
+
+	const update: StateUpdate<T> = {
+		oldValue: isTransceiver(oldValue) ? oldValue.READONLY_VIEW : oldValue,
+		newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue,
+	}
+
+	if (isRootStore(target)) {
+		switch (type) {
+			case `mutable_atom`:
+				target.logger.info(
+					`📢`,
+					type,
+					key,
+					`is now (`,
+					newValue,
+					`) subscribers:`,
+					subject.subscribers,
+				)
+				break
+			case `atom`:
+			case `writable_pure_selector`:
+			case `writable_held_selector`:
+				target.logger.info(
+					`📢`,
+					type,
+					key,
+					`went (`,
+					oldValue,
+					`->`,
+					newValue,
+					`) subscribers:`,
+					subject.subscribers,
+				)
+		}
+		subject.next(update)
+	}
+
+	if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
+		if (target.on.transactionApplying.state === null) {
+			const token: WritableToken<T> = deposit(state)
+
+			if (isTransceiver(newValue)) {
+				return
+			}
+			const { timestamp } = target.operation
+			const atomUpdate: AtomUpdateEvent<AtomToken<T>> = {
+				type: `atom_update`,
+				token,
+				timestamp,
+				update,
+			}
+			target.transactionMeta.update.subEvents.push(atomUpdate)
+			target.logger.info(
+				`📁`,
+				`atom`,
+				key,
+				`stowed (`,
+				oldValue,
+				`->`,
+				newValue,
+				`)`,
+			)
+			return
+		}
+		if (hasRole(state, `tracker:signal`)) {
+			const keyOfMutable = key.slice(1)
+			const mutable = target.atoms.get(keyOfMutable) as MutableAtom<
+				Transceiver<unknown, any, any>
+			>
+			const transceiver = readOrComputeValue(target, mutable, `mut`)
+			const accepted = transceiver.do(update.newValue) === null
+			if (accepted === true) {
+				evictDownstreamFromAtom(target, mutable)
+			}
+		}
+	}
+}

package/src/internal/set-state/operate-on-store.ts

@@ -0,0 +1,126 @@
+import type { WritableFamilyToken, WritableToken } from "atom.io"
+import { type Canonical, parseJson } from "atom.io/json"
+
+import { seekInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
+import { mintInStore } from "../families/mint-in-store"
+import type { OpenOperation } from "../operation"
+import { closeOperation, openOperation } from "../operation"
+import { type Store, withdraw } from "../store"
+import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
+import { resetAtomOrSelector } from "./reset-atom-or-selector"
+import { RESET_STATE } from "./reset-in-store"
+import { setAtomOrSelector } from "./set-atom-or-selector"
+
+export function operateOnStore<T, New extends T>(
+	store: Store,
+	ownOp: boolean,
+	...params:
+		| [
+				token: WritableFamilyToken<T, Canonical>,
+				key: Canonical,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+		| [
+				token: WritableToken<T>,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+): void {
+	let existingToken: WritableToken<T> | undefined
+	let brandNewToken: WritableToken<T> | undefined
+	let token: WritableToken<T>
+	let family: WritableFamilyToken<T, Canonical> | null
+	let key: Canonical | null
+	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
+	if (params.length === 2) {
+		token = params[0]
+		value = params[1]
+		if (token.family) {
+			// biome-ignore lint/style/noNonNullAssertion: this token belongs to a family
+			family = getFamilyOfToken(store, token)!
+			key = parseJson(token.family.subKey)
+			existingToken = seekInStore(store, family, key)
+			if (!existingToken) {
+				brandNewToken = mintInStore(store, family, key)
+				token = brandNewToken
+			} else {
+				token = existingToken
+			}
+		}
+	} else {
+		family = params[0]
+		key = params[1]
+		value = params[2]
+		existingToken = seekInStore(store, family, key)
+		if (!existingToken) {
+			brandNewToken = mintInStore(store, family, key)
+			token = brandNewToken
+		} else {
+			token = existingToken
+		}
+	}
+
+	const action = value === RESET_STATE ? `reset` : `set`
+
+	let target: Store & { operation: OpenOperation }
+
+	if (ownOp) {
+		const result = openOperation(store, token)
+		const rejected = typeof result === `number`
+		if (rejected) {
+			const rejectionTime = result
+			const unsubscribe = store.on.operationClose.subscribe(
+				`waiting to ${action} "${token.key}" at T-${rejectionTime}`,
+				function waitUntilOperationCloseToSetState() {
+					unsubscribe()
+					store.logger.info(
+						`🟢`,
+						token.type,
+						token.key,
+						`resuming deferred`,
+						action,
+						`from T-${rejectionTime}`,
+					)
+					operateOnStore(store, ownOp, token, value)
+				},
+			)
+			return
+		}
+		target = result
+	} else {
+		target = store as Store & { operation: OpenOperation }
+	}
+
+	if (`counterfeit` in token && `family` in token) {
+		const subKey = token.family.subKey
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === subKey,
+		)
+		store.logger.error(
+			`❌`,
+			token.type,
+			token.key,
+			`could not be`,
+			action,
+			`because it was not found in the store "${store.config.name}".`,
+			disposal
+				? `This state was previously disposed:\n${disposal.trace}`
+				: `No previous disposal trace was found.`,
+		)
+		return
+	}
+
+	const state = withdraw(target, token)
+	let protoUpdate: [T, T]
+	if (value === RESET_STATE) {
+		protoUpdate = resetAtomOrSelector(target, state)
+	} else {
+		protoUpdate = setAtomOrSelector(target, state, value)
+	}
+	const isNewlyCreated = Boolean(brandNewToken)
+	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated)
+
+	if (ownOp) {
+		closeOperation(target)
+	}
+}

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

@@ -1,40 +1,49 @@
-import type { Atom, WritableState } from ".."
+import type { Atom, OpenOperation, Store, WritableState } from ".."
 import { traceRootSelectorAtoms } from ".."
-import type { Store } from "../store"
+import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import { setAtom } from "./set-atom"
 
-function resetAtom(store: Store, state: Atom<any>) {
-	switch (state.type) {
+function resetAtom<T>(
+	target: Store & { operation: OpenOperation },
+	atom: Atom<T>,
+): [oldValue: T, newValue: T] {
+	switch (atom.type) {
 		case `mutable_atom`:
-			setAtom(store, state, new state.class())
-			return
+			return setAtom(target, atom, new atom.class())
 		case `atom`: {
-			let def = state.default
+			let def = atom.default
 			if (def instanceof Function) {
 				def = def()
 			}
-			setAtom(store, state, def)
+			return setAtom(target, atom, def)
 		}
 	}
 }
 
-export function resetAtomOrSelector(
-	store: Store,
-	state: WritableState<any>,
-): void {
+export function resetAtomOrSelector<T>(
+	target: Store & { operation: OpenOperation },
+	state: WritableState<T>,
+): [oldValue: T, newValue: T] {
+	let protoUpdate: [T, T]
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
-			resetAtom(store, state)
+			protoUpdate = resetAtom(target, state)
 			break
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
 			{
-				const atoms = traceRootSelectorAtoms(store, state.key)
+				const oldValue = state.getFrom(target)
+				const atoms = traceRootSelectorAtoms(target, state.key)
 				for (const atom of atoms.values()) {
-					resetAtom(store, atom)
+					const rootProtoUpdate = resetAtom(target, atom)
+					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false)
 				}
+				const newValue = state.getFrom(target)
+				protoUpdate = [oldValue, newValue]
 			}
 			break
 	}
+
+	return protoUpdate
 }

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

@@ -1,20 +1,25 @@
 import type { WritableState } from ".."
+import type { OpenOperation } from "../operation"
 import type { Store } from "../store"
 import { setAtom } from "./set-atom"
+import { setSelector } from "./set-selector"
 
 export const setAtomOrSelector = <T>(
-	store: Store,
+	target: Store & { operation: OpenOperation },
 	state: WritableState<T>,
 	value: T | ((oldValue: T) => T),
-): void => {
+): [oldValue: T, newValue: T] => {
+	let protoUpdate: [T, T]
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
-			setAtom(store, state, value)
+			protoUpdate = setAtom(target, state, value)
 			break
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
-			state.set(value)
+			protoUpdate = setSelector(target, state, value)
 			break
 	}
+
+	return protoUpdate
 }

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

@@ -1,65 +1,20 @@
-import type { KeyedStateUpdate } from "atom.io"
-
-import type { Atom, MutableAtom, Store } from ".."
-import { hasRole } from "../atom/has-role"
+import type { Atom, OpenOperation, Store } from ".."
 import { writeToCache } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
-import { isTransceiver, type Transceiver } from "../mutable"
 import { markDone } from "../operation"
-import { isChildStore } from "../transaction/is-root-store"
 import { become } from "./become"
-import { emitUpdate } from "./emit-update"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 
 export const setAtom = <T>(
-	target: Store,
+	target: Store & { operation: OpenOperation<any> },
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
-): void => {
+): [oldValue: T, newValue: T] => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)
 	let newValue = become(next)(oldValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
 	newValue = writeToCache(target, atom, newValue)
 	markDone(target, atom.key)
 	evictDownstreamFromAtom(target, atom)
-	const update = { oldValue, newValue }
-	if (!isChildStore(target)) {
-		emitUpdate(target, atom, update)
-		return
-	}
-	if (target.on.transactionApplying.state === null) {
-		const { key } = atom
-		if (isTransceiver(update.newValue)) {
-			return
-		}
-		const atomUpdate: KeyedStateUpdate<T> = {
-			type: `atom_update`,
-			key,
-			...update,
-		}
-		if (atom.family) {
-			atomUpdate.family = atom.family
-		}
-		target.transactionMeta.update.updates.push(atomUpdate)
-		target.logger.info(
-			`📁`,
-			`atom`,
-			key,
-			`stowed (`,
-			update.oldValue,
-			`->`,
-			update.newValue,
-			`)`,
-		)
-	} else if (hasRole(atom, `tracker:signal`)) {
-		const key = atom.key.slice(1)
-		const mutable = target.atoms.get(key) as MutableAtom<
-			Transceiver<unknown, any, any>
-		>
-		const transceiver = readOrComputeValue(target, mutable, `mut`)
-		const accepted = transceiver.do(update.newValue) === null
-		if (accepted === true) {
-			evictDownstreamFromAtom(target, mutable)
-		}
-	}
+	return [oldValue, newValue]
 }