atom.io 0.33.13 → 0.33.15

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

@@ -9,7 +9,6 @@ import { selectJson } from "atom.io/json"
 
 import type { MutableAtom } from ".."
 import { cacheValue, setIntoStore } from ".."
-import { markAtomAsDefault } from "../atom"
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
 import { Subject } from "../subject"
@@ -59,7 +58,6 @@ export function createMutableAtom<
 	}
 	const initialValue = def()
 	target.atoms.set(newAtom.key, newAtom)
-	markAtomAsDefault(store, key)
 	cacheValue(target, key, initialValue, subject)
 	const token = deposit(newAtom)
 	if (options.effects) {

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

@@ -1,4 +1,4 @@
-import type { Selector, Store } from ".."
+import type { Atom, Selector, Store } from ".."
 import type { AtomKey, StateKey } from "../keys"
 import { isAtomKey } from "../keys"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
@@ -37,13 +37,15 @@ export const traceSelectorAtoms = (
 export const traceAllSelectorAtoms = (
 	selector: Selector<any>,
 	store: Store,
-): AtomKey<unknown>[] => {
+): Atom<unknown>[] => {
 	const selectorKey = selector.key
 	const directDependencyKeys = getSelectorDependencyKeys(store, selectorKey)
 	const covered = new Set<string>()
-	return directDependencyKeys.flatMap((depKey) =>
-		isAtomKey(store, depKey)
-			? depKey
-			: traceSelectorAtoms(store, depKey, covered),
-	)
+	return directDependencyKeys
+		.flatMap((depKey) =>
+			isAtomKey(store, depKey)
+				? depKey
+				: traceSelectorAtoms(store, depKey, covered),
+		)
+		.map((atomKey) => store.atoms.get(atomKey) as Atom<unknown>)
 }

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

@@ -1,3 +1,5 @@
 export * from "./become"
+export * from "./reset-atom-or-selector"
+export * from "./reset-in-store"
 export * from "./set-atom-or-selector"
 export * from "./set-into-store"

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

@@ -0,0 +1,32 @@
+import { type Atom, traceAllSelectorAtoms, type WritableState } from ".."
+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()
+	}
+	setAtom(store, state, def)
+}
+
+export function resetAtomOrSelector(
+	store: Store,
+	state: WritableState<any>,
+): void {
+	switch (state.type) {
+		case `atom`:
+		case `mutable_atom`:
+			resetAtom(store, state)
+			break
+		case `writable_pure_selector`:
+		case `writable_held_selector`:
+			{
+				const atoms = traceAllSelectorAtoms(state, store)
+				for (const atom of atoms) {
+					resetAtom(store, atom)
+				}
+			}
+			break
+	}
+}

package/src/internal/set-state/reset-in-store.ts

