atom.io 0.33.2 → 0.33.3

package/src/internal/selector/create-writable-held-selector.ts

@@ -0,0 +1,68 @@
+import type {
+	FamilyMetadata,
+	WritableHeldSelectorOptions,
+	WritableHeldSelectorToken,
+} from "atom.io"
+
+import type { WritableHeldSelector } from ".."
+import { cacheValue } from "../caching"
+import { newest } from "../lineage"
+import { markDone } from "../operation"
+import { become } from "../set-state"
+import type { Store } from "../store"
+import { Subject } from "../subject"
+import { isRootStore } from "../transaction"
+import { registerSelector } from "./register-selector"
+
+export const createWritableHeldSelector = <T extends object>(
+	store: Store,
+	options: WritableHeldSelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+): WritableHeldSelectorToken<T> => {
+	const target = newest(store)
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const covered = new Set<string>()
+	const { key, const: constant } = options
+	const type = `writable_held_selector` as const
+	const setterToolkit = registerSelector(target, type, key, covered)
+	const { find, get, json } = setterToolkit
+	const getterToolkit = { find, get, json }
+
+	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+		getFn(getterToolkit, constant)
+		cacheValue(innerTarget, key, constant, subject)
+		covered.clear()
+		return constant
+	}
+
+	const setSelf = (next: T | ((oldValue: T) => T)): void => {
+		const innerTarget = newest(store)
+		const oldValue = getSelf(options.get, innerTarget)
+		const newValue = become(next)(oldValue)
+		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`)
+		cacheValue(innerTarget, key, newValue, subject)
+		markDone(innerTarget, key)
+		if (isRootStore(innerTarget)) {
+			subject.next({ newValue, oldValue })
+		}
+		options.set(setterToolkit, newValue)
+	}
+	const mySelector: WritableHeldSelector<T> = {
+		...options,
+		type,
+		subject,
+		install: (s: Store) => createWritableHeldSelector(s, options, family),
+		get: getSelf,
+		set: setSelf,
+		...(family && { family }),
+	}
+	target.writableSelectors.set(key, mySelector)
+	const initialValue = getSelf()
+	store.logger.info(`✨`, type, key, `=`, initialValue)
+
+	const token: WritableHeldSelectorToken<T> = { key, type }
+	if (family) {
+		token.family = family
+	}
+	return token
+}

package/src/internal/selector/{create-writable-selector.ts → create-writable-pure-selector.ts}

@@ -1,10 +1,10 @@
 import type {
 	FamilyMetadata,
-	WritableSelectorOptions,
-	WritableSelectorToken,
+	WritablePureSelectorOptions,
+	WritablePureSelectorToken,
 } from "atom.io"
 
-import type { WritableSelector } from ".."
+import type { WritablePureSelector } from ".."
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
 import { markDone } from "../operation"
@@ -14,21 +14,23 @@ import { Subject } from "../subject"
 import { isRootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
-export const createWritableSelector = <T>(
+export const createWritablePureSelector = <T>(
 	store: Store,
-	options: WritableSelectorOptions<T>,
+	options: WritablePureSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-): WritableSelectorToken<T> => {
+): WritablePureSelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
-	const setterToolkit = registerSelector(options.key, covered, target)
+	const key = options.key
+	const type = `writable_pure_selector` as const
+	const setterToolkit = registerSelector(target, type, key, covered)
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
 
 	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
 		const value = getFn(getterToolkit)
-		cacheValue(innerTarget, options.key, value, subject)
+		cacheValue(innerTarget, key, value, subject)
 		covered.clear()
 		return value
 	}
@@ -37,16 +39,7 @@ export const createWritableSelector = <T>(
 		const innerTarget = newest(store)
 		const oldValue = getSelf(options.get, innerTarget)
 		const newValue = become(next)(oldValue)
-		store.logger.info(
-			`📝`,
-			`selector`,
-			options.key,
-			`set (`,
-			oldValue,
-			`->`,
-			newValue,
-			`)`,
-		)
+		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`)
 		cacheValue(innerTarget, options.key, newValue, subject)
 		markDone(innerTarget, options.key)
 		if (isRootStore(innerTarget)) {
@@ -54,21 +47,21 @@ export const createWritableSelector = <T>(
 		}
 		options.set(setterToolkit, newValue)
 	}
