atom.io 0.24.7 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.24.7",
+  "version": "0.25.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -64,8 +64,8 @@
     "drizzle-kit": "0.22.7",
     "drizzle-orm": "0.31.2",
     "eslint": "npm:eslint@8.57.0",
-    "eslint-v9": "npm:eslint@9.5.0",
-    "framer-motion": "11.2.11",
+    "eslint-v9": "npm:eslint@9.6.0",
+    "framer-motion": "11.2.12",
     "happy-dom": "14.12.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
@@ -79,7 +79,7 @@
     "tmp": "0.2.3",
     "tsup": "8.1.0",
     "typescript": "5.5.2",
-    "vite": "5.3.1",
+    "vite": "5.3.2",
     "vite-tsconfig-paths": "4.3.2",
     "vitest": "1.6.0"
   },
@@ -250,7 +250,7 @@
     }
   },
   "scripts": {
-    "manifest": "tsx __scripts__/manifest-build.node",
+    "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:main": "tsup",
@@ -279,7 +279,7 @@
     "test:coverage": "vitest run --coverage",
     "test:once": "bun run test:manifest && cross-env IMPORT=dist vitest run",
     "test:once:public": "cross-env IMPORT=dist vitest run public",
-    "test:manifest": "tsx __scripts__/manifest-test.node",
+    "test:manifest": "tsx __scripts__/manifest-test.node.ts",
     "test:semver": "bun ../break-check/src/break-check.x.ts --verbose"
   }
 }

package/react/dist/index.cjs

