atom.io 0.25.2 → 0.25.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -56,12 +56,12 @@
     "@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",
+    "@typescript-eslint/parser": "7.15.0",
+    "@typescript-eslint/rule-tester": "7.15.0",
     "@vitest/coverage-v8": "1.6.0",
     "@vitest/ui": "1.6.0",
     "concurrently": "8.2.2",
-    "drizzle-kit": "0.22.7",
+    "drizzle-kit": "0.22.8",
     "drizzle-orm": "0.31.2",
     "eslint": "npm:eslint@8.57.0",
     "eslint-v9": "npm:eslint@9.6.0",
@@ -70,7 +70,7 @@
     "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",
@@ -78,7 +78,7 @@
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.1.0",
-    "typescript": "5.5.2",
+    "typescript": "5.5.3",
     "vite": "5.3.2",
     "vite-tsconfig-paths": "4.3.2",
     "vitest": "1.6.0"

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),
 	)
 }