atom.io 0.40.0 → 0.40.2

package/src/internal/families/create-selector-family.ts

@@ -11,36 +11,36 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-import type { Store } from "../store"
+import type { RootStore } from "../transaction"
 import { createReadonlyHeldSelectorFamily } from "./create-readonly-held-selector-family"
 import { createReadonlyPureSelectorFamily } from "./create-readonly-pure-selector-family"
 import { createWritableHeldSelectorFamily } from "./create-writable-held-selector-family"
 import { createWritablePureSelectorFamily } from "./create-writable-pure-selector-family"
 
 export function createSelectorFamily<T extends object, K extends Canonical>(
-	store: Store,
+	store: RootStore,
 	options: WritableHeldSelectorFamilyOptions<T, K>,
 ): WritableHeldSelectorFamilyToken<T, K>
 export function createSelectorFamily<T extends object, K extends Canonical>(
-	store: Store,
+	store: RootStore,
 	options: ReadonlyHeldSelectorFamilyOptions<T, K>,
 ): ReadonlyHeldSelectorFamilyToken<T, K>
-export function createSelectorFamily<T, K extends Canonical>(
-	store: Store,
-	options: WritablePureSelectorFamilyOptions<T, K>,
-): WritablePureSelectorFamilyToken<T, K>
-export function createSelectorFamily<T, K extends Canonical>(
-	store: Store,
-	options: ReadonlyPureSelectorFamilyOptions<T, K>,
-): ReadonlyPureSelectorFamilyToken<T, K>
+export function createSelectorFamily<T, K extends Canonical, E>(
+	store: RootStore,
+	options: WritablePureSelectorFamilyOptions<T, K, E>,
+): WritablePureSelectorFamilyToken<T, K, E>
+export function createSelectorFamily<T, K extends Canonical, E>(
+	store: RootStore,
+	options: ReadonlyPureSelectorFamilyOptions<T, K, E>,
+): ReadonlyPureSelectorFamilyToken<T, K, E>
 export function createSelectorFamily(
-	store: Store,
+	store: RootStore,
 	options:
 		| ReadonlyHeldSelectorFamilyOptions<any, any>
-		| ReadonlyPureSelectorFamilyOptions<any, any>
+		| ReadonlyPureSelectorFamilyOptions<any, any, any>
 		| WritableHeldSelectorFamilyOptions<any, any>
-		| WritablePureSelectorFamilyOptions<any, any>,
-): SelectorFamilyToken<any, any> {
+		| WritablePureSelectorFamilyOptions<any, any, any>,
+): SelectorFamilyToken<any, any, any> {
 	const isWritable = `set` in options
 	const isHeld = `const` in options
 

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

@@ -9,7 +9,7 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { WritableHeldSelectorFamily } from ".."
+import type { RootStore, WritableHeldSelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createWritableHeldSelector } from "../selector"
 import type { Store } from "../store"
@@ -68,7 +68,7 @@ export function createWritableHeldSelectorFamily<
 	const selectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createWritableHeldSelectorFamily(s, options),
+		install: (s: RootStore) => createWritableHeldSelectorFamily(s, options),
 		default: options.const,
 	}) satisfies WritableHeldSelectorFamily<T, K>
 

package/src/internal/families/create-writable-pure-selector-family.ts