-	const mySelector: WritableSelector<T> = {
+	const mySelector: WritablePureSelector<T> = {
 		...options,
+		type,
 		subject,
-		install: (s: Store) => createWritableSelector(s, options, family),
+		install: (s: Store) => createWritablePureSelector(s, options, family),
 		get: getSelf,
 		set: setSelf,
-		type: `selector`,
 		...(family && { family }),
 	}
-	target.selectors.set(options.key, mySelector)
+	target.writableSelectors.set(key, mySelector)
 	const initialValue = getSelf()
 	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
-	const token: WritableSelectorToken<T> = {
-		key: options.key,
-		type: `selector`,
+	const token: WritablePureSelectorToken<T> = {
+		key,
+		type,
 	}
 	if (family) {
 		token.family = family

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

@@ -8,12 +8,12 @@ export function disposeSelector(
 	selectorToken: SelectorToken<unknown>,
 ): void {
 	const target = newest(store)
-	const { key } = selectorToken
+	const { key, type } = selectorToken
 	const selector = withdraw(target, selectorToken)
 	if (!selector.family) {
 		store.logger.error(
 			`❌`,
-			`selector`,
+			type,
 			key,
 			`Standalone selectors cannot be disposed.`,
 		)
@@ -24,12 +24,12 @@ export function disposeSelector(
 		}
 		let familyToken: SelectorFamilyToken<any, any>
 		switch (selectorToken.type) {
-			case `selector`:
+			case `writable_held_selector`:
 				{
-					target.selectors.delete(key)
+					target.writableSelectors.delete(key)
 					familyToken = {
 						key: selector.family.key,
-						type: `selector_family`,
+						type: `writable_held_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
 					family.subject.next({
@@ -39,12 +39,42 @@ export function disposeSelector(
 					})
 				}
 				break
-			case `readonly_selector`:
+			case `writable_pure_selector`:
+				{
+					target.writableSelectors.delete(key)
+					familyToken = {
+						key: selector.family.key,
+						type: `writable_pure_selector_family`,
+					}
+					const family = withdraw(store, familyToken)
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+					})
+				}
+				break
+			case `readonly_held_selector`:
+				{
+					target.readonlySelectors.delete(key)
+					familyToken = {
+						key: selector.family.key,
+						type: `readonly_held_selector_family`,
+					}
+					const family = withdraw(store, familyToken)
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+					})
+				}
+				break
+			case `readonly_pure_selector`:
 				{
 					target.readonlySelectors.delete(key)
 					familyToken = {
 						key: selector.family.key,
-						type: `readonly_selector_family`,
+						type: `readonly_pure_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
 					family.subject.next({

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

@@ -4,8 +4,8 @@ import { newest } from "../lineage"
 import type { Store } from "../store"
 
 export const getSelectorDependencyKeys = (
-	key: string,
 	store: Store,
+	key: string,
 ): (
 	| AtomKey<unknown>
 	| ReadonlySelectorKey<unknown>

package/src/internal/selector/index.ts

@@ -1,6 +1,8 @@
-export * from "./create-readonly-selector"
+export * from "./create-readonly-held-selector"
+export * from "./create-readonly-pure-selector"
 export * from "./create-standalone-selector"
-export * from "./create-writable-selector"
+export * from "./create-writable-held-selector"
+export * from "./create-writable-pure-selector"
 export * from "./dispose-selector"
 export * from "./get-selector-dependency-keys"
 export * from "./register-selector"

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

@@ -19,9 +19,14 @@ import { withdraw } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
+	store: Store,
+	selectorType:
+		| `readonly_held_selector`
+		| `readonly_pure_selector`
+		| `writable_held_selector`
+		| `writable_pure_selector`,
 	selectorKey: string,
 	covered: Set<string>,
-	store: Store,
 ): SetterToolkit => ({
 	get: (
 		...params:
@@ -40,26 +45,33 @@ export const registerSelector = (
 
 		const dependencyState = withdraw(store, dependency)
 		const dependencyValue = readOrComputeValue(store, dependencyState)
+		const dependencyKey = dependency.key
 
 		store.logger.info(
 			`🔌`,
-			`selector`,
+			selectorType,
 			selectorKey,
-			`registers dependency ( "${dependency.key}" =`,
+			`registers dependency ( "${dependencyKey}" =`,
 			dependencyValue,
 			`)`,
 		)
 
 		target.selectorGraph.set(
 			{
-				upstreamSelectorKey: dependency.key,
+				upstreamSelectorKey: dependencyKey,
 				downstreamSelectorKey: selectorKey,
 			},
 			{
 				source: dependency.key,
 			},
 		)
-		updateSelectorAtoms(selectorKey, dependency as any, covered, store)
+		updateSelectorAtoms(
+			store,
+			selectorType,
+			selectorKey,
+			dependency as any,
+			covered,
+		)
 		return dependencyValue
 	},
 	set: (<T, New extends T>(

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

@@ -4,15 +4,15 @@ import { isAtomKey } from "../keys"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
 export const traceSelectorAtoms = (
+	store: Store,
 	directDependencyKey: StateKey<unknown>,
 	covered: Set<string>,
-	store: Store,
 ): AtomKey<unknown>[] => {
 	const rootKeys: AtomKey<unknown>[] = []
 
 	const indirectDependencyKeys = getSelectorDependencyKeys(
-		directDependencyKey,
 		store,
+		directDependencyKey,
 	)
 	while (indirectDependencyKeys.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
@@ -24,7 +24,7 @@ export const traceSelectorAtoms = (
 
 		if (!isAtomKey(store, indirectDependencyKey)) {
 			indirectDependencyKeys.push(
-				...getSelectorDependencyKeys(indirectDependencyKey, store),
+				...getSelectorDependencyKeys(store, indirectDependencyKey),
 			)
 		} else if (!rootKeys.includes(indirectDependencyKey)) {
 			rootKeys.push(indirectDependencyKey)
@@ -39,11 +39,11 @@ export const traceAllSelectorAtoms = (
 	store: Store,
 ): AtomKey<unknown>[] => {
 	const selectorKey = selector.key
-	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store)
+	const directDependencyKeys = getSelectorDependencyKeys(store, selectorKey)
 	const covered = new Set<string>()
 	return directDependencyKeys.flatMap((depKey) =>
 		isAtomKey(store, depKey)
 			? depKey
-			: traceSelectorAtoms(depKey, covered, store),
+			: traceSelectorAtoms(store, depKey, covered),
 	)
 }

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

@@ -1,32 +1,38 @@
-import type { ReadonlySelectorToken, WritableToken } from "atom.io"
+import type { ReadonlyPureSelectorToken, WritableToken } from "atom.io"
 
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { traceSelectorAtoms } from "./trace-selector-atoms"
 
 export const updateSelectorAtoms = (
+	store: Store,
+	selectorType:
+		| `readonly_held_selector`
+		| `readonly_pure_selector`
+		| `writable_held_selector`
+		| `writable_pure_selector`,
 	selectorKey: string,
-	dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>,
+	dependency: ReadonlyPureSelectorToken<unknown> | WritableToken<unknown>,
 	covered: Set<string>,
-	store: Store,
 ): void => {
 	const target = newest(store)
-	if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
+	const { type: dependencyType, key: dependencyKey } = dependency
+	if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
 		target.selectorAtoms.set({
 			selectorKey,
-			atomKey: dependency.key,
+			atomKey: dependencyKey,
 		})
 		store.logger.info(
 			`🔍`,
-			`selector`,
+			selectorType,
 			selectorKey,
-			`discovers root atom "${dependency.key}"`,
+			`discovers root atom "${dependencyKey}"`,
 		)
 	} else {
-		const rootKeys = traceSelectorAtoms(dependency.key, covered, store)
+		const rootKeys = traceSelectorAtoms(store, dependencyKey, covered)
 		store.logger.info(
 			`🔍`,
-			`selector`,
+			selectorType,
 			selectorKey,
 			`discovers root atoms: [ ${rootKeys
 				.map((key) => `"${key}"`)
@@ -39,5 +45,5 @@ export const updateSelectorAtoms = (
 			})
 		}
 	}
-	covered.add(dependency.key)
+	covered.add(dependencyKey)
 }

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

@@ -20,8 +20,10 @@ export const emitUpdate = <T>(
 			)
 			break
 		case `atom`:
-		case `selector`:
-		case `readonly_selector`:
+		case `writable_pure_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `readonly_held_selector`:
 			store.logger.info(
 				`📢`,
 				state.type,

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

@@ -12,7 +12,8 @@ export const setAtomOrSelector = <T>(
 		case `mutable_atom`:
 			setAtom(store, state, value)
 			break
-		case `selector`:
+		case `writable_pure_selector`:
+		case `writable_held_selector`:
 			state.set(value)
 			break
 	}

package/src/internal/store/counterfeit.ts

@@ -5,15 +5,15 @@ import type {
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
 	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
@@ -23,10 +23,12 @@ import type { Transceiver } from "../mutable"
 
 export const FAMILY_MEMBER_TOKEN_TYPES = {
 	atom_family: `atom`,
-	mutable_atom_family: `mutable_atom`,
-	selector_family: `selector`,
-	readonly_selector_family: `readonly_selector`,
 	molecule_family: `molecule`,
+	mutable_atom_family: `mutable_atom`,
+	readonly_held_selector_family: `readonly_held_selector`,
+	readonly_pure_selector_family: `readonly_pure_selector`,
+	writable_held_selector_family: `writable_held_selector`,
+	writable_pure_selector_family: `writable_pure_selector`,
 } as const
 
 export function counterfeit<
@@ -47,14 +49,14 @@ export function counterfeit<T, K extends Canonical, Key extends K>(
 ): AtomToken<T>
 
 export function counterfeit<T, K extends Canonical, Key extends K>(
-	token: WritableSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T>
+): WritablePureSelectorToken<T>
 
 export function counterfeit<T, K extends Canonical, Key extends K>(
-	token: ReadonlySelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T>
+): ReadonlyPureSelectorToken<T>
 
 export function counterfeit<T, K extends Canonical, Key extends K>(
 	token: SelectorFamilyToken<T, K>,

package/src/internal/store/deposit.ts

@@ -6,8 +6,8 @@ import type {
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	SelectorFamilyToken,
@@ -16,8 +16,8 @@ import type {
 	TimelineToken,
 	TransactionToken,
 	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
@@ -31,8 +31,8 @@ import type {
 	MutableAtomFamily,
 	ReadableFamily,
 	ReadableState,
-	ReadonlySelector,
-	ReadonlySelectorFamily,
+	ReadonlyPureSelector,
+	ReadonlyPureSelectorFamily,
 	RegularAtom,
 	RegularAtomFamily,
 	Selector,
@@ -40,8 +40,8 @@ import type {
 	Timeline,
 	Transceiver,
 	WritableFamily,
-	WritableSelector,
-	WritableSelectorFamily,
+	WritablePureSelector,
+	WritablePureSelectorFamily,
 	WritableState,
 } from ".."
 import type { Transaction } from "../transaction"
@@ -51,8 +51,12 @@ export function deposit<T extends Transceiver<any>>(
 	state: MutableAtom<T, any>,
 ): MutableAtomToken<T, any>
 export function deposit<T>(state: Atom<T>): AtomToken<T>
-export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
-export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
+export function deposit<T>(
+	state: WritablePureSelector<T>,
+): WritablePureSelectorToken<T>
+export function deposit<T>(
+	state: ReadonlyPureSelector<T>,
+): ReadonlyPureSelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
 export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
@@ -67,11 +71,11 @@ export function deposit<
 >(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
 export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
 export function deposit<T>(
-	state: WritableSelectorFamily<T, any>,
-): WritableSelectorFamilyToken<T, any>
+	state: WritablePureSelectorFamily<T, any>,
+): WritablePureSelectorFamilyToken<T, any>
 export function deposit<T>(
-	state: ReadonlySelectorFamily<T, any>,
-): ReadonlySelectorFamilyToken<T, any>
+	state: ReadonlyPureSelectorFamily<T, any>,
+): ReadonlyPureSelectorFamilyToken<T, any>
 export function deposit<T>(
 	state: SelectorFamily<T, any>,
 ): SelectorFamilyToken<T, any>

package/src/internal/store/store.ts

@@ -3,22 +3,21 @@ import type {
 	Logger,
 	MoleculeCreation,
 	MoleculeDisposal,
-	ReadonlySelectorToken,
+	SelectorToken,
 	TimelineToken,
 	TransactionToken,
-	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 
 import type {
 	Atom,
+	HeldSelectorFamily,
 	MutableAtomFamily,
+	PureSelectorFamily,
 	ReadonlySelector,
-	ReadonlySelectorFamily,
 	RegularAtomFamily,
 	WritableSelector,
-	WritableSelectorFamily,
 } from ".."
 import { isReservedIntrospectionKey } from ".."
 import type { Join } from "../join"
@@ -47,7 +46,7 @@ export class Store implements Lineage {
 	public defaults: Map<string, any> = new Map()
 
 	public atoms: Map<string, Atom<any>> = new Map()
-	public selectors: Map<string, WritableSelector<any>> = new Map()
+	public writableSelectors: Map<string, WritableSelector<any>> = new Map()
 	public readonlySelectors: Map<string, ReadonlySelector<any>> = new Map()
 
 	public atomsThatAreDefault: Set<string> = new Set()
@@ -74,10 +73,10 @@ export class Store implements Lineage {
 	public trackers: Map<string, Tracker<Transceiver<any>>> = new Map()
 	public families: Map<
 		string,
+		| HeldSelectorFamily<any, any>
 		| MutableAtomFamily<any, any, any>
-		| ReadonlySelectorFamily<any, any>
+		| PureSelectorFamily<any, any>
 		| RegularAtomFamily<any, any>
-		| WritableSelectorFamily<any, any>
 	> = new Map()
 	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
 
@@ -230,7 +229,7 @@ export class Store implements Lineage {
 			for (const [, selector] of store.readonlySelectors) {
 				selector.install(this)
 			}
-			for (const [, selector] of store.selectors) {
+			for (const [, selector] of store.writableSelectors) {
 				if (mutableHelpers.has(selector.key)) {
 					continue
 				}
@@ -249,12 +248,8 @@ export class Store implements Lineage {
 export type StoreEventCarrier = {
 	atomCreation: Subject<AtomToken<unknown>>
 	atomDisposal: Subject<AtomToken<unknown>>
-	selectorCreation: Subject<
-		ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
-	>
-	selectorDisposal: Subject<
-		ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
-	>
+	selectorCreation: Subject<SelectorToken<unknown>>
+	selectorDisposal: Subject<SelectorToken<unknown>>
 	timelineCreation: Subject<TimelineToken<unknown>>
 	transactionCreation: Subject<TransactionToken<Func>>
 	transactionApplying: StatefulSubject<TransactionProgress<Func> | null>