atom.io 0.25.1 → 0.25.3

package/internal/dist/index.cjs

@@ -849,15 +849,19 @@ var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
 
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, covered, store) => ({
-  get: (dependency, key) => {
+  get: (...params) => {
     const target = newest(store);
-    if (key) {
-      switch (dependency.type) {
+    let dependency;
+    if (params.length === 2) {
+      const [family, key] = params;
+      switch (family.type) {
         case `molecule_family`:
-          return getFromStore(dependency, key, store);
-        case `atom_family`:
-          dependency = seekInStore(dependency, key, store);
+          return getFromStore(family, key, store);
+        default:
+          dependency = seekInStore(family, key, store);
       }
+    } else {
+      [dependency] = params;
     }
     if (dependency.type === `molecule`) {
       return getFromStore(dependency, store);

package/internal/dist/index.js

@@ -574,15 +574,19 @@ var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
 
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, covered, store) => ({
-  get: (dependency, key) => {
+  get: (...params) => {
     const target = newest(store);
-    if (key) {
-      switch (dependency.type) {
+    let dependency;
+    if (params.length === 2) {
+      const [family, key] = params;
+      switch (family.type) {
         case `molecule_family`:
-          return getFromStore(dependency, key, store);
-        case `atom_family`:
-          dependency = seekInStore(dependency, key, store);
+          return getFromStore(family, key, store);
+        default:
+          dependency = seekInStore(family, key, store);
       }
+    } else {
+      [dependency] = params;
     }
     if (dependency.type === `molecule`) {
       return getFromStore(dependency, store);

package/internal/src/selector/register-selector.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableToken,
 	setState,
 	SetterToolkit,
-	WritableSelectorFamilyToken,
+	WritableFamilyToken,
 	WritableToken,
 } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
@@ -30,29 +30,32 @@ export const registerSelector = (
 	store: Store,
 ): SetterToolkit => ({
 	get: (
-		dependency:
-			| MoleculeFamilyToken<any>
-			| MoleculeToken<MoleculeConstructor>
-			| ReadableFamilyToken<any, any>
-			| ReadableToken<any>,
-		key?: Json.Serializable,
+		...params:
+			| [MoleculeFamilyToken<any>, Json.Serializable]
+			| [MoleculeToken<MoleculeConstructor>]
+			| [ReadableFamilyToken<any, any>, Json.Serializable]
+			| [ReadableToken<any>]
 	) => {
 		const target = newest(store)
+		let dependency: MoleculeToken<MoleculeConstructor> | ReadableToken<any>
 
-		if (key) {
-			switch (dependency.type) {
+		if (params.length === 2) {
+			const [family, key] = params
+			switch (family.type) {
 				case `molecule_family`:
-					return getFromStore(dependency, key, store)
-				case `atom_family`:
-					dependency = seekInStore(dependency, key, store) as any
+					return getFromStore(family, key, store)
+				default:
+					dependency = seekInStore(family, key, store) as any
 			}
+		} else {
+			;[dependency] = params
 		}
 
 		if (dependency.type === `molecule`) {
 			return getFromStore(dependency, store)
 		}
 
-		const dependencyState = withdraw(dependency as ReadableToken<any>, store)
+		const dependencyState = withdraw(dependency, store)
 		const dependencyValue = readOrComputeValue(dependencyState, store)
 
 		store.logger.info(
@@ -79,7 +82,7 @@ export const registerSelector = (
 	set: (<T, New extends T>(
 		...params:
 			| [
-					token: WritableSelectorFamilyToken<T, any>,
+					token: WritableFamilyToken<T, any>,
 					key: Json.Serializable,
 					value: New | ((oldValue: any) => New),
 			  ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.25.1",
+  "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),
 	)
 }