atom.io 0.33.14 → 0.33.16

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

@@ -12,7 +12,6 @@ import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
 import { subscribeToState } from "../subscribe"
-import { markAtomAsDefault } from "./is-default"
 
 export function createRegularAtom<T>(
 	store: Store,
@@ -56,7 +55,6 @@ export function createRegularAtom<T>(
 		initialValue = def()
 	}
 	target.atoms.set(key, newAtom)
-	markAtomAsDefault(store, key)
 	cacheValue(target, key, initialValue, subject)
 	const token = deposit(newAtom)
 	if (options.effects) {

package/src/internal/atom/index.ts

@@ -1,4 +1,3 @@
 export * from "./create-regular-atom"
 export * from "./create-standalone-atom"
 export * from "./dispose-atom"
-export * from "./is-default"

package/src/internal/families/create-regular-atom-family.ts

@@ -51,7 +51,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		const def = options.default
 		const individualOptions: RegularAtomOptions<T> = {
 			key: fullKey,
-			default: def instanceof Function ? def(key) : def,
+			default: def instanceof Function ? () => def(key) : def,
 		}
 		if (options.effects) {
 			individualOptions.effects = options.effects(key)

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/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"

package/src/main/reset-state.ts

@@ -0,0 +1,35 @@
+import * as Internal from "atom.io/internal"
+import type { Canonical } from "atom.io/json"
+
+import type { WritableFamilyToken, WritableToken } from "."
+
+/**
+ * @public
+ * Set the value of a state into the implicit store back to its default value.
+ * @param token - An atom or writable selector token.
+ * @overload Default
+ * @default
+ */
+export function resetState(token: WritableToken<any>): void
+/**
+ * @public
+ * Set the value of a state into the implicit store back to its default value.
+ * @param token - An atom family or writable selector family token.
+ * @param key - The unique key of the state to set.
+ * @overload Streamlined
+ */
+export function resetState<K extends Canonical>(
+	token: WritableFamilyToken<any, K>,
+	key: K,
+): void
+export function resetState(
+	...params:
+		| [token: WritableFamilyToken<any, Canonical>, key: Canonical]
+		| [token: WritableToken<any>]
+): void {
+	if (params.length === 2) {
+		Internal.resetInStore(Internal.IMPLICIT.STORE, ...params)
+	} else {
+		Internal.resetInStore(Internal.IMPLICIT.STORE, ...params)
+	}
+}

package/src/main/silo.ts

@@ -13,6 +13,7 @@ import {
 	getFromStore,
 	IMPLICIT,
 	installIntoStore,
+	resetInStore,
 	setIntoStore,
 	Store,
 	subscribeInStore,
@@ -30,6 +31,7 @@ import type {
 	undo,
 } from "."
 import type { atom, atomFamily } from "./atom"
+import type { resetState } from "./reset-state"
 import type { selector, selectorFamily } from "./selector"
 import type { runTransaction, transaction } from "./transaction"
 
@@ -44,6 +46,7 @@ export class Silo {
 	public findState: typeof findState
 	public getState: typeof getState
 	public setState: typeof setState
+	public resetState: typeof resetState
 	public disposeState: typeof disposeState
 	public subscribe: typeof subscribe
 	public undo: typeof undo
@@ -70,6 +73,9 @@ export class Silo {
 		this.setState = ((...params: Parameters<typeof setState>) => {
 			setIntoStore(s, ...params)
 		}) as typeof setState
+		this.resetState = ((...params: Parameters<typeof resetState>) => {
+			resetInStore(s, ...params)
+		}) as typeof resetState
 		this.disposeState = ((...params: Parameters<typeof disposeState>) => {
 			disposeFromStore(s, ...params)
 		}) as typeof disposeState

package/src/main/transaction.ts

@@ -16,6 +16,7 @@ import type {
 	TokenType,
 	WritablePureSelectorToken,
 } from "."
+import type { resetState } from "./reset-state"
 
 export type TransactionToken<F extends Func> = {
 	key: string
@@ -93,6 +94,7 @@ export type SetterToolkit = Readonly<{
 export type ActorToolkit = Readonly<{
 	get: typeof getState
 	set: typeof setState
+	reset: typeof resetState
 	find: typeof findState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,

package/src/internal/atom/is-default.ts

@@ -1,18 +0,0 @@
-import { newest } from "../lineage"
-import type { Store } from "../store"
-
-export const isAtomDefault = (store: Store, key: string): boolean => {
-	const core = newest(store)
-	return core.atomsThatAreDefault.has(key)
-}
-
-export const markAtomAsDefault = (store: Store, key: string): void => {
-	const core = newest(store)
-	core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key)
-}
-
-export const markAtomAsNotDefault = (store: Store, key: string): void => {
-	const core = newest(store)
-	core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault)
-	core.atomsThatAreDefault.delete(key)
-}