@@ -5,35 +5,32 @@ import type {
 	StateLifecycleEvent,
 	WritablePureSelectorFamilyOptions,
 	WritablePureSelectorFamilyToken,
+	WritablePureSelectorOptions,
 	WritablePureSelectorToken,
 } from "atom.io"
 import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import {
-	findInStore,
-	getFromStore,
-	getJsonToken,
-	type WritablePureSelectorFamily,
-} from ".."
+import type { RootStore, WritablePureSelectorFamily } from ".."
+import { findInStore, getFromStore, getJsonToken } from ".."
 import { newest } from "../lineage"
 import { createWritablePureSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createWritablePureSelectorFamily<T, K extends Canonical>(
+export function createWritablePureSelectorFamily<T, K extends Canonical, E>(
 	store: Store,
-	options: WritablePureSelectorFamilyOptions<T, K>,
+	options: WritablePureSelectorFamilyOptions<T, K, E>,
 	internalRoles?: string[],
-): WritablePureSelectorFamilyToken<T, K> {
+): WritablePureSelectorFamilyToken<T, K, E> {
 	const familyKey = options.key
 	const type = `writable_pure_selector_family`
 
 	const familyToken = {
 		key: familyKey,
 		type,
-	} as const satisfies WritablePureSelectorFamilyToken<T, K>
+	} as const satisfies WritablePureSelectorFamilyToken<T, K, E>
 
 	const existing = store.families.get(familyKey)
 	if (existing) {
@@ -45,22 +42,28 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 		)
 	}
 	const subject = new Subject<
-		StateLifecycleEvent<WritablePureSelectorToken<T>>
+		StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>
 	>()
 
-	const familyFunction = (key: K): WritablePureSelectorToken<T> => {
+	const familyFunction = <Key extends K>(
+		key: Key,
+	): WritablePureSelectorToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
-		const family: FamilyMetadata = { key: familyKey, subKey }
+		const family: FamilyMetadata<Key> = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
+		const individualOptions: WritablePureSelectorOptions<T, E> = {
+			key: fullKey,
+			get: options.get(key),
+			set: options.set(key),
+		}
+		if (options.catch) {
+			individualOptions.catch = options.catch
+		}
 
-		const token = createWritablePureSelector(
+		const token = createWritablePureSelector<T, Key, E>(
 			target,
-			{
-				key: fullKey,
-				get: options.get(key),
-				set: options.set(key),
-			},
+			individualOptions,
 			family,
 		)
 
@@ -71,7 +74,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 	const selectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createWritablePureSelectorFamily(s, options),
+		install: (s: RootStore) => createWritablePureSelectorFamily(s, options),
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
@@ -82,7 +85,8 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies WritablePureSelectorFamily<T, K>
+		...(options.catch ? { catch: options.catch } : {}),
+	}) satisfies WritablePureSelectorFamily<T, K, E>
 
 	store.families.set(familyKey, selectorFamily)
 	return familyToken

package/src/internal/families/dispose-from-store.ts

@@ -6,21 +6,31 @@ import { disposeSelector } from "../selector"
 import { type Store, withdraw } from "../store"
 import { findInStore } from "./find-in-store"
 
-export function disposeFromStore(store: Store, token: ReadableToken<any>): void
+export function disposeFromStore(
+	store: Store,
+	token: ReadableToken<any, any, any>,
+): void
 
-export function disposeFromStore<K extends Canonical>(
+export function disposeFromStore<K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadableFamilyToken<any, K>,
-	key: K,
+	token: ReadableFamilyToken<any, K, any>,
+	key: Key,
+): void
+
+export function disposeFromStore<K extends Canonical, Key extends K>(
+	store: Store,
+	...params:
+		| [token: ReadableFamilyToken<any, K, any>, key: Key]
+		| [token: ReadableToken<any, any, any>]
 ): void
 
 export function disposeFromStore(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<any, any>, key: Canonical]
-		| [token: ReadableToken<any>]
+		| [token: ReadableFamilyToken<any, any, any>, key: Canonical]
+		| [token: ReadableToken<any, any, any>]
 ): void {
-	let token: ReadableToken<any>
+	let token: ReadableToken<any, any, any>
 	if (params.length === 1) {
 		token = params[0]
 	} else {

package/src/internal/families/find-in-store.ts

@@ -38,53 +38,53 @@ export function findInStore<
 	key: Key,
 ): MutableAtomToken<T, K>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: RegularAtomFamilyToken<T, K>,
+	familyToken: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
-): RegularAtomToken<T, K>
+): RegularAtomToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: AtomFamilyToken<T, K>,
+	familyToken: AtomFamilyToken<T, K, E>,
 	key: Key,
-): AtomToken<T, K>
+): AtomToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: WritablePureSelectorFamilyToken<T, K>,
+	familyToken: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): WritablePureSelectorToken<T, K>
+): WritablePureSelectorToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: ReadonlyPureSelectorFamilyToken<T, K>,
+	familyToken: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): ReadonlyPureSelectorToken<T, K>
+): ReadonlyPureSelectorToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: SelectorFamilyToken<T, K>,
+	familyToken: SelectorFamilyToken<T, K, E>,
 	key: Key,
-): SelectorToken<T, K>
+): SelectorToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: WritableFamilyToken<T, K>,
+	familyToken: WritableFamilyToken<T, K, E>,
 	key: Key,
-): WritableToken<T, K>
+): WritableToken<T, K, E>
 
