atom.io 0.24.8 → 0.25.0

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>