@@ -0,0 +1,78 @@
+import type { WritableFamilyToken, WritableToken } from "atom.io"
+import { type Canonical, parseJson } from "atom.io/json"
+
+import { findInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
+import { closeOperation, openOperation } from "../operation"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import { resetAtomOrSelector } from "./reset-atom-or-selector"
+
+export function resetInStore(store: Store, token: WritableToken<any>): void
+
+export function resetInStore<K extends Canonical>(
+	store: Store,
+	token: WritableFamilyToken<any, K>,
+	key: K,
+): void
+
+export function resetInStore<T>(
+	store: Store,
+	...params:
+		| [token: WritableFamilyToken<T, Canonical>, key: Canonical]
+		| [token: WritableToken<T>]
+): void {
+	let token: WritableToken<T>
+	let family: WritableFamilyToken<T, Canonical> | null
+	let key: Canonical | null
+	if (params.length === 1) {
+		token = params[0]
+		family = getFamilyOfToken(store, token) ?? null
+		if (family) {
+			key = token.family ? parseJson(token.family.subKey) : null
+			token = findInStore(store, family, key)
+		}
+	} else {
+		family = params[0]
+		key = params[1]
+		token = findInStore(store, family, key)
+	}
+
+	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 reset 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 rejectionTime = openOperation(store, token)
+	if (rejectionTime) {
+		const unsubscribe = store.on.operationClose.subscribe(
+			`waiting to reset "${token.key}" at T-${rejectionTime}`,
+			() => {
+				unsubscribe()
+				store.logger.info(
+					`🟢`,
+					token.type,
+					token.key,
+					`resuming deferred resetState from T-${rejectionTime}`,
+				)
+				resetInStore(store, token)
+			},
+		)
+		return
+	}
+	const state = withdraw(store, token)
+	resetAtomOrSelector(store, state)
+	closeOperation(store)
+}

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

@@ -1,7 +1,6 @@
 import type { KeyedStateUpdate } from "atom.io"
 
 import type { Atom, Store } from ".."
-import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { isTransceiver, type Transceiver } from "../mutable"
@@ -27,9 +26,6 @@ export const setAtom = <T>(
 	newValue = become(next)(newValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
 	newValue = cacheValue(target, atom.key, newValue, atom.subject)
-	if (isAtomDefault(target, atom.key)) {
-		markAtomAsNotDefault(target, atom.key)
-	}
 	markDone(target, atom.key)
 	evictDownStream(target, atom)
 	const update = { oldValue, newValue }

package/src/internal/subscribe/subscribe-to-root-atoms.ts

@@ -11,13 +11,7 @@ export const subscribeToRootAtoms = <T>(
 ): (() => void)[] => {
 	const target = newest(store)
 	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
-		(atomKey) => {
-			const atom = target.atoms.get(atomKey)
-			if (atom === undefined) {
-				throw new Error(
-					`Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`,
-				)
-			}
+		(atom) => {
 			return atom.subject.subscribe(
 				`${selector.type}:${selector.key}`,
 				(atomChange) => {
@@ -26,7 +20,7 @@ export const subscribeToRootAtoms = <T>(
 						selector.type,
 						selector.key,
 						`root`,
-						atomKey,
+						atom.key,
 						`went`,
 						atomChange.oldValue,
 						`->`,

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

@@ -1,4 +1,10 @@
-import type { disposeState, findState, getState, setState } from "atom.io"
+import type {
+	disposeState,
+	findState,
+	getState,
+	resetState,
+	setState,
+} from "atom.io"
 
 import { arbitrary } from "../arbitrary"
 import { disposeFromStore, findInStore } from "../families"
@@ -8,7 +14,7 @@ import { Junction } from "../junction"
 import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
-import { setIntoStore } from "../set-state"
+import { resetInStore, setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import type { Func } from "../utility-types"
 import type { TransactionProgress } from "."
@@ -77,6 +83,9 @@ export const buildTransaction = (
 			set: ((...ps: Parameters<typeof setState>) => {
 				setIntoStore(child, ...ps)
 			}) as typeof setState,
+			reset: ((...ps: Parameters<typeof resetState>) => {
+				resetInStore(child, ...ps)
+			}) as typeof resetState,
 			run: (token, identifier = arbitrary()) =>
 				actUponStore(child, token, identifier),
 			find: ((...ps: Parameters<typeof findState>) =>

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

@@ -25,11 +25,13 @@ export function createTransaction<F extends Func>(
 	store: Store,
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
+	const { key } = options
+	const transactionAlreadyExists = store.transactions.has(key)
 	const newTransaction: Transaction<F> = {
-		key: options.key,
+		key,
 		type: `transaction`,
 		run: (params: Parameters<F>, id: string) => {
-			const childStore = buildTransaction(store, options.key, params, id)
+			const childStore = buildTransaction(store, key, params, id)
 			try {
 				const target = newest(store)
 				const { toolkit } = childStore.transactionMeta
@@ -38,7 +40,7 @@ export function createTransaction<F extends Func>(
 				return output
 			} catch (thrown) {
 				abortTransaction(target)
-				store.logger.warn(`💥`, `transaction`, options.key, `caught:`, thrown)
+				store.logger.warn(`💥`, `transaction`, key, `caught:`, thrown)
 				throw thrown
 			}
 		},
@@ -46,8 +48,10 @@ export function createTransaction<F extends Func>(
 		subject: new Subject(),
 	}
 	const target = newest(store)
-	target.transactions.set(newTransaction.key, newTransaction)
+	target.transactions.set(key, newTransaction)
 	const token = deposit(newTransaction)
-	store.on.transactionCreation.next(token)
+	if (!transactionAlreadyExists) {
+		store.on.transactionCreation.next(token)
+	}
 	return token
 }

package/src/introspection/attach-atom-index.ts

@@ -1,8 +1,7 @@
-import type { AtomToken, ReadonlyPureSelectorToken } from "atom.io"
+import type { AtomToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
-	createStandaloneSelector,
 	deposit,
 	isReservedIntrospectionKey,
 } from "atom.io/internal"
@@ -11,13 +10,11 @@ import type { WritableTokenIndex } from "."
 
 export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
 
-export const attachAtomIndex = (
-	store: Store,
-): ReadonlyPureSelectorToken<AtomTokenIndex> => {
-	const atomTokenIndexState__INTERNAL = createRegularAtom<AtomTokenIndex>(
+export const attachAtomIndex = (store: Store): AtomToken<AtomTokenIndex> => {
+	return createRegularAtom<AtomTokenIndex>(
 		store,
 		{
-			key: `🔍 Atom Token Index (Internal)`,
+			key: `🔍 Atom Token Index`,
 			default: () => {
 				const base: AtomTokenIndex = new Map()
 				for (const [key, val] of store.atoms) {
@@ -66,7 +63,7 @@ export const attachAtomIndex = (
 							} else {
 								self.set(atomToken.key, atomToken)
 							}
-							return self
+							return new Map(self)
 						})
 					})
 					store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
@@ -80,10 +77,8 @@ export const attachAtomIndex = (
 										self.delete(familyKey)
 									}
 								}
-							} else {
-								self.delete(atomToken.key)
 							}
-							return self
+							return new Map(self)
 						})
 					})
 				},
@@ -91,8 +86,4 @@ export const attachAtomIndex = (
 		},
 		undefined,
 	)
-	return createStandaloneSelector(store, {
-		key: `🔍 Atom Token Index`,
-		get: ({ get }) => get(atomTokenIndexState__INTERNAL),
-	})
 }

package/src/introspection/attach-introspection-states.ts

@@ -1,7 +1,7 @@
 import type {
+	AtomToken,
 	Loadable,
 	ReadonlyPureSelectorFamilyToken,
-	ReadonlyPureSelectorToken,
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
@@ -18,14 +18,14 @@ import { attachTransactionLogs } from "./attach-transaction-logs"
 import { attachTypeSelectors } from "./attach-type-selectors"
 
 export type IntrospectionStates = {
-	atomIndex: ReadonlyPureSelectorToken<AtomTokenIndex>
-	selectorIndex: ReadonlyPureSelectorToken<SelectorTokenIndex>
-	transactionIndex: ReadonlyPureSelectorToken<TransactionToken<Func>[]>
+	atomIndex: AtomToken<AtomTokenIndex>
+	selectorIndex: AtomToken<SelectorTokenIndex>
+	transactionIndex: AtomToken<TransactionToken<Func>[]>
 	transactionLogSelectors: ReadonlyPureSelectorFamilyToken<
 		TransactionUpdate<Func>[],
 		string
 	>
-	timelineIndex: ReadonlyPureSelectorToken<TimelineToken<any>[]>
+	timelineIndex: AtomToken<TimelineToken<any>[]>
 	timelineSelectors: ReadonlyPureSelectorFamilyToken<Timeline<any>, string>
 	typeSelectors: ReadonlyPureSelectorFamilyToken<Loadable<string>, string>
 }

package/src/introspection/attach-selector-index.ts

@@ -1,8 +1,7 @@
-import type { ReadonlyPureSelectorToken, SelectorToken } from "atom.io"
+import type { AtomToken, SelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
-	createStandaloneSelector,
 	deposit,
 	isReservedIntrospectionKey,
 } from "atom.io/internal"
@@ -13,97 +12,91 @@ export type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>
 
 export const attachSelectorIndex = (
 	store: Store,
-): ReadonlyPureSelectorToken<SelectorTokenIndex> => {
-	const readonlySelectorTokenIndexState__INTERNAL =
-		createRegularAtom<SelectorTokenIndex>(
-			store,
-
-			{
-				key: `🔍 Selector Token Index (Internal)`,
-				default: () => {
-					const base: SelectorTokenIndex = new Map()
-					for (const map of [store.readonlySelectors, store.writableSelectors]) {
-						for (const [key, val] of map) {
-							if (isReservedIntrospectionKey(key)) {
-								continue
-							}
-							const token = deposit(val)
-							if (val.family) {
-								let familyNode = base.get(val.family.key)
-								if (!familyNode || !(`familyMembers` in familyNode)) {
-									familyNode = {
-										key: val.family.key,
-										familyMembers: new Map(),
-									}
-									base.set(val.family.key, familyNode)
+): AtomToken<SelectorTokenIndex> => {
+	return createRegularAtom<SelectorTokenIndex>(
+		store,
+		{
+			key: `🔍 Selector Token Index`,
+			default: () => {
+				const base: SelectorTokenIndex = new Map()
+				for (const map of [store.readonlySelectors, store.writableSelectors]) {
+					for (const [key, val] of map) {
+						if (isReservedIntrospectionKey(key)) {
+							continue
+						}
+						const token = deposit(val)
+						if (val.family) {
+							let familyNode = base.get(val.family.key)
+							if (!familyNode || !(`familyMembers` in familyNode)) {
+								familyNode = {
+									key: val.family.key,
+									familyMembers: new Map(),
 								}
-								familyNode.familyMembers.set(val.family.subKey, token)
-							} else {
-								base.set(key, token)
+								base.set(val.family.key, familyNode)
 							}
+							familyNode.familyMembers.set(val.family.subKey, token)
+						} else {
+							base.set(key, token)
 						}
 					}
-					return base
-				},
-				effects: [
-					({ setSelf }) => {
-						store.on.selectorCreation.subscribe(
-							`introspection`,
-							(selectorToken) => {
-								if (isReservedIntrospectionKey(selectorToken.key)) {
-									return
-								}
+				}
+				return base
+			},
+			effects: [
+				({ setSelf }) => {
+					store.on.selectorCreation.subscribe(
+						`introspection`,
+						(selectorToken) => {
+							if (isReservedIntrospectionKey(selectorToken.key)) {
+								return
+							}
 
-								setSelf((self) => {
-									if (selectorToken.family) {
-										const { key: familyKey, subKey } = selectorToken.family
-										let familyNode = self.get(familyKey)
-										if (
-											familyNode === undefined ||
-											!(`familyMembers` in familyNode)
-										) {
-											familyNode = {
-												key: familyKey,
-												familyMembers: new Map(),
-											}
-											self.set(familyKey, familyNode)
+							setSelf((self) => {
+								if (selectorToken.family) {
+									const { key: familyKey, subKey } = selectorToken.family
+									let familyNode = self.get(familyKey)
+									if (
+										familyNode === undefined ||
+										!(`familyMembers` in familyNode)
+									) {
+										familyNode = {
+											key: familyKey,
+											familyMembers: new Map(),
 										}
-										familyNode.familyMembers.set(subKey, selectorToken)
-									} else {
-										self.set(selectorToken.key, selectorToken)
+										self.set(familyKey, familyNode)
 									}
-									return self
-								})
-							},
-						)
+									familyNode.familyMembers.set(subKey, selectorToken)
+								} else {
+									self.set(selectorToken.key, selectorToken)
+								}
+								return new Map(self)
+							})
+						},
+					)
 
-						store.on.selectorDisposal.subscribe(
-							`introspection`,
-							(selectorToken) => {
-								setSelf((self) => {
-									if (selectorToken.family) {
-										const { key: familyKey, subKey } = selectorToken.family
-										const familyNode = self.get(familyKey)
-										if (familyNode && `familyMembers` in familyNode) {
-											familyNode.familyMembers.delete(subKey)
-											if (familyNode.familyMembers.size === 0) {
-												self.delete(familyKey)
-											}
+					store.on.selectorDisposal.subscribe(
+						`introspection`,
+						(selectorToken) => {
+							setSelf((self) => {
+								if (selectorToken.family) {
+									const { key: familyKey, subKey } = selectorToken.family
+									const familyNode = self.get(familyKey)
+									if (familyNode && `familyMembers` in familyNode) {
+										familyNode.familyMembers.delete(subKey)
+										if (familyNode.familyMembers.size === 0) {
+											self.delete(familyKey)
 										}
-									} else {
-										self.delete(selectorToken.key)
 									}
-									return self
-								})
-							},
-						)
-					},
-				],
-			},
-			undefined,
-		)
-	return createStandaloneSelector(store, {
-		key: `🔍 Selector Token Index`,
-		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
-	})
+								} else {
+									self.delete(selectorToken.key)
+								}
+								return new Map(self)
+							})
+						},
+					)
+				},
+			],
+		},
+		undefined,
+	)
 }

package/src/introspection/attach-timeline-index.ts

@@ -1,16 +1,14 @@
-import type { ReadonlyPureSelectorToken, TimelineToken } from "atom.io"
+import type { AtomToken, TimelineToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
+import { createRegularAtom } from "atom.io/internal"
 
 export const attachTimelineIndex = (
 	store: Store,
-): ReadonlyPureSelectorToken<TimelineToken<any>[]> => {
-	const timelineTokenIndexState__INTERNAL = createRegularAtom<
-		TimelineToken<any>[]
-	>(
+): AtomToken<TimelineToken<any>[]> => {
+	return createRegularAtom<TimelineToken<any>[]>(
 		store,
 		{
-			key: `🔍 Timeline Token Index (Internal)`,
+			key: `🔍 Timeline Token Index`,
 			default: () =>
 				[...store.timelines].map(([key]): TimelineToken<any> => {
 					return { key, type: `timeline` }
@@ -28,9 +26,4 @@ export const attachTimelineIndex = (
 		},
 		undefined,
 	)
-	const timelineTokenIndex = createStandaloneSelector(store, {
-		key: `🔍 Timeline Token Index`,
-		get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
-	})
-	return timelineTokenIndex
 }

package/src/introspection/attach-transaction-index.ts

@@ -1,25 +1,32 @@
-import type { ReadonlyPureSelectorToken, TransactionToken } from "atom.io"
+import type { AtomToken, TransactionToken } from "atom.io"
 import type { Func, Store } from "atom.io/internal"
-import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
+import { createRegularAtom, isReservedIntrospectionKey } from "atom.io/internal"
 
 export const attachTransactionIndex = (
 	store: Store,
-): ReadonlyPureSelectorToken<TransactionToken<Func>[]> => {
-	const transactionTokenIndexState__INTERNAL = createRegularAtom<
-		TransactionToken<Func>[]
-	>(
+): AtomToken<TransactionToken<Func>[]> => {
+	return createRegularAtom<TransactionToken<Func>[]>(
 		store,
 		{
-			key: `🔍 Transaction Token Index (Internal)`,
-			default: () =>
-				[...store.transactions].map(([key]): TransactionToken<Func> => {
-					return { key, type: `transaction` }
-				}),
+			key: `🔍 Transaction Token Index`,
+			default: () => {
+				const tokens: TransactionToken<Func>[] = []
+				for (const [key] of store.transactions) {
+					if (isReservedIntrospectionKey(key)) {
+						continue
+					}
+					tokens.push({ key, type: `transaction` })
+				}
+				return tokens
+			},
 			effects: [
 				({ setSelf }) => {
 					store.on.transactionCreation.subscribe(
 						`introspection`,
 						(transactionToken) => {
+							if (isReservedIntrospectionKey(transactionToken.key)) {
+								return
+							}
 							setSelf((state) => [...state, transactionToken])
 						},
 					)
@@ -28,9 +35,4 @@ export const attachTransactionIndex = (
 		},
 		undefined,
 	)
-	const transactionTokenIndex = createStandaloneSelector(store, {
-		key: `🔍 Transaction Token Index`,
-		get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
-	})
-	return transactionTokenIndex
 }

package/src/introspection/auditor.ts

@@ -2,7 +2,6 @@ import {
 	type AtomToken,
 	getState,
 	type ReadableToken,
-	type ReadonlyPureSelectorToken,
 	type SelectorToken,
 } from "atom.io"
 import * as Internal from "atom.io/internal"
@@ -26,8 +25,8 @@ export class Auditor {
 	public readonly store: Internal.Store
 	public auditorCreatedAt: number = performance.now()
 	public statesCreatedAt: Map<string, number> = new Map()
-	public readonly atomIndex: ReadonlyPureSelectorToken<AtomTokenIndex>
-	public readonly selectorIndex: ReadonlyPureSelectorToken<SelectorTokenIndex>
+	public readonly atomIndex: AtomToken<AtomTokenIndex>
+	public readonly selectorIndex: AtomToken<SelectorTokenIndex>
 	public disposed = false
 
 	private readonly unsubscribeFromAtomCreation: () => void

package/src/main/index.ts

@@ -16,6 +16,7 @@ export * from "./get-state"
 export * from "./join"
 export * from "./logger"
 export * from "./realm"
+export * from "./reset-state"
 export * from "./selector"
 export * from "./set-state"
 export * from "./silo"