atom.io 0.40.2 → 0.40.3

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

@@ -44,13 +44,13 @@ export function createReadonlyHeldSelectorFamily<
 		StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>
 	>()
 
-	const familyFunction = (key: K): ReadonlyHeldSelectorToken<T> => {
+	const create = (key: K): ReadonlyHeldSelectorToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
 
-		const token = createReadonlyHeldSelector(
+		return createReadonlyHeldSelector(
 			target,
 			{
 				key: fullKey,
@@ -59,17 +59,16 @@ export function createReadonlyHeldSelectorFamily<
 			},
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+	const readonlySelectorFamily: ReadonlyHeldSelectorFamily<T, K> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createReadonlyHeldSelectorFamily(s, options),
 		default: options.const,
-	}) satisfies ReadonlyHeldSelectorFamily<T, K>
+	}
 
 	store.families.set(familyKey, readonlySelectorFamily)
 	return familyToken

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

@@ -45,7 +45,7 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(
 		StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>
 	>()
 
-	const familyFunction = <Key extends K>(
+	const create = <Key extends K>(
 		key: Key,
 	): ReadonlyPureSelectorToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
@@ -60,16 +60,16 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(
 			individualOptions.catch = options.catch
 		}
 
-		const token = createReadonlyPureSelector<T, Key, E>(
+		return createReadonlyPureSelector<T, Key, E>(
 			target,
 			individualOptions,
 			family,
 		)
-
-		return token
 	}
 
-	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+	const readonlySelectorFamily: ReadonlyPureSelectorFamily<T, K, E> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createReadonlyPureSelectorFamily(s, options),
@@ -83,8 +83,7 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-		...(options.catch ? { catch: options.catch } : {}),
-	}) satisfies ReadonlyPureSelectorFamily<T, K, E>
+	}
 
 	store.families.set(familyKey, readonlySelectorFamily)
 	return familyToken

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