@@ -41,7 +41,10 @@ function useI(token, key) {
 }
 function useO(token, key) {
   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.findInStore(token, key, store) : token;
+  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 id = React5__namespace.useId();
   return React5__namespace.useSyncExternalStore(
     (dispatch) => internal.subscribeToState(stateToken, dispatch, `use-o:${id}`, store),

package/react/dist/index.js

@@ -1,5 +1,5 @@
 import '../../dist/chunk-S4N6XNPH.js';
-import { IMPLICIT, findInStore, setIntoStore, subscribeToState, getFromStore, getJsonToken, withdraw, subscribeToTimeline } from 'atom.io/internal';
+import { IMPLICIT, findInStore, setIntoStore, seekInStore, NotFoundError, subscribeToState, getFromStore, getJsonToken, withdraw, subscribeToTimeline } from 'atom.io/internal';
 import * as React5 from 'react';
 import { jsx } from 'react/jsx-runtime';
 import { undo, redo } from 'atom.io';
@@ -19,7 +19,10 @@ function useI(token, key) {
 }
 function useO(token, key) {
   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` ? findInStore(token, key, store) : token;
+  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 id = React5.useId();
   return React5.useSyncExternalStore(
     (dispatch) => subscribeToState(stateToken, dispatch, `use-o:${id}`, store),

package/react/src/use-o.ts

@@ -1,5 +1,10 @@
 import type { ReadableFamilyToken, ReadableToken } from "atom.io"
-import { findInStore, getFromStore, subscribeToState } from "atom.io/internal"
+import {
+	getFromStore,
+	NotFoundError,
+	seekInStore,
+	subscribeToState,
+} from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import * as React from "react"
 
@@ -17,13 +22,16 @@ export function useO<T, K extends Json.Serializable>(
 	key?: K,
 ): T {
 	const store = React.useContext(StoreContext)
-	const stateToken: ReadableToken<any> =
+	const stateToken: ReadableToken<any> | undefined =
 		token.type === `atom_family` ||
 		token.type === `mutable_atom_family` ||
 		token.type === `selector_family` ||
 		token.type === `readonly_selector_family`
-			? findInStore(token, key as K, store)
+			? seekInStore(token, key as K, store)
 			: token
+	if (!stateToken) {
+		throw new NotFoundError(token, store)
+	}
 	const id = React.useId()
 	return React.useSyncExternalStore<T>(
 		(dispatch) => subscribeToState(stateToken, dispatch, `use-o:${id}`, store),

package/realtime/dist/index.cjs

@@ -24,7 +24,6 @@ var InvariantMap = class extends Map {
 var _SyncGroup = class _SyncGroup {
   constructor(key) {
     this.key = key;
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     this.type = `continuity`;
     this.globals = [];
     this.actions = [];

package/realtime/dist/index.js

@@ -22,7 +22,6 @@ var InvariantMap = class extends Map {
 var _SyncGroup = class _SyncGroup {
   constructor(key) {
     this.key = key;
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     this.type = `continuity`;
     this.globals = [];
     this.actions = [];

package/realtime/src/realtime-continuity.ts

@@ -51,7 +51,6 @@ export type ContinuityToken = {
 }
 
 export class SyncGroup {
-	// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 	protected type = `continuity` as const
 
 	protected globals: AtomToken<any>[] = []

package/realtime-server/dist/index.cjs

@@ -410,41 +410,41 @@ var createRoomTX = AtomIO__namespace.transaction({
 });
 var joinRoomTX = AtomIO__namespace.transaction({
   key: `joinRoom`,
-  do: (transactors, roomId, userId, enteredAtEpoch) => {
+  do: (tools, roomId, userId, enteredAtEpoch) => {
     const meta = { enteredAtEpoch };
     data.editRelationsInStore(
       realtime.usersInRooms,
       (relations) => {
         relations.set({ room: roomId, user: userId }, meta);
       },
-      transactors.env().store
+      tools.env().store
     );
     return meta;
   }
 });
 var leaveRoomTX = AtomIO__namespace.transaction({
   key: `leaveRoom`,
-  do: (transactors, roomId, userId) => {
+  do: (tools, roomId, userId) => {
     data.editRelationsInStore(
       realtime.usersInRooms,
       (relations) => {
         relations.delete({ room: roomId, user: userId });
       },
-      transactors.env().store
+      tools.env().store
     );
   }
 });
 var destroyRoomTX = AtomIO__namespace.transaction({
   key: `destroyRoom`,
-  do: (transactors, roomId) => {
+  do: (tools, roomId) => {
     data.editRelationsInStore(
       realtime.usersInRooms,
       (relations) => {
         relations.delete({ room: roomId });
       },
-      transactors.env().store
+      tools.env().store
     );
-    transactors.set(realtime.roomIndex, (s) => (s.delete(roomId), s));
+    tools.set(realtime.roomIndex, (s) => (s.delete(roomId), s));
   }
 });
 function redactTransactionUpdateContent(visibleStateKeys, updates) {

package/realtime-server/dist/index.js

@@ -370,41 +370,41 @@ var createRoomTX = AtomIO.transaction({
 });
 var joinRoomTX = AtomIO.transaction({
   key: `joinRoom`,
-  do: (transactors, roomId, userId, enteredAtEpoch) => {
+  do: (tools, roomId, userId, enteredAtEpoch) => {
     const meta = { enteredAtEpoch };
     editRelationsInStore(
       usersInRooms,
       (relations) => {
         relations.set({ room: roomId, user: userId }, meta);
       },
-      transactors.env().store
+      tools.env().store
     );
     return meta;
   }
 });
 var leaveRoomTX = AtomIO.transaction({
   key: `leaveRoom`,
-  do: (transactors, roomId, userId) => {
+  do: (tools, roomId, userId) => {
     editRelationsInStore(
       usersInRooms,
       (relations) => {
         relations.delete({ room: roomId, user: userId });
       },
-      transactors.env().store
+      tools.env().store
     );
   }
 });
 var destroyRoomTX = AtomIO.transaction({
   key: `destroyRoom`,
-  do: (transactors, roomId) => {
+  do: (tools, roomId) => {
     editRelationsInStore(
       usersInRooms,
       (relations) => {
         relations.delete({ room: roomId });
       },
-      transactors.env().store
+      tools.env().store
     );
-    transactors.set(roomIndex, (s) => (s.delete(roomId), s));
+    tools.set(roomIndex, (s) => (s.delete(roomId), s));
   }
 });
 function redactTransactionUpdateContent(visibleStateKeys, updates) {

package/realtime-server/src/realtime-server-stores/server-room-external-actions.ts

@@ -31,14 +31,14 @@ export const joinRoomTX = AtomIO.transaction<
 	(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta
 >({
 	key: `joinRoom`,
-	do: (transactors, roomId, userId, enteredAtEpoch) => {
+	do: (tools, roomId, userId, enteredAtEpoch) => {
 		const meta = { enteredAtEpoch }
 		editRelationsInStore(
 			usersInRooms,
 			(relations) => {
 				relations.set({ room: roomId, user: userId }, meta)
 			},
-			transactors.env().store,
+			tools.env().store,
 		)
 		return meta
 	},
@@ -49,13 +49,13 @@ export const leaveRoomTX = AtomIO.transaction<
 	(roomId: string, userId: string) => void
 >({
 	key: `leaveRoom`,
-	do: (transactors, roomId, userId) => {
+	do: (tools, roomId, userId) => {
 		editRelationsInStore(
 			usersInRooms,
 			(relations) => {
 				relations.delete({ room: roomId, user: userId })
 			},
-			transactors.env().store,
+			tools.env().store,
 		)
 	},
 })
@@ -63,14 +63,14 @@ export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
 
 export const destroyRoomTX = AtomIO.transaction<(roomId: string) => void>({
 	key: `destroyRoom`,
-	do: (transactors, roomId) => {
+	do: (tools, roomId) => {
 		editRelationsInStore(
 			usersInRooms,
 			(relations) => {
 				relations.delete({ room: roomId })
 			},
-			transactors.env().store,
+			tools.env().store,
 		)
-		transactors.set(roomIndex, (s) => (s.delete(roomId), s))
+		tools.set(roomIndex, (s) => (s.delete(roomId), s))
 	},
 })

package/src/dispose-state.ts

@@ -1,10 +1,39 @@
 import * as Internal from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
-import type { ReadableToken } from "."
-import type { MoleculeToken } from "./molecule"
+import type { ReadableFamilyToken, ReadableToken } from "."
+import type {
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeToken,
+} from "./molecule"
 
 export function disposeState(
 	token: MoleculeToken<any> | ReadableToken<any>,
+): void
+
+export function disposeState<K extends Json.Serializable>(
+	token: ReadableFamilyToken<any, K>,
+	key: K,
+): void
+
+export function disposeState<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+): void
+
+export function disposeState(
+	token:
+		| MoleculeFamilyToken<any>
+		| MoleculeToken<any>
+		| ReadableFamilyToken<any, any>
+		| ReadableToken<any>,
+	key?: Json.Serializable,
 ): void {
-	Internal.disposeFromStore(token, Internal.IMPLICIT.STORE)
+	if (key) {
+		Internal.disposeFromStore(token as any, key, Internal.IMPLICIT.STORE)
+	} else {
+		Internal.disposeFromStore(token as any, Internal.IMPLICIT.STORE)
+	}
 }

package/src/get-state.ts

@@ -1,11 +1,44 @@
 import * as Internal from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
-import type { MoleculeConstructor, MoleculeToken, ReadableToken } from "."
+import type {
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeToken,
+	ReadableFamilyToken,
+	ReadableToken,
+} from "."
 
 export function getState<T>(token: ReadableToken<T>): T
+
 export function getState<M extends MoleculeConstructor>(
 	token: MoleculeToken<M>,
-): InstanceType<M> | undefined
-export function getState(token: MoleculeToken<any> | ReadableToken<any>): any {
-	return Internal.getFromStore(token, Internal.IMPLICIT.STORE)
+): InstanceType<M>
+
+export function getState<T, K extends Json.Serializable>(
+	token: ReadableFamilyToken<T, K>,
+	key: K,
+): T
+
+export function getState<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: Json.Serializable,
+): InstanceType<M>
+
+export function getState(
+	token:
+		| MoleculeFamilyToken<any>
+		| MoleculeToken<any>
+		| ReadableFamilyToken<any, any>
+		| ReadableToken<any>,
+	key?: Json.Serializable,
+): any {
+	if (key) {
+		return Internal.getFromStore(
+			token as any,
+			key as any,
+			Internal.IMPLICIT.STORE,
+		)
+	}
+	return Internal.getFromStore(token as any, Internal.IMPLICIT.STORE)
 }

package/src/molecule.ts

@@ -1,4 +1,5 @@
 import type {
+	ActorToolkit,
 	Flat,
 	MoleculeCreation,
 	MoleculeDisposal,
@@ -10,7 +11,6 @@ import type {
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
-	TransactorsWithRunAndEnv,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
@@ -26,8 +26,8 @@ import {
 } from "atom.io/internal"
 import { type Json, stringifyJson } from "atom.io/json"
 
-export type MoleculeTransactors<K extends Json.Serializable> = Flat<
-	Omit<TransactorsWithRunAndEnv, `find`> & {
+export type CtorToolkit<K extends Json.Serializable> = Flat<
+	Omit<ActorToolkit, `find`> & {
 		bond<T extends Transceiver<any>, J extends Json.Serializable>(
 			family: MutableAtomFamilyToken<T, J, K>,
 		): MutableAtomToken<T, J>
@@ -36,10 +36,23 @@ export type MoleculeTransactors<K extends Json.Serializable> = Flat<
 		bond<T>(family: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>
 		bond<T>(family: WritableFamilyToken<T, K>): WritableToken<T>
 		bond<T>(family: ReadableFamilyToken<T, K>): ReadableToken<T>
+		bond<J extends JoinToken<any, any, any, any>>(
+			joinToken: J,
+			role: {
+				as: J extends JoinToken<infer A, infer B, any, any> ? A | B : never
+			},
+		): J extends JoinToken<any, any, any, infer Content>
+			? Content extends null
+				? { relatedKeys: ReadonlySelectorToken<string[]> }
+				: {
+						relatedKeys: ReadonlySelectorToken<string[]>
+						relatedEntries: ReadonlySelectorToken<
+							[key: string, value: Content][]
+						>
+					}
+			: never
 
-		claim(below: MoleculeToken<any>, options: { exclusive: boolean })
-
-		join<J extends JoinToken<any, any, any, any>>(joinToken: J): J
+		claim(below: MoleculeToken<any>, options: { exclusive: boolean }): void
 
 		spawn<Key extends Json.Serializable, Ctor extends MoleculeConstructor>(
 			family: MoleculeFamilyToken<Ctor>,
@@ -49,7 +62,7 @@ export type MoleculeTransactors<K extends Json.Serializable> = Flat<
 	}
 >
 export type MoleculeConstructor = new (
-	transactors: MoleculeTransactors<any>,
+	toolkit: CtorToolkit<any>,
 	key: any,
 	...params: any
 ) => any

package/src/set-state.ts

@@ -1,10 +1,27 @@
 import * as Internal from "atom.io/internal"
+import type { Json } from "rel8"
 
-import type { WritableToken } from "."
+import type { WritableFamilyToken, WritableToken } from "."
 
 export function setState<T, New extends T>(
 	token: WritableToken<T>,
 	value: New | ((oldValue: T) => New),
+): void
+
+export function setState<T, K extends Json.Serializable, New extends T>(
+	token: WritableFamilyToken<T, K>,
+	key: K,
+	value: New | ((oldValue: T) => New),
+): void
+
+export function setState<T, New extends T>(
+	token: WritableFamilyToken<T, Json.Serializable> | WritableToken<T>,
+	p1: Json.Serializable | New | ((oldValue: T) => New),
+	p2?: New | ((oldValue: T) => New),
 ): void {
-	Internal.setIntoStore(token, value, Internal.IMPLICIT.STORE)
+	if (p2) {
+		Internal.setIntoStore(token as any, p1 as any, p2, Internal.IMPLICIT.STORE)
+	} else {
+		Internal.setIntoStore(token as any, p1 as any, Internal.IMPLICIT.STORE)
+	}
 }

package/src/silo.ts

@@ -7,6 +7,7 @@ import {
 	createStandaloneSelector,
 	createTimeline,
 	createTransaction,
+	disposeFromStore,
 	findInStore,
 	getFromStore,
 	setIntoStore,
@@ -17,6 +18,7 @@ import type { Json } from "atom.io/json"
 
 import type {
 	AtomToken,
+	disposeState,
 	getState,
 	MutableAtomFamily,
 	MutableAtomFamilyOptions,
@@ -47,6 +49,7 @@ export class Silo {
 	public findState: typeof findState
 	public getState: typeof getState
 	public setState: typeof setState
+	public disposeState: typeof disposeState
 	public subscribe: typeof subscribe
 	public undo: typeof undo
 	public redo: typeof redo
@@ -84,10 +87,14 @@ export class Silo {
 		this.transaction = (options) => createTransaction(options, s)
 		this.timeline = (options) => createTimeline(options, s)
 		this.findState = (token, key) => findInStore(token, key, s) as any
-		this.getState = (token) => getFromStore(token, s)
-		this.setState = (token, newValue) => {
-			setIntoStore(token, newValue, s)
-		}
+		this.getState = ((...params: Parameters<typeof getState>) =>
+			getFromStore(...params, s)) as typeof getState
+		this.setState = ((...params: Parameters<typeof setState>) => {
+			setIntoStore(...params, s)
+		}) as typeof setState
+		this.disposeState = ((...params: Parameters<typeof disposeState>) => {
+			disposeFromStore(...params, s)
+		}) as typeof disposeState
 		this.subscribe = (token, handler, key) => subscribe(token, handler, key, s)
 		this.undo = (token) => {
 			timeTravel(`undo`, token, s)

package/src/transaction.ts

@@ -5,6 +5,7 @@ import type {
 	MoleculeFamilyToken,
 	MoleculeParams,
 	MoleculeToken,
+	setState,
 } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
 import type { seekState } from "atom.io/immortal"
@@ -78,24 +79,19 @@ export type TransactionUpdate<F extends Func> = {
 	output: ReturnType<F>
 }
 
-export type Transactors = Readonly<{
+export type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json` | `seek`>
+export type SetterToolkit = Readonly<{
 	get: typeof getState
-	set: <S, New extends S>(
-		state: WritableToken<S>,
-		newValue: New | ((oldValue: S) => New),
-	) => void
+	set: typeof setState
 	find: typeof findState
 	seek: typeof seekState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,
 	) => WritableSelectorToken<J>
 }>
-export type TransactorsWithRunAndEnv = Readonly<{
+export type ActorToolkit = Readonly<{
 	get: typeof getState
-	set: <S, New extends S>(
-		state: WritableToken<S>,
-		newValue: New | ((oldValue: S) => New),
-	) => void
+	set: typeof setState
 	find: typeof findState
 	seek: typeof seekState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
@@ -106,23 +102,19 @@ export type TransactorsWithRunAndEnv = Readonly<{
 	run: typeof runTransaction
 	env: () => EnvironmentData
 }>
-export type ReadonlyTransactors = Pick<
-	Transactors,
-	`find` | `get` | `json` | `seek`
->
 
 export type Read<F extends Func> = (
-	transactors: ReadonlyTransactors,
+	toolkit: GetterToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
 
 export type Write<F extends Func> = (
-	transactors: Transactors,
+	toolkit: SetterToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
 
 export type Transact<F extends Func> = (
-	transactors: TransactorsWithRunAndEnv,
+	toolkit: ActorToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>