atom.io 0.34.2 → 0.36.0

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

@@ -4,11 +4,18 @@ 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()
+	switch (state.type) {
+		case `mutable_atom`:
+			setAtom(store, state, new state.class())
+			return
+		case `atom`: {
+			let def = state.default
+			if (def instanceof Function) {
+				def = def()
+			}
+			setAtom(store, state, def)
+		}
 	}
-	setAtom(store, state, def)
 }
 
 export function resetAtomOrSelector(

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

@@ -60,7 +60,7 @@ export const setAtom = <T>(
 	} else if (atom.key.startsWith(`*`)) {
 		const mutableKey = atom.key.slice(1)
 		const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
-		let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
+		let transceiver: Transceiver<any, any> = target.valueMap.get(mutableKey)
 		if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
 			const { parent } = target
 			const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent)

package/src/internal/store/counterfeit.ts

@@ -16,7 +16,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
@@ -32,11 +32,10 @@ export const FAMILY_MEMBER_TOKEN_TYPES = {
 } as const
 
 export function counterfeit<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
->(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
 
 export function counterfeit<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,

package/src/internal/store/deposit.ts

@@ -20,7 +20,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
@@ -47,9 +47,9 @@ import type {
 import type { Transaction } from "../transaction"
 
 export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
-export function deposit<T extends Transceiver<any>>(
-	state: MutableAtom<T, any>,
-): MutableAtomToken<T, any>
+export function deposit<T extends Transceiver<any, any>>(
+	state: MutableAtom<T>,
+): MutableAtomToken<T>
 export function deposit<T>(state: Atom<T>): AtomToken<T>
 export function deposit<T>(
 	state: WritablePureSelector<T>,
@@ -64,11 +64,9 @@ export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T, K extends Canonical>(
 	state: RegularAtomFamily<T, K>,
 ): RegularAtomFamilyToken<T, K>
-export function deposit<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
+export function deposit<T extends Transceiver<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>,

package/src/internal/store/store.ts

@@ -70,11 +70,11 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public trackers: Map<string, Tracker<Transceiver<any>>> = new Map()
+	public trackers: Map<string, Tracker<Transceiver<any, any>>> = new Map()
 	public families: Map<
 		string,
 		| HeldSelectorFamily<any, any>
-		| MutableAtomFamily<any, any, any>
+		| MutableAtomFamily<any, any>
 		| PureSelectorFamily<any, any>
 		| RegularAtomFamily<any, any>
 	> = new Map()

package/src/internal/store/withdraw.ts

@@ -32,7 +32,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
@@ -76,10 +76,10 @@ export function withdraw<T>(
 	store: Store,
 	token: RegularAtomToken<T>,
 ): RegularAtom<T>
-export function withdraw<T extends Transceiver<any>>(
+export function withdraw<T extends Transceiver<any, any>>(
 	store: Store,
 	token: MutableAtomToken<T, any>,
-): MutableAtom<T, any>
+): MutableAtom<T>
 export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
 export function withdraw<T>(
 	store: Store,
@@ -127,14 +127,10 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 ): RegularAtomFamily<T, K>
-export function withdraw<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
-): MutableAtomFamily<T, J, K>
+export function withdraw<T extends Transceiver<any, any>, K extends Canonical>(
+	store: Store,
+	token: MutableAtomFamilyToken<T, K>,
+): MutableAtomFamily<T, K>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,

package/src/json/entries.ts

@@ -1,32 +1,32 @@
 import type { Count, Flat } from "atom.io/internal"
 
-/** @public Tuples of `[key, value]` pairs, as returned from `Object.entries` */
+/** Tuples of `[key, value]` pairs, as returned from `Object.entries` */
 export type Entries<K extends PropertyKey = PropertyKey, V = any> = [K, V][]
 
-/** @public The collective or "union" type of the keys in a set of entries */
+/** The collective or "union" type of the keys in a set of entries */
 export type KeyOfEntries<E extends Entries> = E extends [infer K, any][]
 	? K
 	: never
 
-/** @public The type of the value of entry `K` in a set of entries `E` */
+/** The type of the value of entry `K` in a set of entries `E` */
 export type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
 	[P in Count<E[`length`]>]: E[P] extends [K, infer V] ? V : never
 }[Count<E[`length`]>]
 
-/** @public The type of a set of entries `E` in object form */
+/** The type of a set of entries `E` in object form */
 export type FromEntries<E extends Entries> = Flat<{
 	[K in KeyOfEntries<E>]: ValueOfEntry<E, K>
 }>
 
-/** @public Typed form of `Object.fromEntries` */
+/** Typed form of `Object.fromEntries` */
 export function fromEntries<E extends Entries>(entries: E): FromEntries<E> {
 	return Object.fromEntries(entries) as FromEntries<E>
 }
 
-/** @public The type of an object T in {@link Entries} form */
+/** The type of an object T in {@link Entries} form */
 export type ToEntries<T extends object> = Entries<keyof T, T[keyof T]>
 
-/** @public Typed form of `Object.entries` */
+/** Typed form of `Object.entries` */
 export function toEntries<T extends object>(obj: T): ToEntries<T> {
 	return Object.entries(obj) as Entries<keyof T, T[keyof T]>
 }

package/src/json/index.ts

@@ -1,6 +1,4 @@
 export * from "./entries"
-export * from "./select-json"
-export * from "./select-json-family"
 
 export type primitive = boolean | number | string | null
 

package/src/main/atom.ts

@@ -1,15 +1,48 @@
-import type { Transceiver } from "atom.io/internal"
+import type { ConstructorOf, Transceiver } from "atom.io/internal"
 import {
-	createAtomFamily,
-	createStandaloneAtom,
+	createMutableAtom,
+	createMutableAtomFamily,
+	createRegularAtom,
+	createRegularAtomFamily,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Canonical, Json, JsonInterface } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import type { AtomToken, MutableAtomToken, RegularAtomToken, Setter } from "."
+import type { Setter } from "./set-state"
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+} from "./tokens"
 
+export type RegularAtomOptions<T> = {
+	/** The unique identifier of the atom */
+	key: string
+	/** The starting value of the atom */
+	default: T | (() => T)
+	/** Hooks used to run side effects when the atom is set */
+	effects?: AtomEffect<T>[]
+}
+/**
+ * Create a regular atom, a global reactive variable in the implicit store
+ * @param options - {@link RegularAtomOptions}.
+ * @returns
+ * A reference to the atom created: a {@link RegularAtomToken}
+ */
+export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T> {
+	return createRegularAtom(IMPLICIT.STORE, options, undefined)
+}
+
+export type MutableAtomOptions<T extends Transceiver<any, any>> = {
+	/** The unique identifier of the atom */
+	key: string
+	/** A constructor for the atom's value */
+	class: ConstructorOf<T>
+	/** Hooks used to run side effects when the atom is set */
+	effects?: AtomEffect<T>[]
+}
 /**
- * @public
  * Create a mutable atom, a global reactive variable in the implicit store
  *
  * The value of a mutable atom must be some kind of {@link Transceiver}.
@@ -17,27 +50,20 @@ import type { AtomToken, MutableAtomToken, RegularAtomToken, Setter } from "."
  * @param options - {@link MutableAtomOptions}.
  * @returns
  * A reference to the atom created: a {@link MutableAtomToken}
- * @overload Mutable
  */
-export function atom<T extends Transceiver<any>, J extends Json.Serializable>(
-	options: MutableAtomOptions<T, J>,
-): MutableAtomToken<T, J>
+export function mutableAtom<T extends Transceiver<any, any>>(
+	options: MutableAtomOptions<T>,
+): MutableAtomToken<T> {
+	return createMutableAtom(IMPLICIT.STORE, options, undefined)
+}
+
 /**
- * @public
- * Create a regular atom, a global reactive variable in the implicit store
- * @param options - {@link RegularAtomOptions}.
+ * A function that runs side effects when the atom is set
+ * @param tools - {@link Effectors} that can be used to run side effects
  * @returns
- * A reference to the atom created: a {@link RegularAtomToken}
- * @overload Regular
+ * Optionally, a cleanup function that will be called when the atom is disposed
  */
-export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
-export function atom(
-	options: MutableAtomOptions<any, any> | RegularAtomOptions<any>,
-): AtomToken<any> {
-	return createStandaloneAtom(IMPLICIT.STORE, options)
-}
-
-/** @public */
+export type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void
 export type Effectors<T> = {
 	/**
 	 * Reset the value of the atom to its default
@@ -52,44 +78,6 @@ export type Effectors<T> = {
 	onSet: (callback: (options: { newValue: T; oldValue: T }) => void) => void
 }
 
-/**
- * @public
- * A function that runs side effects when the atom is set
- * @param tools - {@link Effectors} that can be used to run side effects
- * @returns
- * Optionally, a cleanup function that will be called when the atom is disposed
- */
-export type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void
-
-/** @public */
-export type RegularAtomOptions<T> = {
-	/** The unique identifier of the atom */
-	key: string
-	/** The starting value of the atom */
-	default: T | (() => T)
-	/** Hooks used to run side effects when the atom is set */
-	effects?: AtomEffect<T>[]
-}
-
-/** @public */
-// biome-ignore format: intersection
-export type MutableAtomOptions<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-> =
-	& JsonInterface<T, J>
-	& {
-		/** Used to signal that the atom is mutable */
-		mutable: true
-		/** The unique identifier of the atom */
-		key: string
-		/** A function to create an initial value for the atom */
-		default: () => T
-		/** Hooks used to run side effects when the atom is set */
-		effects?: AtomEffect<T>[]
-	}
-
-/** @public */
 export type RegularAtomFamilyOptions<T, K extends Canonical> = {
 	/** The unique identifier of the atom family */
 	key: string
@@ -98,59 +86,30 @@ export type RegularAtomFamilyOptions<T, K extends Canonical> = {
 	/** Hooks used to run side effects when an atom in the family is set  */
 	effects?: (key: K) => AtomEffect<T>[]
 }
-
-export type RegularAtomFamilyToken<T, K extends Canonical> = {
-	/** The unique identifier of the atom family */
-	key: string
-	/** Discriminator */
-	type: `atom_family`
-	/** Never present. This is a marker that preserves the type of atoms in this family */
-	__T?: T
-	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
-	__K?: K
+/**
+ * Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.
+ * @param options - {@link RegularAtomFamilyOptions}
+ * @returns
+ * A reference to the atom family created: a {@link RegularAtomFamilyToken}
+ */
+export function atomFamily<T, K extends Canonical>(
+	options: RegularAtomFamilyOptions<T, K>,
+): RegularAtomFamilyToken<T, K> {
+	return createRegularAtomFamily(IMPLICIT.STORE, options)
 }
 
-/** @public */
-// biome-ignore format: intersection
 export type MutableAtomFamilyOptions<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
-> =
-	& JsonInterface<T, J>
-	& {
-		/** Used to signal that the atoms created from this family are mutable */
-		mutable: true
-		/** The unique identifier of the atom family */
-		key: string
-		/** A function to create an initial value for each atom in the family */
-		default: (key: K) => T
-		/** Hooks used to run side effects when an atom in the family is set  */
-		effects?: (key: K) => AtomEffect<T>[]
-	}
-
-export type MutableAtomFamilyToken<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 > = {
 	/** The unique identifier of the atom family */
 	key: string
-	/** Discriminator */
-	type: `mutable_atom_family`
-	/** Never present. This is a marker that preserves the type of atoms in this family */
-	__T?: T
-	/** Never present. This is a marker that preserves the type of the JSON form of atoms in this family */
-	__J?: J
-	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
-	__K?: K
+	/** The class of the transceiver to be created */
+	class: ConstructorOf<T>
+	/** Hooks used to run side effects when an atom in the family is set  */
+	effects?: (key: K) => AtomEffect<T>[]
 }
-export type AtomFamilyToken<T, K extends Canonical = Canonical> =
-	| MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K>
-	| RegularAtomFamilyToken<T, K>
-
 /**
- * @public
  * Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
  *
  * The value of a mutable atom must be some kind of {@link Transceiver}.
@@ -158,28 +117,10 @@ export type AtomFamilyToken<T, K extends Canonical = Canonical> =
  * @param options - {@link MutableAtomFamilyOptions}
  * @returns
  * A reference to the atom family created: a {@link MutableAtomFamilyToken}
- * @overload Mutable
  */
-export function atomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+export function mutableAtomFamily<
+	T extends Transceiver<any, any>,
 	K extends Canonical,
->(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>
-/**
- * @public
- * Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.
- * @param options - {@link RegularAtomFamilyOptions}
- * @returns
- * A reference to the atom family created: a {@link RegularAtomFamilyToken}
- * @overload Regular
- */
-export function atomFamily<T, K extends Canonical>(
-	options: RegularAtomFamilyOptions<T, K>,
-): RegularAtomFamilyToken<T, K>
-export function atomFamily<T, K extends Canonical>(
-	options:
-		| MutableAtomFamilyOptions<any, any, any>
-		| RegularAtomFamilyOptions<T, K>,
-): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
-	return createAtomFamily(IMPLICIT.STORE, options)
+>(options: MutableAtomFamilyOptions<T, K>): MutableAtomFamilyToken<T, K> {
+	return createMutableAtomFamily(IMPLICIT.STORE, options)
 }

package/src/main/dispose-state.ts

@@ -4,7 +4,6 @@ import type { Canonical } from "atom.io/json"
 import type { ReadableFamilyToken, ReadableToken } from "."
 
 /**
- * @public
  * Disposes of a state in the implicit store.
  *
  * Only family members can be disposed of.
@@ -14,7 +13,6 @@ import type { ReadableFamilyToken, ReadableToken } from "."
  */
 export function disposeState(token: ReadableToken<any>): void
 /**
- * @public
  * Disposes of a state in the implicit store.
  *
  * Only family members can be disposed of.
@@ -27,13 +25,13 @@ export function disposeState<K extends Canonical>(
 	key: K,
 ): void
 export function disposeState(
-	...[token, key]:
+	...params:
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): void {
-	if (key) {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any, key)
+	if (params.length === 2) {
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, ...params)
 	} else {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any)
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, ...params)
 	}
 }

package/src/main/find-state.ts

@@ -1,11 +1,9 @@
 import type {
-	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
-	RegularAtomFamilyToken,
 	RegularAtomToken,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
@@ -14,10 +12,11 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore, IMPLICIT } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
+
+import type { MutableAtomFamilyToken, RegularAtomFamilyToken } from "./tokens"
 
 /**
- * @public
  * Finds a {@link MutableAtomToken} in the store, without accessing its value.
  *
  * In an ephemeral store, this will create a new atom if one does not exist with the given key.
@@ -31,13 +30,11 @@ import type { Canonical, Json } from "atom.io/json"
  * @overload Mutable Atom
  */
 export function findState<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
->(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>
+>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, K>
 /**
- * @public
  * Finds a {@link RegularAtomToken} in the store, without accessing its value.
  *
  * In an ephemeral store, this will create a new atom if one does not exist with the given key.
@@ -55,7 +52,6 @@ export function findState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): RegularAtomToken<T, K>
 /**
- * @public
  * Finds a {@link WritableSelectorToken} in the store, without accessing its value.
  *
  * In an ephemeral store, this will create a new selector if one does not exist with the given key.
@@ -73,7 +69,6 @@ export function findState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): WritableSelectorToken<T, K>
 /**
- * @public
  * Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
  *
  * In an ephemeral store, this will create a new selector if one does not exist with the given key.
@@ -91,7 +86,6 @@ export function findState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ReadonlySelectorToken<T, K>
 /**
- * @public
  * Finds a {@link WritableToken} in the store, without accessing its value.
  *
  * In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
@@ -109,7 +103,6 @@ export function findState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): WritableToken<T, K>
 /**
- * @public
  * Finds a {@link MutableAtomToken} in the store, without accessing its value.
  *
  * In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
@@ -130,7 +123,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 
 export function findState(
 	token: ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
+	key: Canonical,
 ): ReadableToken<any> {
 	const state = findInStore(IMPLICIT.STORE, token, key)
 	return state

package/src/main/get-state.ts

@@ -4,7 +4,6 @@ import type { Canonical } from "atom.io/json"
 import type { ReadableFamilyToken, ReadableToken } from "."
 
 /**
- * @public
  * Read or compute the current value of a state
  * @param token - The token of the state to get
  * @return The current value of the state
@@ -14,7 +13,6 @@ import type { ReadableFamilyToken, ReadableToken } from "."
 export function getState<T>(token: ReadableToken<T>): T
 
 /**
- * @public
  * Read or compute the current value of a state
  * @param token - The token of a state family
  * @param key - The unique key of the state to get