@@ -38,9 +38,7 @@ export function createRegularAtomFamily<T, K extends Canonical, E>(
 
 	const subject = new Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>()
 
-	const familyFunction = <Key extends K>(
-		key: Key,
-	): RegularAtomToken<T, Key, E> => {
+	const create = <Key extends K>(key: Key): RegularAtomToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata<Key> = { key: options.key, subKey }
 		const fullKey = `${options.key}(${subKey})`
@@ -58,20 +56,17 @@ export function createRegularAtomFamily<T, K extends Canonical, E>(
 			individualOptions.catch = options.catch
 		}
 
-		const token = createRegularAtom(target, individualOptions, family)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
+		return createRegularAtom(target, individualOptions, family)
 	}
 
-	const atomFamily: RegularAtomFamily<T, K, E> = Object.assign(familyFunction, {
+	const atomFamily: RegularAtomFamily<T, K, E> = {
 		...familyToken,
+		create,
 		default: options.default,
 		subject,
 		install: (s: RootStore) => createRegularAtomFamily(s, options),
 		internalRoles,
-		...(options.catch ? { catch: options.catch } : {}),
-	})
+	}
 
 	store.families.set(options.key, atomFamily)
 	if (isFn(options.default) === false) {

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

@@ -44,13 +44,13 @@ export function createWritableHeldSelectorFamily<
 		StateLifecycleEvent<WritableHeldSelectorToken<T>>
 	>()
 
-	const familyFunction = (key: K): WritableHeldSelectorToken<T> => {
+	const create = (key: K): WritableHeldSelectorToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: familyKey, subKey }
 		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
 
-		const token = createWritableHeldSelector(
+		return createWritableHeldSelector(
 			target,
 			{
 				key: fullKey,
@@ -60,17 +60,16 @@ export function createWritableHeldSelectorFamily<
 			},
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const selectorFamily = Object.assign(familyFunction, familyToken, {
+	const selectorFamily: WritableHeldSelectorFamily<T, K> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createWritableHeldSelectorFamily(s, options),
 		default: options.const,
-	}) satisfies WritableHeldSelectorFamily<T, K>
+	}
 
 	store.families.set(familyKey, selectorFamily)
 	return familyToken

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

@@ -45,7 +45,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical, E>(
 		StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>
 	>()
 
-	const familyFunction = <Key extends K>(
+	const create = <Key extends K>(
 		key: Key,
 	): WritablePureSelectorToken<T, Key, E> => {
 		const subKey = stringifyJson(key)
@@ -61,17 +61,16 @@ export function createWritablePureSelectorFamily<T, K extends Canonical, E>(
 			individualOptions.catch = options.catch
 		}
 
-		const token = createWritablePureSelector<T, Key, E>(
+		return createWritablePureSelector<T, Key, E>(
 			target,
 			individualOptions,
 			family,
 		)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
 	}
 
-	const selectorFamily = Object.assign(familyFunction, familyToken, {
+	const selectorFamily: WritablePureSelectorFamily<T, K, E> = {
+		...familyToken,
+		create,
 		internalRoles,
 		subject,
 		install: (s: RootStore) => createWritablePureSelectorFamily(s, options),
@@ -85,8 +84,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical, E>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-		...(options.catch ? { catch: options.catch } : {}),
-	}) satisfies WritablePureSelectorFamily<T, K, E>
+	}
 
 	store.families.set(familyKey, selectorFamily)
 	return familyToken

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

@@ -52,7 +52,7 @@ export function mintInStore<T, K extends Canonical, Key extends K, E>(
 			`adds member`,
 			typeof key === `string` ? `\`${key}\`` : key,
 		)
-		token = family(key)
+		token = family.create(key)
 		if (molecule) {
 			store.moleculeData.set(stringKey, family.key)
 		}

package/src/internal/index.ts

@@ -23,7 +23,7 @@ import type { Store } from "./store"
 import type { Subject } from "./subject"
 import type { Timeline } from "./timeline"
 import type { RootStore, Transaction } from "./transaction"
-import type { Flat } from "./utility-types"
+import type { Ctor, Flat } from "./utility-types"
 
 export * from "./arbitrary"
 export * from "./atom"
@@ -67,7 +67,7 @@ export type RegularAtom<T, E> = Flat<
 		default: T | (() => T)
 		cleanup?: () => void
 		internalRoles?: internalRole[]
-		catch?: readonly (new () => E)[]
+		catch?: readonly Ctor<E>[]
 	}
 >
 export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
@@ -101,14 +101,14 @@ export type WritablePureSelector<T, E> = Flat<
 		type: `writable_pure_selector`
 		getFrom: (target: Store) => E | T
 		setSelf: (newValue: T) => void
-		catch?: readonly (new () => E)[]
+		catch?: readonly Ctor<E>[]
 	}
 >
 export type ReadonlyPureSelector<T, E> = Flat<
 	AtomIOState & {
 		type: `readonly_pure_selector`
 		getFrom: (target: Store) => E | T
-		catch?: readonly (new () => E)[]
+		catch?: readonly Ctor<E>[]
 	}
 >
 export type ReadonlySelector<T, E> =
@@ -135,13 +135,13 @@ export type RegularAtomFamily<T, K extends Canonical, E = never> =
 	& Flat<
 		& RegularAtomFamilyToken<T, K, E>
 		& {
+			create: <Key extends K>(key: Key) => RegularAtomToken<T, Key, E>
 			default: T | ((key: K) => T)
 			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
 			subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>
 		}
 	>
-	& (<Key extends K>(key: Key) => RegularAtomToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type MutableAtomFamily<
@@ -151,13 +151,13 @@ export type MutableAtomFamily<
 	& Flat<
 		& MutableAtomFamilyToken<T, K>
 		& {
+				create: <Key extends K>(key: Key) => MutableAtomToken<T, Key>
 				class: ConstructorOf<T>
 				install: (store: RootStore) => void
 				internalRoles: string[] | undefined
 				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
 			}
 	>
-	& (<Key extends K>(key: Key) => MutableAtomToken<T, Key>)
 
 export type AtomFamily<T, K extends Canonical, E> =
 	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
@@ -168,52 +168,52 @@ export type WritablePureSelectorFamily<T, K extends Canonical, E> =
 	& Flat<
 		& WritablePureSelectorFamilyToken<T, K, E>
 		& {
+			create: <Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>
 			default: (key: K) => T,
 			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
 			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>
 		}
 	>
-	& (<Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type WritableHeldSelectorFamily<T , K extends Canonical> =
 	& Flat<
 		& WritableHeldSelectorFamilyToken<T, K>
 		& {
+			create: <Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>
 			default: (key: K) => T,
 			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
 			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>
 		}
 	>
-	& (<Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>)
 
 // biome-ignore format: intersection
 export type ReadonlyPureSelectorFamily<T, K extends Canonical, E> =
 	& Flat<
 		& ReadonlyPureSelectorFamilyToken<T, K, E>
 		& {
+			create: <Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>
 			default: (key: K) => T,
 			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
 			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>
 		}
 	>
-	& (<Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
 	& Flat<
 		& ReadonlyHeldSelectorFamilyToken<T, K>
 		& {
+			create: <Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>
 			default: (key: K) => T,
 			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
 			subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>
 		}
 	>
-	& (<Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>)
 
 export type PureSelectorFamily<T, K extends Canonical, E> =
 	| ReadonlyPureSelectorFamily<T, K, E>

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

@@ -44,7 +44,7 @@ export function createMutableAtomFamily<
 
 	const subject = new Subject<StateLifecycleEvent<MutableAtomToken<T>>>()
 
-	const familyFunction = (key: K): MutableAtomToken<T> => {
+	const create = (key: K): MutableAtomToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: options.key, subKey }
 		const fullKey = `${options.key}(${subKey})`
@@ -58,18 +58,17 @@ export function createMutableAtomFamily<
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createMutableAtom(target, individualOptions, family)
-
-		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
-		return token
+		return createMutableAtom(target, individualOptions, family)
 	}
 
-	const atomFamily = Object.assign(familyFunction, familyToken, {
+	const atomFamily: MutableAtomFamily<T, K> = {
+		...familyToken,
+		create,
 		class: options.class,
 		subject,
 		install: (s: RootStore) => createMutableAtomFamily(s, options),
 		internalRoles,
-	}) satisfies MutableAtomFamily<T, K>
+	}
 
 	store.families.set(options.key, atomFamily)
 

package/src/internal/utility-types.ts

@@ -1,5 +1,7 @@
 export type Fn = (...parameters: any[]) => any
 
+export type Ctor<T> = new (...args: any[]) => T
+
 export type Flat<R extends { [K in PropertyKey]: any }> = {
 	[K in keyof R]: R[K]
 }

package/src/main/atom.ts

@@ -1,4 +1,4 @@
-import type { ConstructorOf, Transceiver } from "atom.io/internal"
+import type { ConstructorOf, Ctor, Transceiver } from "atom.io/internal"
 import {
 	createMutableAtom,
 	createMutableAtomFamily,
@@ -25,7 +25,7 @@ export type RegularAtomOptions<T, E = never> = {
 	/** Hooks used to run side effects when the atom is set */
 	effects?: readonly AtomEffect<T>[]
 	/** The classes of errors that might be thrown when deriving the atom's default value */
-	catch?: readonly (new () => E)[]
+	catch?: readonly Ctor<E>[]
 }
 /**
  * Create a regular atom, a global reactive variable in the implicit store
@@ -91,7 +91,7 @@ export type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
 	/** Hooks used to run side effects when an atom in the family is set  */
 	effects?: (key: K) => AtomEffect<T>[]
 	/** The classes of errors that might be thrown when deriving the atom's default value */
-	catch?: readonly (new () => E)[]
+	catch?: readonly Ctor<E>[]
 }
 /**
  * Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.

package/src/main/selector.ts

@@ -1,3 +1,4 @@
+import type { Ctor } from "atom.io/internal"
 import {
 	createSelectorFamily,
 	createStandaloneSelector,
@@ -25,7 +26,7 @@ export type WritablePureSelectorOptions<T, E = never> = {
 	/** For each instantiated selector, a function that sets its value */
 	set: Write<(newValue: T) => void>
 	/** The classes of errors that might be thrown when deriving the atom's default value */
-	catch?: readonly (new () => E)[]
+	catch?: readonly Ctor<E>[]
 }
 export type ReadonlyPureSelectorOptions<T, E = never> = {
 	/** The unique identifier of the selector */
@@ -33,7 +34,7 @@ export type ReadonlyPureSelectorOptions<T, E = never> = {
 	/** For each instantiated selector, a function that computes its value */
 	get: Read<() => T>
 	/** The classes of errors that might be thrown when deriving the atom's default value */
-	catch?: readonly (new () => E)[]
+	catch?: readonly Ctor<E>[]
 }
 export type ReadonlyHeldSelectorOptions<T extends object> = {
 	/** The unique identifier of the selector */
@@ -154,7 +155,7 @@ export type WritablePureSelectorFamilyOptions<
 	/** For each instantiated family member, a function that sets its value */
 	set: (key: K) => Write<(newValue: T) => void>
 	/** The classes of errors that might be thrown when deriving the atom's default value */
-	catch?: readonly (new () => E)[]
+	catch?: readonly Ctor<E>[]
 }
 export type ReadonlyPureSelectorFamilyOptions<
 	T,
@@ -166,7 +167,7 @@ export type ReadonlyPureSelectorFamilyOptions<
 	/** For each instantiated family member, a function that computes its value */
 	get: (key: K) => Read<() => T>
 	/** The classes of errors that might be thrown when deriving the atom's default value */
-	catch?: readonly (new () => E)[]
+	catch?: readonly Ctor<E>[]
 }
 export type WritableHeldSelectorFamilyOptions<
 	T extends object,