atom.io 0.25.2 → 0.25.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.25.2",
+  "version": "0.25.4",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -49,43 +49,42 @@
   },
   "devDependencies": {
     "@testing-library/react": "16.0.0",
-    "@types/eslint": "npm:@types/eslint@8.56.10",
-    "@types/eslint-v9": "npm:@types/eslint@8.56.10",
+    "@types/eslint": "npm:@types/eslint@9.6.0",
+    "@types/eslint-v9": "npm:@types/eslint@9.6.0",
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.14",
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.3",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "7.14.1",
-    "@typescript-eslint/rule-tester": "7.14.1",
-    "@vitest/coverage-v8": "1.6.0",
-    "@vitest/ui": "1.6.0",
+    "@typescript-eslint/parser": "7.17.0",
+    "@typescript-eslint/rule-tester": "7.17.0",
+    "@vitest/coverage-v8": "2.0.4",
+    "@vitest/ui": "2.0.4",
     "concurrently": "8.2.2",
-    "drizzle-kit": "0.22.7",
-    "drizzle-orm": "0.31.2",
+    "drizzle-kit": "0.23.0",
+    "drizzle-orm": "0.32.0",
     "eslint": "npm:eslint@8.57.0",
-    "eslint-v9": "npm:eslint@9.6.0",
-    "framer-motion": "11.2.12",
+    "eslint-v9": "npm:eslint@9.7.0",
+    "framer-motion": "11.3.8",
     "happy-dom": "14.12.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.22.0",
+    "preact": "10.22.1",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.24.0",
+    "react-router-dom": "6.25.1",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
-    "tsup": "8.1.0",
-    "typescript": "5.5.2",
-    "vite": "5.3.2",
+    "tsup": "8.2.2",
+    "typescript": "5.5.3",
+    "vite": "5.3.4",
     "vite-tsconfig-paths": "4.3.2",
-    "vitest": "1.6.0"
+    "vitest": "2.0.4"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "module": "dist/index.mjs",
   "files": [
     "dist",
     "src",
@@ -252,7 +251,7 @@
   "scripts": {
     "manifest": "tsx __scripts__/manifest-build.node.ts",
     "clean:build": "find . -type d -name 'dist' -not -path '*/node_modules/*' | xargs rm -rf",
-    "build": "bun run clean:build && concurrently \"npm:build:*\"",
+    "build": "bun run clean:build && concurrently \"bun:build:*\"",
     "build:main": "tsup",
     "build:types": "tsup --dts",
     "build:data": "cd data && tsup",

package/react/dist/index.cjs

@@ -28,28 +28,46 @@ var React5__namespace = /*#__PURE__*/_interopNamespace(React5);
 // react/src/store-context.tsx
 var StoreContext = React5__namespace.createContext(internal.IMPLICIT.STORE);
 var StoreProvider = ({ children, store = internal.IMPLICIT.STORE }) => /* @__PURE__ */ jsxRuntime.jsx(StoreContext.Provider, { value: store, children });
-function useI(token, key) {
+function parseStateOverloads(store, ...rest) {
+  let token;
+  if (rest.length === 2) {
+    const family = rest[0];
+    const key = rest[1];
+    if (store.config.lifespan === `immortal`) {
+      const maybeToken = internal.seekInStore(family, key, store);
+      if (!maybeToken) {
+        throw new internal.NotFoundError(family, key, store);
+      }
+      token = maybeToken;
+    } else {
+      token = internal.findInStore(family, key, store);
+    }
+  } else {
+    token = rest[0];
+  }
+  return token;
+}
+
+// react/src/use-i.ts
+function useI(...params) {
   const store = React5__namespace.useContext(StoreContext);
-  const stateToken = token.type === `atom_family` || token.type === `mutable_atom_family` || token.type === `selector_family` ? internal.findInStore(token, key, store) : token;
+  const token = parseStateOverloads(store, ...params);
   const setter = React5__namespace.useRef(null);
   if (setter.current === null) {
     setter.current = (next) => {
-      internal.setIntoStore(stateToken, next, store);
+      internal.setIntoStore(token, next, store);
     };
   }
   return setter.current;
 }
-function useO(token, key) {
+function useO(...params) {
   const store = React5__namespace.useContext(StoreContext);
-  const stateToken = token.type === `atom_family` || token.type === `mutable_atom_family` || token.type === `selector_family` || token.type === `readonly_selector_family` ? internal.seekInStore(token, key, store) : token;
-  if (!stateToken) {
-    throw new internal.NotFoundError(token, store);
-  }
+  const token = parseStateOverloads(store, ...params);
   const id = React5__namespace.useId();
   return React5__namespace.useSyncExternalStore(
-    (dispatch) => internal.subscribeToState(stateToken, dispatch, `use-o:${id}`, store),
-    () => internal.getFromStore(stateToken, store),
-    () => internal.getFromStore(stateToken, store)
+    (dispatch) => internal.subscribeToState(token, dispatch, `use-o:${id}`, store),
+    () => internal.getFromStore(token, store),
+    () => internal.getFromStore(token, store)
   );
 }
 

package/react/dist/index.js

@@ -1,33 +1,51 @@
 import '../../dist/chunk-S4N6XNPH.js';
-import { IMPLICIT, findInStore, setIntoStore, seekInStore, NotFoundError, subscribeToState, getFromStore, getJsonToken, withdraw, subscribeToTimeline } from 'atom.io/internal';
+import { IMPLICIT, setIntoStore, subscribeToState, getFromStore, findInStore, getJsonToken, withdraw, subscribeToTimeline, seekInStore, NotFoundError } from 'atom.io/internal';
 import * as React5 from 'react';
 import { jsx } from 'react/jsx-runtime';
 import { undo, redo } from 'atom.io';
 
 var StoreContext = React5.createContext(IMPLICIT.STORE);
 var StoreProvider = ({ children, store = IMPLICIT.STORE }) => /* @__PURE__ */ jsx(StoreContext.Provider, { value: store, children });
-function useI(token, key) {
+function parseStateOverloads(store, ...rest) {
+  let token;
+  if (rest.length === 2) {
+    const family = rest[0];
+    const key = rest[1];
+    if (store.config.lifespan === `immortal`) {
+      const maybeToken = seekInStore(family, key, store);
+      if (!maybeToken) {
+        throw new NotFoundError(family, key, store);
+      }
+      token = maybeToken;
+    } else {
+      token = findInStore(family, key, store);
+    }
+  } else {
+    token = rest[0];
+  }
+  return token;
+}
+
+// react/src/use-i.ts
+function useI(...params) {
   const store = React5.useContext(StoreContext);
-  const stateToken = token.type === `atom_family` || token.type === `mutable_atom_family` || token.type === `selector_family` ? findInStore(token, key, store) : token;
+  const token = parseStateOverloads(store, ...params);
   const setter = React5.useRef(null);
   if (setter.current === null) {
     setter.current = (next) => {
-      setIntoStore(stateToken, next, store);
+      setIntoStore(token, next, store);
     };
   }
   return setter.current;
 }
-function useO(token, key) {
+function useO(...params) {
   const store = React5.useContext(StoreContext);
-  const stateToken = token.type === `atom_family` || token.type === `mutable_atom_family` || token.type === `selector_family` || token.type === `readonly_selector_family` ? seekInStore(token, key, store) : token;
-  if (!stateToken) {
-    throw new NotFoundError(token, store);
-  }
+  const token = parseStateOverloads(store, ...params);
   const id = React5.useId();
   return React5.useSyncExternalStore(
-    (dispatch) => subscribeToState(stateToken, dispatch, `use-o:${id}`, store),
-    () => getFromStore(stateToken, store),
-    () => getFromStore(stateToken, store)
+    (dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
+    () => getFromStore(token, store),
+    () => getFromStore(token, store)
   );
 }
 

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

@@ -0,0 +1,43 @@
+import type {
+	ReadableFamilyToken,
+	ReadableToken,
+	WritableFamilyToken,
+	WritableToken,
+} from "atom.io"
+import type { Store } from "atom.io/internal"
+import { findInStore, NotFoundError, seekInStore } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+export function parseStateOverloads<T, K extends Json.Serializable>(
+	store: Store,
+	...rest: [WritableFamilyToken<T, K>, K] | [WritableToken<T>]
+): WritableToken<T>
+
+export function parseStateOverloads<T, K extends Json.Serializable>(
+	store: Store,
+	...rest: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
+): ReadableToken<T>
+
+export function parseStateOverloads<T, K extends Json.Serializable>(
+	store: Store,
+	...rest: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
+): ReadableToken<T> {
+	let token: ReadableToken<any>
+	if (rest.length === 2) {
+		const family = rest[0]
+		const key = rest[1]
+
+		if (store.config.lifespan === `immortal`) {
+			const maybeToken = seekInStore(family, key, store)
+			if (!maybeToken) {
+				throw new NotFoundError(family, key, store)
+			}
+			token = maybeToken
+		} else {
+			token = findInStore(family, key, store)
+		}
+	} else {
+		token = rest[0]
+	}
+	return token
+}

package/react/src/use-i.ts

@@ -1,8 +1,9 @@
-import type { ReadableToken, WritableFamilyToken, WritableToken } from "atom.io"
-import { findInStore, setIntoStore } from "atom.io/internal"
+import type { WritableFamilyToken, WritableToken } from "atom.io"
+import { setIntoStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import * as React from "react"
 
+import { parseStateOverloads } from "./parse-state-overloads"
 import { StoreContext } from "./store-context"
 
 export function useI<T>(
@@ -15,22 +16,16 @@ export function useI<T, K extends Json.Serializable>(
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
 export function useI<T, K extends Json.Serializable>(
-	token: WritableFamilyToken<T, K> | WritableToken<T>,
-	key?: K,
+	...params: [WritableFamilyToken<T, K>, K] | [WritableToken<T>]
 ): <New extends T>(next: New | ((old: T) => New)) => void {
 	const store = React.useContext(StoreContext)
-	const stateToken: ReadableToken<any> =
-		token.type === `atom_family` ||
-		token.type === `mutable_atom_family` ||
-		token.type === `selector_family`
-			? findInStore(token, key as K, store)
-			: token
+	const token = parseStateOverloads(store, ...params)
 	const setter: React.MutableRefObject<
 		(<New extends T>(next: New | ((old: T) => New)) => void) | null
 	> = React.useRef(null)
 	if (setter.current === null) {
 		setter.current = (next) => {
-			setIntoStore(stateToken, next, store)
+			setIntoStore(token, next, store)
 		}
 	}
 	return setter.current

package/react/src/use-o.ts

@@ -1,13 +1,9 @@
 import type { ReadableFamilyToken, ReadableToken } from "atom.io"
-import {
-	getFromStore,
-	NotFoundError,
-	seekInStore,
-	subscribeToState,
-} from "atom.io/internal"
+import { getFromStore, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import * as React from "react"
 
+import { parseStateOverloads } from "./parse-state-overloads"
 import { StoreContext } from "./store-context"
 
 export function useO<T>(token: ReadableToken<T>): T
@@ -18,24 +14,14 @@ export function useO<T, K extends Json.Serializable>(
 ): T
 
 export function useO<T, K extends Json.Serializable>(
-	token: ReadableFamilyToken<T, K> | ReadableToken<T>,
-	key?: K,
+	...params: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
 ): T {
 	const store = React.useContext(StoreContext)
-	const stateToken: ReadableToken<any> | undefined =
-		token.type === `atom_family` ||
-		token.type === `mutable_atom_family` ||
-		token.type === `selector_family` ||
-		token.type === `readonly_selector_family`
-			? seekInStore(token, key as K, store)
-			: token
-	if (!stateToken) {
-		throw new NotFoundError(token, store)
-	}
+	const token = parseStateOverloads(store, ...params)
 	const id = React.useId()
 	return React.useSyncExternalStore<T>(
-		(dispatch) => subscribeToState(stateToken, dispatch, `use-o:${id}`, store),
-		() => getFromStore(stateToken, store),
-		() => getFromStore(stateToken, store),
+		(dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
+		() => getFromStore(token, store),
+		() => getFromStore(token, store),
 	)
 }

package/react-devtools/dist/index.d.ts

@@ -61,8 +61,8 @@ declare const AtomIODevtools: () => JSX.Element;
 
 declare const atomIndex: atom_io.ReadonlySelectorToken<AtomTokenIndex>;
 declare const selectorIndex: atom_io.ReadonlySelectorToken<SelectorTokenIndex>;
-declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<atom_io.Func>[]>;
-declare const findTransactionLogState: atom_io.ReadonlySelectorFamilyToken<atom_io.TransactionUpdate<atom_io.Func>[], string>;
+declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<Internal.Func>[]>;
+declare const findTransactionLogState: atom_io.ReadonlySelectorFamilyToken<atom_io.TransactionUpdate<Internal.Func>[], string>;
 declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken<any>[]>;
 declare const findTimelineState: atom_io.ReadonlySelectorFamilyToken<Internal.Timeline<any>, string>;
 declare const devtoolsAreOpenState: atom_io.RegularAtomToken<boolean>;

package/react-devtools/src/TransactionIndex.tsx

@@ -1,11 +1,11 @@
 import type {
-	Func,
 	ReadonlySelectorToken,
 	RegularAtomToken,
 	TransactionToken,
 	TransactionUpdate,
 } from "atom.io"
 import { findState } from "atom.io/ephemeral"
+import type { Func } from "atom.io/internal"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
 

package/react-devtools/src/Updates.tsx

@@ -1,9 +1,9 @@
 import type {
-	Func,
 	KeyedStateUpdate,
 	TimelineUpdate,
 	TransactionUpdate,
 } from "atom.io"
+import type { Func } from "atom.io/internal"
 import * as React from "react"
 
 import { discoverType } from "~/packages/anvl/src/refinement/refinery"

package/realtime-client/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as AtomIO from 'atom.io';
 import * as Internal from 'atom.io/internal';
-import { Store, Transceiver } from 'atom.io/internal';
+import { Store, Transceiver, Func } from 'atom.io/internal';
 import { Json } from 'atom.io/json';
 import { Socket } from 'socket.io-client';
 import { ContinuityToken } from 'atom.io/realtime';
@@ -26,8 +26,8 @@ declare const myUsernameState: AtomIO.RegularAtomToken<string | null>;
 declare const optimisticUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 declare const confirmedUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 
-declare function serverAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>, socket: Socket, store: Internal.Store): () => void;
+declare function serverAction<F extends Internal.Func>(token: AtomIO.TransactionToken<F>, socket: Socket, store: Internal.Store): () => void;
 
-declare function syncContinuity<F extends AtomIO.Func>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
+declare function syncContinuity<F extends Func>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
 
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity };

package/realtime-client/src/server-action.ts

@@ -2,7 +2,7 @@ import type * as AtomIO from "atom.io"
 import * as Internal from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-export function serverAction<F extends AtomIO.Func>(
+export function serverAction<F extends Internal.Func>(
 	token: AtomIO.TransactionToken<F>,
 	socket: Socket,
 	store: Internal.Store,

package/realtime-client/src/sync-continuity.ts

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { Func, Store } from "atom.io/internal"
 import {
 	actUponStore,
 	assignTransactionToContinuity,
@@ -21,7 +21,7 @@ import {
 } from "atom.io/realtime-client"
 import type { Socket } from "socket.io-client"
 
-export function syncContinuity<F extends AtomIO.Func>(
+export function syncContinuity<F extends Func>(
 	continuity: ContinuityToken,
 	socket: Socket,
 	store: Store,

package/realtime-react/dist/index.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 import { Socket } from 'socket.io-client';
 import * as AtomIO from 'atom.io';
 import { Json } from 'atom.io/json';
-import { Transceiver } from 'atom.io/internal';
+import { Transceiver, Func } from 'atom.io/internal';
 import { ContinuityToken } from 'atom.io/realtime';
 
 type RealtimeReactStore = {
@@ -32,7 +32,7 @@ declare function usePullSelectorFamilyMember<T, K extends Json.Serializable, Key
 
 declare function usePush<J extends Json.Serializable>(token: AtomIO.WritableToken<J>): <New extends J>(next: New | ((old: J) => New)) => void;
 
-declare function useServerAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function useServerAction<F extends Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
 
 declare function useSyncContinuity(token: ContinuityToken): void;
 

package/realtime-react/src/use-server-action.ts

@@ -1,4 +1,5 @@
 import type * as AtomIO from "atom.io"
+import type { Func } from "atom.io/internal"
 import { actUponStore, arbitrary } from "atom.io/internal"
 import { StoreContext } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
@@ -6,7 +7,7 @@ import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function useServerAction<F extends AtomIO.Func>(
+export function useServerAction<F extends Func>(
 	token: AtomIO.TransactionToken<F>,
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	const store = React.useContext(StoreContext)

package/src/atom.ts

@@ -35,10 +35,27 @@ export type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serial
 			mutable: true
 		}
 
+/**
+ * @public
+ * Declare a mutable global reactive variable.
+ * @param options - Configuration for this mutable atom.
+ * @returns
+ * The token for your mutable atom.
+ * @overload Mutable
+ */
 export function atom<T extends Transceiver<any>, J extends Json.Serializable>(
 	options: MutableAtomOptions<T, J>,
 ): MutableAtomToken<T, J>
+/**
+ * @public
+ * Declare a regular global reactive variable.
+ * @param options - Configuration for this regular atom.
+ * @returns
+ * The token for your regular atom.
+ * @overload Regular
+ */
 export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
+
 export function atom(
 	options: MutableAtomOptions<any, any> | RegularAtomOptions<any>,
 ): AtomToken<any> {

package/src/index.ts

@@ -22,12 +22,6 @@ export * from "./timeline"
 export * from "./transaction"
 export * from "./validators"
 
-export type Func = (...parameters: any[]) => any
-
-export type Flat<R extends { [K in PropertyKey]: any }> = {
-	[K in keyof R]: R[K]
-}
-
 export type RegularAtomToken<T> = {
 	key: string
 	type: `atom`

package/src/molecule.ts

@@ -1,6 +1,5 @@
 import type {
 	ActorToolkit,
-	Flat,
 	MoleculeCreation,
 	MoleculeDisposal,
 	MutableAtomFamilyToken,
@@ -17,7 +16,7 @@ import type {
 	WritableToken,
 } from "atom.io"
 import type { JoinToken } from "atom.io/data"
-import type { Store, Subject, Transceiver } from "atom.io/internal"
+import type { Flat, Store, Subject, Transceiver } from "atom.io/internal"
 import {
 	createMoleculeFamily,
 	IMPLICIT,
@@ -92,7 +91,7 @@ export type MoleculeFamily<M extends MoleculeConstructor> = Flat<
 	}
 >
 export type MoleculeToken<M extends MoleculeConstructor> = {
-	key: MK<M>
+	key: MoleculeKey<M>
 	type: `molecule`
 	family?: MoleculeFamilyToken<M>
 	__M?: M
@@ -120,7 +119,6 @@ export type MoleculeType<T extends MoleculeFamilyToken<any>> =
 			? M
 			: never
 export type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`]
-export type MK<M extends MoleculeConstructor> = MoleculeKey<M>
 
 export function makeRootMolecule(
 	key: string,

package/src/set-state.ts

@@ -3,11 +3,27 @@ import type { Json } from "rel8"
 
 import type { WritableFamilyToken, WritableToken } from "."
 
+/**
+ * @public
+ * Set the value of a state into the implicit store.
+ * @param token - The unique identifier of the state to set.
+ * @param value - The new value of the state.
+ * @overload Default
+ * @default
+ */
 export function setState<T, New extends T>(
 	token: WritableToken<T>,
 	value: New | ((oldValue: T) => New),
 ): void
 
+/**
+ * @public
+ * Set the value of a state into the implicit store.
+ * @param token - The unique identifier of a state family.
+ * @param key - The key of the state to set.
+ * @param value - The new value of the state.
+ * @overload Streamlined
+ */
 export function setState<T, K extends Json.Serializable, New extends T>(
 	token: WritableFamilyToken<T, K>,
 	key: K,

package/src/subscribe.ts

@@ -1,4 +1,4 @@
-import type { Store } from "atom.io/internal"
+import type { Flat, Func, Store } from "atom.io/internal"
 import {
 	arbitrary,
 	IMPLICIT,
@@ -9,8 +9,6 @@ import {
 
 import type {
 	FamilyMetadata,
-	Flat,
-	Func,
 	ReadableToken,
 	TimelineManageable,
 	TimelineToken,

package/src/transaction.ts

@@ -9,7 +9,7 @@ import type {
 } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
 import type { seekState } from "atom.io/immortal"
-import type { EnvironmentData, Transceiver } from "atom.io/internal"
+import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
@@ -20,11 +20,9 @@ import type { Json } from "atom.io/json"
 
 import type {
 	disposeState,
-	Func,
 	KeyedStateUpdate,
 	MutableAtomToken,
 	ReadableToken,
-	ReadonlySelectorToken,
 	TokenType,
 	WritableSelectorToken,
 	WritableToken,