atom.io 0.40.1 → 0.40.3

package/src/react/parse-state-overloads.ts

@@ -8,21 +8,21 @@ import type { Store } from "atom.io/internal"
 import { findInStore } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
-export function parseStateOverloads<T, K extends Canonical>(
+export function parseStateOverloads<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	...rest: [WritableFamilyToken<T, K>, K] | [WritableToken<T>]
-): WritableToken<T>
+	...rest: [WritableFamilyToken<T, K, E>, Key] | [WritableToken<T, any, E>]
+): WritableToken<T, K, E>
 
-export function parseStateOverloads<T, K extends Canonical>(
+export function parseStateOverloads<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	...rest: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
-): ReadableToken<T>
+	...rest: [ReadableFamilyToken<T, K, E>, Key] | [ReadableToken<T, any, E>]
+): ReadableToken<T, K, E>
 
-export function parseStateOverloads<T, K extends Canonical>(
+export function parseStateOverloads<T, K extends Canonical, Key extends K, E>(
 	store: Store,
-	...rest: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
-): ReadableToken<T> {
-	let token: ReadableToken<any>
+	...rest: [ReadableFamilyToken<T, K, E>, Key] | [ReadableToken<T, any, E>]
+): ReadableToken<T, K, E> {
+	let token: ReadableToken<any, any, any>
 	if (rest.length === 2) {
 		const family = rest[0]
 		const key = rest[1]

package/src/react/use-i.ts

@@ -7,16 +7,16 @@ import { parseStateOverloads } from "./parse-state-overloads"
 import { StoreContext } from "./store-context"
 
 export function useI<T>(
-	token: WritableToken<T>,
+	token: WritableToken<T, any, any>,
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
-export function useI<T, K extends Canonical>(
-	token: WritableFamilyToken<T, K>,
-	key: K,
+export function useI<T, K extends Canonical, Key extends K>(
+	token: WritableFamilyToken<T, K, any>,
+	key: Key,
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
-export function useI<T, K extends Canonical>(
-	...params: [WritableFamilyToken<T, K>, K] | [WritableToken<T>]
+export function useI<T, K extends Canonical, Key extends K>(
+	...params: [WritableFamilyToken<T, K, any>, Key] | [WritableToken<T, any, any>]
 ): <New extends T>(next: New | ((old: T) => New)) => void {
 	const store = React.useContext(StoreContext)
 	const token = parseStateOverloads(store, ...params)

package/src/react/use-loadable.ts

@@ -4,32 +4,32 @@ import type { Canonical } from "atom.io/json"
 import { useO } from "atom.io/react"
 import React from "react"
 
-export function useLoadable<T>(
-	token: ReadableToken<Loadable<T>>,
-): `LOADING` | { loading: boolean; value: T }
+export function useLoadable<T, E>(
+	token: ReadableToken<Loadable<T>, any, E>,
+): `LOADING` | { loading: boolean; value: E | T }
 
-export function useLoadable<T, K extends Canonical>(
-	token: ReadableFamilyToken<Loadable<T>, K>,
+export function useLoadable<T, K extends Canonical, E>(
+	token: ReadableFamilyToken<Loadable<T>, K, E>,
 	key: K,
-): `LOADING` | { loading: boolean; value: T }
+): `LOADING` | { loading: boolean; value: E | T }
 
-export function useLoadable<T, F extends T>(
-	token: ReadableToken<Loadable<T>>,
+export function useLoadable<T, F extends T, E>(
+	token: ReadableToken<Loadable<T>, any, E>,
 	fallback: F,
 ): { loading: boolean; value: T }
 
-export function useLoadable<T, K extends Canonical, F extends T>(
-	token: ReadableFamilyToken<Loadable<T>, K>,
+export function useLoadable<T, K extends Canonical, F extends T, E>(
+	token: ReadableFamilyToken<Loadable<T>, K, E>,
 	key: K,
 	fallback: F,
-): { loading: boolean; value: T }
+): { loading: boolean; value: E | T }
 
 export function useLoadable(
 	...params:
-		| readonly [ReadableFamilyToken<any, Canonical>, Canonical, unknown]
-		| readonly [ReadableFamilyToken<any, Canonical>, Canonical]
-		| readonly [ReadableToken<any>, unknown]
-		| readonly [ReadableToken<any>]
+		| readonly [ReadableFamilyToken<any, Canonical, any>, Canonical, unknown]
+		| readonly [ReadableFamilyToken<any, Canonical, any>, Canonical]
+		| readonly [ReadableToken<any, any, any>, unknown]
+		| readonly [ReadableToken<any, any, any>]
 ): `LOADING` | { loading: boolean; value: unknown } {
 	let state: unknown
 	let fallback: unknown

package/src/react/use-o.ts

@@ -6,20 +6,20 @@ import * as React from "react"
 import { parseStateOverloads } from "./parse-state-overloads"
 import { StoreContext } from "./store-context"
 
-export function useO<T>(token: ReadableToken<T>): T
+export function useO<T, E>(token: ReadableToken<T, any, E>): E | T
 
-export function useO<T, K extends Canonical>(
-	token: ReadableFamilyToken<T, K>,
-	key: K,
-): T
+export function useO<T, K extends Canonical, Key extends K, E>(
+	token: ReadableFamilyToken<T, K, E>,
+	key: Key,
+): E | T
 
-export function useO<T, K extends Canonical>(
-	...params: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
-): T {
+export function useO<T, K extends Canonical, Key extends K, E>(
+	...params: [ReadableFamilyToken<T, K, E>, Key] | [ReadableToken<T, any, E>]
+): E | T {
 	const store = React.useContext(StoreContext)
 	const token = parseStateOverloads(store, ...params)
 	const id = React.useId()
-	return React.useSyncExternalStore<T>(
+	return React.useSyncExternalStore<E | T>(
 		(dispatch) => subscribeToState(store, token, `use-o:${id}`, dispatch),
 		() => getFromStore(store, token),
 		() => getFromStore(store, token),

package/src/react-devtools/StateEditor.tsx

@@ -5,7 +5,7 @@ import type { FC } from "react"
 import { JsonEditor } from "./json-editor"
 
 export const StateEditor: FC<{
-	token: WritableToken<unknown>
+	token: WritableToken<unknown, any, unknown>
 }> = ({ token }) => {
 	const set = useI(token)
 	const data = useO(token)
@@ -23,7 +23,7 @@ export const StateEditor: FC<{
 }
 
 export const ReadonlySelectorViewer: FC<{
-	token: ReadonlySelectorToken<unknown>
+	token: ReadonlySelectorToken<unknown, any, unknown>
 }> = ({ token }) => {
 	const data = useO(token)
 	const metaPath = token.family
@@ -41,7 +41,9 @@ export const ReadonlySelectorViewer: FC<{
 }
 
 export const StoreEditor: FC<{
-	token: ReadonlySelectorToken<unknown> | WritableToken<unknown>
+	token:
+		| ReadonlySelectorToken<unknown, any, unknown>
+		| WritableToken<unknown, any, unknown>
 }> = ({ token }) => {
 	switch (token.type) {
 		case `readonly_pure_selector`:

package/src/react-devtools/StateIndex.tsx

@@ -25,7 +25,7 @@ import { DevtoolsContext } from "./store"
 /* eslint-disable no-console */
 
 export const StateIndexLeafNode: FC<{
-	node: ReadableToken<unknown>
+	node: ReadableToken<unknown, any, unknown>
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlyPureSelectorToken<Loadable<string>>
 	dispose?: (() => void) | undefined
@@ -95,7 +95,7 @@ export const StateIndexLeafNode: FC<{
 	)
 }
 export const StateIndexTreeNode: FC<{
-	node: FamilyNode<ReadableToken<unknown>>
+	node: FamilyNode<ReadableToken<unknown, any, unknown>>
 	isOpenState: RegularAtomToken<boolean>
 }> = ({ node, isOpenState }) => {
 	const setIsOpen = useI(isOpenState)
@@ -147,7 +147,9 @@ export const StateIndexTreeNode: FC<{
 }
 
 export const StateIndexNode: FC<{
-	node: FamilyNode<ReadableToken<unknown>> | ReadableToken<unknown>
+	node:
+		| FamilyNode<ReadableToken<unknown, any, unknown>>
+		| ReadableToken<unknown, any, unknown>
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlyPureSelectorToken<Loadable<string>>
 	dispose?: () => void
@@ -169,7 +171,7 @@ export const StateIndexNode: FC<{
 }
 
 export const StateIndex: FC<{
-	tokenIndex: AtomToken<WritableTokenIndex<ReadableToken<unknown>>>
+	tokenIndex: AtomToken<WritableTokenIndex<ReadableToken<unknown, any, unknown>>>
 }> = ({ tokenIndex }) => {
 	const tokenIds = useO(tokenIndex)
 

package/src/react-devtools/Updates.tsx

@@ -13,7 +13,7 @@ import * as React from "react"
 
 const AtomUpdateFC: React.FC<{
 	serialNumber: number
-	atomUpdate: AtomUpdateEvent<AtomToken<unknown>>
+	atomUpdate: AtomUpdateEvent<AtomToken<unknown, any, any>>
 }> = ({ atomUpdate }) => {
 	return (
 		<article

package/src/react-devtools/store.ts

@@ -39,7 +39,7 @@ export function attachDevtoolsStates(
 ): DevtoolsStates & IntrospectionStates & { store: Store } {
 	const introspectionStates = attachIntrospectionStates(store)
 
-	const devtoolsAreHiddenAtom = createRegularAtom<boolean>(
+	const devtoolsAreHiddenAtom = createRegularAtom<boolean, never, never>(
 		store,
 		{
 			key: `🔍 Devtools Are Hidden`,
@@ -62,7 +62,7 @@ export function attachDevtoolsStates(
 		undefined,
 	)
 
-	const devtoolsAreOpenAtom = createRegularAtom<boolean>(
+	const devtoolsAreOpenAtom = createRegularAtom<boolean, never, never>(
 		store,
 		{
 			key: `🔍 Devtools Are Open`,
@@ -75,7 +75,11 @@ export function attachDevtoolsStates(
 		undefined,
 	)
 
-	const devtoolsViewSelectionAtom = createRegularAtom<DevtoolsView>(
+	const devtoolsViewSelectionAtom = createRegularAtom<
+		DevtoolsView,
+		never,
+		never
+	>(
 		store,
 		{
 			key: `🔍 Devtools View Selection`,
@@ -88,7 +92,11 @@ export function attachDevtoolsStates(
 		undefined,
 	)
 
-	const devtoolsViewOptionsAtom = createRegularAtom<DevtoolsView[]>(
+	const devtoolsViewOptionsAtom = createRegularAtom<
+		DevtoolsView[],
+		never,
+		never
+	>(
 		store,
 		{
 			key: `🔍 Devtools View Options`,
@@ -103,7 +111,8 @@ export function attachDevtoolsStates(
 
 	const viewIsOpenAtoms = createRegularAtomFamily<
 		boolean,
-		readonly (number | string)[]
+		readonly (number | string)[],
+		never
 	>(store, {
 		key: `🔍 Devtools View Is Open`,
 		default: false,
@@ -122,8 +131,8 @@ export function attachDevtoolsStates(
 		do: ({ get, set }, path, current) => {
 			const currentView = get(devtoolsViewSelectionAtom)
 			let states:
-				| WritableTokenIndex<AtomToken<unknown>>
-				| WritableTokenIndex<SelectorToken<unknown>>
+				| WritableTokenIndex<AtomToken<unknown, any, any>>
+				| WritableTokenIndex<SelectorToken<unknown, any, any>>
 			switch (currentView) {
 				case `atoms`:
 					states = get(introspectionStates.atomIndex)