atom.io 0.40.0 → 0.40.2

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

@@ -18,25 +18,31 @@ export type ProtoUpdate<T> = { oldValue: T; newValue: T }
 export const OWN_OP: unique symbol = Symbol(`OWN_OP`)
 export const JOIN_OP: unique symbol = Symbol(`JOIN_OP`)
 
-export function operateOnStore<T, New extends T>(
+export function operateOnStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+	E,
+>(
 	store: Store,
 	opMode: typeof JOIN_OP | typeof OWN_OP,
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K, E>,
+				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, Key, E>,
 				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: WritableFamily<T, Canonical> | undefined
-	let key: Canonical | null
+	let existingToken: WritableToken<T, Key, E> | undefined
+	let brandNewToken: WritableToken<T, Key, E> | undefined
+	let token: WritableToken<T, Key, E>
+	let family: WritableFamily<T, K, E> | undefined
+	let key: Key | null
 	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
 	if (params.length === 2) {
 		token = params[0]
@@ -116,7 +122,7 @@ export function operateOnStore<T, New extends T>(
 	}
 
 	const state = withdraw(target, token)
-	let protoUpdate: ProtoUpdate<T>
+	let protoUpdate: ProtoUpdate<E | T>
 	if (value === RESET_STATE) {
 		protoUpdate = resetAtomOrSelector(target, state)
 	} else {

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

@@ -5,10 +5,10 @@ import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
 
-function resetAtom<T>(
+function resetAtom<T, E>(
 	target: Store & { operation: OpenOperation },
-	atom: Atom<T>,
-): ProtoUpdate<T> {
+	atom: Atom<T, E>,
+): ProtoUpdate<E | T> {
 	switch (atom.type) {
 		case `mutable_atom`:
 			return setAtom(target, atom, new atom.class())
@@ -20,11 +20,11 @@ function resetAtom<T>(
 	}
 }
 
-export function resetAtomOrSelector<T>(
+export function resetAtomOrSelector<T, E>(
 	target: Store & { operation: OpenOperation },
-	state: WritableState<T>,
-): ProtoUpdate<T> {
-	let protoUpdate: ProtoUpdate<T>
+	state: WritableState<T, E>,
+): ProtoUpdate<E | T> {
+	let protoUpdate: ProtoUpdate<E | T>
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:

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

@@ -6,29 +6,30 @@ import { setIntoStore } from "./set-into-store"
 
 export const RESET_STATE: unique symbol = Symbol(`RESET`)
 
-export function resetInStore(store: Store, token: WritableToken<any>): void
+export function resetInStore(
+	store: Store,
+	token: WritableToken<any, any, any>,
+): void
 
 export function resetInStore<K extends Canonical>(
 	store: Store,
-	token: WritableFamilyToken<any, K>,
+	token: WritableFamilyToken<any, K, any>,
 	key: K,
 ): void
 
-export function resetInStore<T>(
+export function resetInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
+	...params:
+		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableToken<T, any, any>]
+): void
+
+export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, Canonical>, key: Canonical]
-		| [token: WritableToken<T>]
+		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableToken<T, any, any>]
 ): void {
-	let token: WritableToken<T>
-	let family: WritableFamilyToken<T, Canonical> | null
-	let key: Canonical | null
-	if (params.length === 1) {
-		token = params[0]
-		setIntoStore(store, token, RESET_STATE)
-	} else {
-		family = params[0]
-		key = params[1]
-		setIntoStore(store, family, key, RESET_STATE)
-	}
+	const subParams = [...params, RESET_STATE] as const
+	setIntoStore(store, ...subParams)
 }

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

@@ -7,7 +7,7 @@ import { setSelector } from "./set-selector"
 
 export const setAtomOrSelector = <T>(
 	target: Store & { operation: OpenOperation },
-	state: WritableState<T>,
+	state: WritableState<T, any>,
 	value: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> => {
 	let protoUpdate: ProtoUpdate<T>

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

@@ -8,7 +8,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 
 export const setAtom = <T>(
 	target: Store & { operation: OpenOperation<any> },
-	atom: Atom<T>,
+	atom: Atom<T, any>,
 	next: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)

package/src/internal/set-state/set-into-store.ts

@@ -5,9 +5,9 @@ import type { Store } from "../store"
 import { operateOnStore, OWN_OP } from "./operate-on-store"
 import type { RESET_STATE } from "./reset-in-store"
 
-export function setIntoStore<T, New extends T>(
+export function setIntoStore<T, New extends T, E>(
 	store: Store,
-	token: WritableToken<T>,
+	token: WritableToken<T, any, E>,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
@@ -16,23 +16,50 @@ export function setIntoStore<
 	K extends Canonical,
 	New extends T,
 	Key extends K,
+	E,
 >(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
-export function setIntoStore<T, New extends T>(
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+	E,
+>(
+	store: Store,
+	...params:
+		| [
+				token: WritableFamilyToken<T, K, E>,
+				key: Key,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+		| [
+				token: WritableToken<T, any, E>,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+): void
+
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+	E,
+>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K, E>,
+				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [
-				token: WritableToken<T>,
+				token: WritableToken<T, any, E>,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {

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

@@ -7,7 +7,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 
 export function setSelector<T>(
 	target: Store & { operation: OpenOperation<any> },
-	selector: WritableSelector<T>,
+	selector: WritableSelector<T, any>,
 	next: T | ((oldValue: T) => T),
 ): ProtoUpdate<T> {
 	let oldValue: T

package/src/internal/store/deposit.ts

@@ -46,44 +46,52 @@ import type {
 } from ".."
 import type { Transaction } from "../transaction"
 
-export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
+export function deposit<T, E>(
+	state: RegularAtom<T, E>,
+): RegularAtomToken<T, Canonical, E>
 export function deposit<T extends Transceiver<any, any, any>>(
 	state: MutableAtom<T>,
 ): MutableAtomToken<T>
-export function deposit<T>(state: Atom<T>): AtomToken<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>
+export function deposit<T, E>(state: Atom<T, E>): AtomToken<T, Canonical, E>
+export function deposit<T, E>(
+	state: WritablePureSelector<T, E>,
+): WritablePureSelectorToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadonlyPureSelector<T, E>,
+): ReadonlyPureSelectorToken<T, any, E>
+export function deposit<T, E>(state: Selector<T, E>): SelectorToken<T, any, E>
+export function deposit<T, E>(
+	state: WritableState<T, E>,
+): WritableToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadableState<T, E>,
+): ReadableToken<T, any, E>
 
-export function deposit<T, K extends Canonical>(
-	state: RegularAtomFamily<T, K>,
-): RegularAtomFamilyToken<T, K>
+export function deposit<T, K extends Canonical, E>(
+	state: RegularAtomFamily<T, K, E>,
+): RegularAtomFamilyToken<T, K, E>
 export function deposit<
 	T extends Transceiver<any, 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>,
-): WritablePureSelectorFamilyToken<T, any>
-export function deposit<T>(
-	state: ReadonlyPureSelectorFamily<T, any>,
-): ReadonlyPureSelectorFamilyToken<T, any>
-export function deposit<T>(
-	state: SelectorFamily<T, any>,
-): SelectorFamilyToken<T, any>
-export function deposit<T>(
-	state: WritableFamily<T, any>,
-): WritableFamilyToken<T, any>
-export function deposit<T>(
-	state: ReadableFamily<T, any>,
-): ReadableFamilyToken<T, any>
+export function deposit<T, E>(
+	state: AtomFamily<T, any, E>,
+): AtomFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: WritablePureSelectorFamily<T, any, E>,
+): WritablePureSelectorFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadonlyPureSelectorFamily<T, any, E>,
+): ReadonlyPureSelectorFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: SelectorFamily<T, any, E>,
+): SelectorFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: WritableFamily<T, any, E>,
+): WritableFamilyToken<T, any, E>
+export function deposit<T, E>(
+	state: ReadableFamily<T, any, E>,
+): ReadableFamilyToken<T, any, E>
 
 export function deposit<T extends Fn>(state: Transaction<T>): TransactionToken<T>
 export function deposit<M extends TimelineManageable>(

package/src/internal/store/mint-or-counterfeit.ts

@@ -39,53 +39,53 @@ export function mint<
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: RegularAtomFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): RegularAtomToken<T>
+): RegularAtomToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: AtomFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: AtomFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): AtomToken<T>
+): AtomToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: WritablePureSelectorFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): WritablePureSelectorToken<T>
+): WritablePureSelectorToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): ReadonlyPureSelectorToken<T>
+): ReadonlyPureSelectorToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: SelectorFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: SelectorFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): SelectorToken<T>
+): SelectorToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: WritableFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): WritableToken<T>
+): WritableToken<T, Key, E>
 