-export function findInStore<T, K extends Canonical, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	familyToken: ReadableFamilyToken<T, K>,
+	familyToken: ReadableFamilyToken<T, K, E>,
 	key: Key,
-): ReadableToken<T, K>
+): ReadableToken<T, K, E>
 
 export function findInStore(
 	store: Store,
-	familyToken: ReadableFamilyToken<any, any>,
+	familyToken: ReadableFamilyToken<any, any, any>,
 	key: Canonical,
-): ReadableToken<any> {
+): ReadableToken<any, any, any> {
 	const family = withdraw(store, familyToken)
 	const existingStateToken = seekInStore(store, familyToken, key)
 	if (existingStateToken) {

package/src/internal/families/get-family-of-token.ts

@@ -24,35 +24,35 @@ export function getFamilyOfToken<
 	K extends Canonical,
 >(store: Store, token: MutableAtomToken<T, K>): MutableAtomFamily<T, K>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: RegularAtomToken<T, K>,
-): RegularAtomFamily<T, K>
+	token: RegularAtomToken<T, K, E>,
+): RegularAtomFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: WritablePureSelectorToken<T, K>,
-): WritablePureSelectorFamily<T, K>
+	token: WritablePureSelectorToken<T, K, E>,
+): WritablePureSelectorFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadonlyPureSelectorToken<T, K>,
-): ReadonlyPureSelectorFamily<T, K>
+	token: ReadonlyPureSelectorToken<T, K, E>,
+): ReadonlyPureSelectorFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: WritableToken<T, K>,
-): WritableFamily<T, K>
+	token: WritableToken<T, K, E>,
+): WritableFamily<T, K, E>
 
-export function getFamilyOfToken<T, K extends Canonical>(
+export function getFamilyOfToken<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadableToken<T, K>,
-): ReadableFamily<T, K>
+	token: ReadableToken<T, K, E>,
+): ReadableFamily<T, K, E>
 
 export function getFamilyOfToken(
 	store: Store,
-	token: ReadableToken<any, any>,
-): ReadableFamily<any, any> {
+	token: ReadableToken<any, any, any>,
+): ReadableFamily<any, any, any> {
 	return withdraw(store, {
 		// biome-ignore lint/style/noNonNullAssertion: family is required
 		key: token.family!.key,

package/src/internal/families/mint-in-store.ts

@@ -8,24 +8,24 @@ import { COUNTERFEIT, mint } from "../store"
 
 export const MUST_CREATE: unique symbol = Symbol(`MUST_CREATE`)
 
-export function mintInStore<T, K extends Canonical, Key extends K>(
+export function mintInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamily<T, K, E>,
 	key: Key,
 	mustCreate?: typeof MUST_CREATE,
-): WritableToken<T, K>
-export function mintInStore<T, K extends Canonical, Key extends K>(
+): WritableToken<T, Key, E>
+export function mintInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamily<T, K, E>,
 	key: Key,
 	mustCreate?: typeof MUST_CREATE,
-): ReadableToken<T, K>
-export function mintInStore<T, K extends Canonical, Key extends K>(
+): ReadableToken<T, Key, E>
+export function mintInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamily<T, K, E>,
 	key: Key,
 	mustCreate?: typeof MUST_CREATE,
-): ReadableToken<T, K> {
+): ReadableToken<T, Key, E> {
 	const stringKey = stringifyJson(key)
 	const molecule = store.molecules.get(stringKey)
 
@@ -43,7 +43,7 @@ export function mintInStore<T, K extends Canonical, Key extends K>(
 		return mint(family, key, COUNTERFEIT)
 	}
 
-	let token: ReadableToken<T, K>
+	let token: ReadableToken<T, Key, E>
 	if (mustCreate === MUST_CREATE) {
 		store.logger.info(
 			`👪`,

package/src/internal/families/seek-in-store.ts

@@ -19,7 +19,7 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { Molecule, ReadableState } from ".."
+import type { ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { deposit, type Store } from "../store"
@@ -32,59 +32,59 @@ export function seekInStore<
 	store: Store,
 	token: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, K> | undefined
+): MutableAtomToken<T, Key> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: RegularAtomFamilyToken<T, K>,
+	token: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
-): RegularAtomToken<T, K> | undefined
+): RegularAtomToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: AtomFamilyToken<T, K>,
+	token: AtomFamilyToken<T, K, E>,
 	key: Key,
-): AtomToken<T, K> | undefined
+): AtomToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: WritablePureSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): WritablePureSelectorToken<T, K> | undefined
+): WritablePureSelectorToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): ReadonlyPureSelectorToken<T, K> | undefined
+): ReadonlyPureSelectorToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: SelectorFamilyToken<T, K>,
+	token: SelectorFamilyToken<T, K, E>,
 	key: Key,
-): SelectorToken<T, K> | undefined
+): SelectorToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
+	token: WritableFamilyToken<T, K, E>,
 	key: Key,
-): WritableToken<T, K> | undefined
+): WritableToken<T, Key, E> | undefined
 
-export function seekInStore<T, K extends Canonical, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
+	token: ReadableFamilyToken<T, K, E>,
 	key: Key,
-): ReadableToken<T, K> | undefined
+): ReadableToken<T, Key, E> | undefined
 
 export function seekInStore(
 	store: Store,
-	token: ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any, any>,
 	key: Canonical,
-): ReadableToken<any> | undefined {
+): ReadableToken<any, any, any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const target = newest(store)
-	let state: Molecule<any> | ReadableState<any> | undefined
+	let state: ReadableState<any, any> | undefined
 	switch (token.type) {
 		case `atom_family`:
 		case `mutable_atom_family`:

package/src/internal/get-state/get-fallback.ts

@@ -1,15 +1,15 @@
-import type { ReadableToken } from "atom.io"
+import type { ReadableToken, ViewOf } from "atom.io"
 import { type Canonical, stringifyJson } from "atom.io/json"
 
 import type { ReadableFamily } from ".."
 import type { Store } from "../store"
 
-export function getFallback<T, K extends Canonical>(
+export function getFallback<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadableToken<T, K>,
-	family: ReadableFamily<T, K>,
+	token: ReadableToken<T, K, E>,
+	family: ReadableFamily<T, K, E>,
 	subKey: K,
-): T {
+): ViewOf<E | T> {
 	const disposal = store.disposalTraces.buffer.find(
 		(item) => item?.key === stringifyJson(subKey),
 	)
@@ -31,7 +31,7 @@ export function getFallback<T, K extends Canonical>(
 			}
 			const defaultValue = new family.class()
 			store.defaults.set(family.key, defaultValue)
-			return defaultValue
+			return defaultValue.READONLY_VIEW
 		}
 		case `atom_family`: {
 			if (store.defaults.has(family.key)) {
@@ -40,7 +40,7 @@ export function getFallback<T, K extends Canonical>(
 			const def = family.default as (key: K) => T
 			const defaultValue = def(subKey)
 			store.defaults.set(family.key, defaultValue)
-			return defaultValue
+			return defaultValue as ViewOf<T>
 		}
 		case `readonly_pure_selector_family`:
 		case `writable_pure_selector_family`:
@@ -51,7 +51,7 @@ export function getFallback<T, K extends Canonical>(
 			}
 			const defaultValue = family.default(subKey)
 			store.defaults.set(family.key, defaultValue)
-			return defaultValue
+			return defaultValue as ViewOf<T>
 		}
 	}
 }

package/src/internal/get-state/get-from-store.ts

@@ -1,4 +1,4 @@
-import type { ReadableFamilyToken, ReadableToken } from "atom.io"
+import type { ReadableFamilyToken, ReadableToken, ViewOf } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import { type Store, withdraw } from "../store"
@@ -8,18 +8,30 @@ import { reduceReference } from "./reduce-reference"
 
 export function getFromStore<T>(store: Store, token: ReadableToken<T>): T
 
-export function getFromStore<T, K extends Canonical>(
+export function getFromStore<T, E>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
+	token: ReadableToken<T, any, E>,
+): E | T
+
+export function getFromStore<T, K extends Canonical, E>(
+	store: Store,
+	token: ReadableFamilyToken<T, K, E>,
 	key: K,
-): T
+): ViewOf<E | T>
+
+export function getFromStore<T, K extends Canonical, Key extends K, E>(
+	store: Store,
+	...params:
+		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableToken<T, any, E>]
+): ViewOf<E | T>
 
-export function getFromStore(
+export function getFromStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<any, any>, key: Canonical]
-		| [token: ReadableToken<any>]
-): any {
+		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableToken<T, any, E>]
+): ViewOf<E | T> {
 	const { token, family, subKey } = reduceReference(store, ...params)
 
 	if (`counterfeit` in token && family && subKey) {