-export function mint<T, K extends Canonical, Key extends K>(
-	token: ReadableFamilyToken<T, K>,
+export function mint<T, K extends Canonical, Key extends K, E>(
+	token: ReadableFamilyToken<T, K, E>,
 	key: Key,
 	counterfeit?: typeof COUNTERFEIT,
-): ReadableToken<T>
+): ReadableToken<T, Key, E>
 
 export function mint(
-	token: ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any, any>,
 	key: Canonical,
 	counterfeit?: typeof COUNTERFEIT,
-): ReadableToken<any> {
+): ReadableToken<any, any, any> {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]

package/src/internal/store/store.ts

@@ -30,6 +30,8 @@ import type { OperationProgress } from "../operation"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type {
+	ChildStore,
+	RootStore,
 	Transaction,
 	TransactionEpoch,
 	TransactionProgress,
@@ -39,15 +41,15 @@ import type { Fn } from "../utility-types"
 import { CircularBuffer } from "./circular-buffer"
 
 export class Store implements Lineage {
-	public parent: Store | null = null
-	public child: Store | null = null
+	public parent: ChildStore | RootStore | null = null
+	public child: ChildStore | null = null
 
 	public valueMap: Map<string, any> = new Map()
 	public defaults: Map<string, any> = new Map()
 
-	public atoms: Map<string, Atom<any>> = new Map()
-	public writableSelectors: Map<string, WritableSelector<any>> = new Map()
-	public readonlySelectors: Map<string, ReadonlySelector<any>> = new Map()
+	public atoms: Map<string, Atom<any, any>> = new Map()
+	public writableSelectors: Map<string, WritableSelector<any, any>> = new Map()
+	public readonlySelectors: Map<string, ReadonlySelector<any, any>> = new Map()
 
 	public atomsThatAreDefault: Set<string> = new Set()
 	public selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string> =
@@ -75,8 +77,8 @@ export class Store implements Lineage {
 		string,
 		| HeldSelectorFamily<any, any>
 		| MutableAtomFamily<any, any>
-		| PureSelectorFamily<any, any>
-		| RegularAtomFamily<any, any>
+		| PureSelectorFamily<any, any, any>
+		| RegularAtomFamily<any, any, any>
 	> = new Map()
 	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
 
@@ -210,14 +212,14 @@ export class Store implements Lineage {
 				) {
 					continue
 				}
-				family.install(this)
+				family.install(this as RootStore)
 			}
 			const mutableHelpers = new Set<string>()
 			for (const [, atom] of store.atoms) {
 				if (mutableHelpers.has(atom.key)) {
 					continue
 				}
-				atom.install(this)
+				atom.install(this as RootStore)
 				if (atom.type === `mutable_atom`) {
 					const originalJsonToken = getJsonToken(store, atom)
 					const originalUpdateToken = getUpdateToken(atom)
@@ -226,29 +228,29 @@ export class Store implements Lineage {
 				}
 			}
 			for (const [, selector] of store.readonlySelectors) {
-				selector.install(this)
+				selector.install(this as RootStore)
 			}
 			for (const [, selector] of store.writableSelectors) {
 				if (mutableHelpers.has(selector.key)) {
 					continue
 				}
-				selector.install(this)
+				selector.install(this as RootStore)
 			}
 			for (const [, tx] of store.transactions) {
-				tx.install(this)
+				tx.install(this as RootStore)
 			}
 			for (const [, timeline] of store.timelines) {
-				timeline.install(this)
+				timeline.install(this as RootStore)
 			}
 		}
 	}
 }
 
 export type StoreEventCarrier = {
-	atomCreation: Subject<AtomToken<unknown>>
-	atomDisposal: Subject<AtomToken<unknown>>
-	selectorCreation: Subject<SelectorToken<unknown>>
-	selectorDisposal: Subject<SelectorToken<unknown>>
+	atomCreation: Subject<AtomToken<unknown, any, any>>
+	atomDisposal: Subject<AtomToken<unknown, any, any>>
+	selectorCreation: Subject<SelectorToken<unknown, any, any>>
+	selectorDisposal: Subject<SelectorToken<unknown, any, any>>
 	timelineCreation: Subject<TimelineToken<unknown>>
 	transactionCreation: Subject<TransactionToken<Fn>>
 	transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>
@@ -258,15 +260,15 @@ export type StoreEventCarrier = {
 }
 
 declare global {
-	var ATOM_IO_IMPLICIT_STORE: Store | undefined
+	var ATOM_IO_IMPLICIT_STORE: RootStore | undefined
 }
 
-export const IMPLICIT: { readonly STORE: Store } = {
-	get STORE(): Store {
+export const IMPLICIT: { readonly STORE: RootStore } = {
+	get STORE(): RootStore {
 		globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
 			name: `IMPLICIT_STORE`,
 			lifespan: `ephemeral`,
-		})
+		}) as RootStore
 		return globalThis.ATOM_IO_IMPLICIT_STORE
 	},
 }