atom.io 0.34.2 → 0.36.0

package/src/realtime-client/pull-mutable-atom-family-member.ts

@@ -1,19 +1,15 @@
 import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
+import type { AsJSON, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 /* eslint-disable no-console */
 
-export function pullMutableAtomFamilyMember<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function pullMutableAtomFamilyMember<T extends Transceiver<any, any>>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.MutableAtomToken<T, J>,
+	token: AtomIO.MutableAtomToken<T>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)
@@ -21,13 +17,13 @@ export function pullMutableAtomFamilyMember<
 	}
 	const { key: familyKey, subKey: serializedSubKey } = token.family
 	const subKey = parseJson(serializedSubKey)
-	socket.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		const jsonToken = getJsonToken(store, token)
 		setIntoStore(store, jsonToken, data)
 	})
 	socket.on(
 		`next:${token.key}`,
-		(data: T extends Transceiver<infer Signal> ? Signal : never) => {
+		(data: T extends Transceiver<infer Signal, any> ? Signal : never) => {
 			const trackerToken = getUpdateToken(token)
 			setIntoStore(store, trackerToken, data)
 		},

package/src/realtime-client/pull-mutable-atom.ts

@@ -1,25 +1,21 @@
 import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
+import type { AsJSON, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-export function pullMutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function pullMutableAtom<T extends Transceiver<any, any>>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.MutableAtomToken<T, J>,
+	token: AtomIO.MutableAtomToken<T>,
 ): () => void {
 	const jsonToken = getJsonToken(store, token)
 	const updateToken = getUpdateToken(token)
-	socket.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		setIntoStore(store, jsonToken, data)
 	})
 	socket.on(
 		`next:${token.key}`,
-		(data: T extends Transceiver<infer Update> ? Update : never) => {
+		(data: T extends Transceiver<infer Update, any> ? Update : never) => {
 			setIntoStore(store, updateToken, data)
 		},
 	)

package/src/realtime-react/use-pull-mutable-atom.ts

@@ -1,16 +1,14 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function usePullMutable<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(token: AtomIO.MutableAtomToken<T, J>): T {
+export function usePullMutable<T extends Transceiver<any, any>>(
+	token: AtomIO.MutableAtomToken<T>,
+): T {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
 		RTC.pullMutableAtom(store, socket, token),

package/src/realtime-react/use-pull-mutable-family-member.ts

@@ -1,7 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
@@ -9,11 +9,10 @@ import * as React from "react"
 import { useRealtimeService } from "./use-realtime-service"
 
 export function usePullMutableAtomFamilyMember<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
->(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T {
+>(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: Key): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>

package/src/realtime-server/realtime-mutable-family-provider.ts

@@ -8,7 +8,7 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
@@ -21,11 +21,10 @@ export function realtimeMutableFamilyProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function mutableFamilyProvider<
-		T extends Transceiver<any>,
-		J extends Json.Serializable,
+		T extends Transceiver<any, any>,
 		K extends Canonical,
 	>(
-		family: AtomIO.MutableAtomFamilyToken<T, J, K>,
+		family: AtomIO.MutableAtomFamilyToken<T, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
 		const unsubCallbacksByKey = new Map<string, () => void>()

package/src/realtime-server/realtime-mutable-provider.ts

@@ -17,9 +17,8 @@ export function realtimeMutableProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function mutableProvider<
-		Core extends Transceiver<Json.Serializable>,
-		SerializableCore extends Json.Serializable,
-	>(token: AtomIO.MutableAtomToken<Core, SerializableCore>): () => void {
+		Core extends Transceiver<Json.Serializable, Json.Serializable>,
+	>(token: AtomIO.MutableAtomToken<Core>): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null
 
 		const jsonToken = getJsonToken(store, token)

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

@@ -7,10 +7,11 @@ import { roomIndex, usersInRooms } from "atom.io/realtime"
 import type { ChildSocket } from "../ipc-sockets"
 import type { RoomArguments } from "./server-room-external-store"
 import { roomArgumentsAtoms, roomSelectors } from "./server-room-external-store"
+import type { RoomKey } from "./server-user-store"
 
 export const createRoomTX: AtomIO.TransactionToken<
 	(
-		roomId: string,
+		roomKey: RoomKey,
 		script: string,
 		options?: string[],
 	) => Loadable<ChildSocket<any, any>>
@@ -62,17 +63,17 @@ export const leaveRoomTX: AtomIO.TransactionToken<
 })
 export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
 
-export const destroyRoomTX: AtomIO.TransactionToken<(roomId: string) => void> =
+export const destroyRoomTX: AtomIO.TransactionToken<(roomKey: RoomKey) => void> =
 	AtomIO.transaction({
 		key: `destroyRoom`,
-		do: (tools, roomId) => {
+		do: (tools, roomKey) => {
 			editRelationsInStore(
 				usersInRooms,
 				(relations) => {
-					relations.delete({ room: roomId })
+					relations.delete({ room: roomKey })
 				},
 				tools.env().store,
 			)
-			tools.set(roomIndex, (s) => (s.delete(roomId), s))
+			tools.set(roomIndex, (s) => (s.delete(roomKey), s))
 		},
 	})

package/src/realtime-server/realtime-server-stores/server-user-store.ts

@@ -4,8 +4,7 @@ import type {
 	MutableAtomToken,
 	RegularAtomFamilyToken,
 } from "atom.io"
-import { atom, atomFamily, join } from "atom.io"
-import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
+import { atomFamily, join, mutableAtom } from "atom.io"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import type { Socket } from ".."
@@ -29,25 +28,17 @@ export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
 		default: null,
 	})
 
-export const socketIndex: MutableAtomToken<
-	SetRTX<SocketKey>,
-	SetRTXJson<SocketKey>
-> = atom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
+export const socketIndex: MutableAtomToken<SetRTX<SocketKey>> = mutableAtom<
+	SetRTX<SocketKey>
+>({
 	key: `socketsIndex`,
-	mutable: true,
-	default: () => new SetRTX(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
-export const userIndex: MutableAtomToken<
-	SetRTX<UserKey>,
-	SetRTXJson<UserKey>
-> = atom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
+export const userIndex: MutableAtomToken<SetRTX<UserKey>> = mutableAtom<
+	SetRTX<UserKey>
+>({
 	key: `usersIndex`,
-	mutable: true,
-	default: () => new SetRTX(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
 export const usersOfSockets: JoinToken<
 	`user`,

package/src/transceivers/set-rtx/set-rtx.ts

@@ -16,7 +16,7 @@ export interface SetRTXJson<P extends primitive> extends Json.Object {
 }
 export class SetRTX<P extends primitive>
 	extends Set<P>
-	implements Transceiver<NumberedSetUpdate>, Lineage
+	implements Transceiver<NumberedSetUpdate, SetRTXJson<P>>, Lineage
 {
 	public mode: TransceiverMode = `record`
 	public readonly subject: Subject<SetUpdate> = new Subject<SetUpdate>()

package/src/eslint-plugin/rules/synchronous-selector-dependencies.ts

@@ -1,140 +0,0 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-import type { RuleType } from "@eslint/core"
-import type { Rule } from "eslint"
-import type * as ESTree from "estree"
-
-import { walk } from "../walk"
-
-export const synchronousSelectorDependencies: {
-	meta: {
-		type: RuleType
-		docs: {
-			description: string
-			category: string
-			recommended: boolean
-			url: string
-		}
-		schema: never[]
-	}
-	create(context: Rule.RuleContext): Rule.NodeListener
-} = {
-	meta: {
-		type: `problem`,
-		docs: {
-			description: `disallow await before calling get on the parameter's get method inside selector`,
-			category: `Possible Errors`,
-			recommended: false,
-			url: ``, // URL to documentation page for this rule
-		},
-		schema: [], // no options
-	},
-	create(context) {
-		return {
-			CallExpression(node) {
-				let selectorComputation: ESTree.Node | undefined
-				if (`name` in node.callee && node.callee.name === `selectorFamily`) {
-					if (node.arguments[0].type === `ObjectExpression`) {
-						const selectorLookupProperty = node.arguments[0].properties.find(
-							(prop): prop is ESTree.Property => {
-								return (
-									`key` in prop && `name` in prop.key && prop.key.name === `get`
-								)
-							},
-						)
-						const selectorLookup = selectorLookupProperty?.value
-						if (
-							selectorLookup?.type === `FunctionExpression` ||
-							selectorLookup?.type === `ArrowFunctionExpression`
-						) {
-							if (selectorLookup.body.type === `BlockStatement`) {
-								for (const statement of selectorLookup.body.body) {
-									if (
-										statement.type === `ReturnStatement` &&
-										statement.argument
-									) {
-										selectorComputation = statement.argument
-									}
-								}
-							} else if (
-								selectorLookup.body.type === `FunctionExpression` ||
-								selectorLookup.body.type === `ArrowFunctionExpression`
-							) {
-								selectorComputation = selectorLookup.body
-							}
-						}
-					}
-				}
-				if (`name` in node.callee && node.callee.name === `selector`) {
-					if (node.arguments[0].type === `ObjectExpression`) {
-						const selectorComputationProperty =
-							node.arguments[0].properties.find(
-								(prop): prop is ESTree.Property => {
-									return (
-										`key` in prop &&
-										`name` in prop.key &&
-										prop.key.name === `get`
-									)
-								},
-							)
-						selectorComputation = selectorComputationProperty?.value
-					}
-				}
-				if (
-					selectorComputation?.type === `FunctionExpression` ||
-					selectorComputation?.type === `ArrowFunctionExpression`
-				) {
-					const nonDestructuredTransactorsName =
-						selectorComputation.params[0] &&
-						`name` in selectorComputation.params[0]
-							? selectorComputation.params[0].name
-							: undefined
-					let awaited: number | undefined
-					let awaitNode: ESTree.AwaitExpression | undefined
-					walk(selectorComputation, (n, depth) => {
-						// console.log(`${`\t`.repeat(depth)}${n.type} ${n.name ?? ``}`)
-						if (typeof awaited === `number`) {
-							if (awaited > depth) {
-								awaited = undefined
-								awaitNode = undefined
-							}
-						}
-						switch (n.type) {
-							case `AwaitExpression`:
-								awaited = depth
-								awaitNode = n
-								break
-							case `CallExpression`:
-								if (awaitNode) {
-									let willReport = false
-									switch (n.callee.type) {
-										case `MemberExpression`:
-											if (
-												n.callee.object.type === `Identifier` &&
-												n.callee.object.name ===
-													nonDestructuredTransactorsName &&
-												n.callee.property.type === `Identifier` &&
-												n.callee.property.name === `get`
-											) {
-												willReport = true
-											}
-											break
-										case `Identifier`:
-											if (n.callee.name === `get`) {
-												willReport = true
-											}
-											break
-									}
-									if (willReport) {
-										context.report({
-											node: awaitNode,
-											message: `Using await before calling the 'get' transactor is not allowed.`,
-										})
-									}
-								}
-						}
-					})
-				}
-			},
-		}
-	},
-} satisfies Rule.RuleModule

package/src/eslint-plugin/walk.ts

@@ -1,81 +0,0 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-import type * as ESTree from "estree"
-
-export function walk(
-	node: ESTree.Node,
-	callback: (node: ESTree.Node, depth: number) => void,
-	depth = 0,
-): void {
-	callback(node, depth)
-
-	switch (node.type) {
-		case `AwaitExpression`:
-			walk(node.argument, callback, depth + 1)
-			break
-		case `FunctionExpression`:
-		case `ArrowFunctionExpression`:
-			for (const param of node.params) {
-				walk(param, callback, depth + 1)
-			}
-			walk(node.body, callback, depth + 1)
-			break
-		case `BlockStatement`:
-			for (const statement of node.body) {
-				walk(statement, callback, depth + 1)
-			}
-			break
-		case `IfStatement`:
-			walk(node.test, callback, depth)
-			walk(node.consequent, callback, depth)
-			if (node.alternate) {
-				walk(node.alternate, callback, depth)
-			}
-			break
-		case `SwitchStatement`:
-			walk(node.discriminant, callback, depth + 1)
-			for (const caseOrDefault of node.cases) {
-				walk(caseOrDefault, callback, depth)
-			}
-			break
-		case `ReturnStatement`:
-			if (node.argument) {
-				walk(node.argument, callback, depth)
-			}
-			break
-		case `SwitchCase`:
-			if (node.test) {
-				walk(node.test, callback, depth)
-			}
-			for (const statement of node.consequent) {
-				walk(statement, callback, depth)
-			}
-			break
-		case `VariableDeclaration`:
-			for (const declaration of node.declarations) {
-				walk(declaration, callback, depth)
-				if (declaration.init) {
-					walk(declaration.init, callback, depth)
-				}
-			}
-			break
-		case `BinaryExpression`:
-			walk(node.left, callback, depth)
-			walk(node.right, callback, depth)
-			break
-		case `ConditionalExpression`:
-			walk(node.test, callback, depth + 1)
-			walk(node.consequent, callback, depth + 1)
-			walk(node.alternate, callback, depth + 1)
-			break
-		case `MemberExpression`:
-			walk(node.object, callback, depth)
-			walk(node.property, callback, depth)
-			break
-		case `CallExpression`:
-			walk(node.callee, callback, depth)
-			for (const argument of node.arguments) {
-				walk(argument, callback, depth)
-			}
-			break
-	}
-}

package/src/internal/atom/create-standalone-atom.ts

@@ -1,39 +0,0 @@
-import type {
-	AtomToken,
-	MutableAtomOptions,
-	MutableAtomToken,
-	RegularAtomOptions,
-	RegularAtomToken,
-} from "atom.io"
-import type { Json } from "atom.io/json"
-
-import type { Transceiver } from "../mutable"
-import { createMutableAtom } from "../mutable"
-import type { Store } from "../store"
-import { createRegularAtom } from "./create-regular-atom"
-
-export function createStandaloneAtom<T>(
-	store: Store,
-	options: RegularAtomOptions<T>,
-): RegularAtomToken<T>
-
-export function createStandaloneAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>
-
-export function createStandaloneAtom<T>(
-	store: Store,
-	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
-): AtomToken<T> {
-	const isMutable = `mutable` in options
-
-	if (isMutable) {
-		const state = createMutableAtom(store, options, undefined)
-		store.on.atomCreation.next(state)
-		return state
-	}
-	const state = createRegularAtom(store, options, undefined)
-	store.on.atomCreation.next(state)
-	return state
-}

package/src/internal/families/create-atom-family.ts

@@ -1,38 +0,0 @@
-import type {
-	AtomFamilyToken,
-	MutableAtomFamilyOptions,
-	MutableAtomFamilyToken,
-	RegularAtomFamilyOptions,
-	RegularAtomFamilyToken,
-} from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
-
-import { createMutableAtomFamily, type Transceiver } from "../mutable"
-import type { Store } from "../store"
-import { createRegularAtomFamily } from "./create-regular-atom-family"
-
-export function createAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	options: MutableAtomFamilyOptions<T, J, K>,
-): MutableAtomFamilyToken<T, J, K>
-export function createAtomFamily<T, K extends Canonical>(
-	store: Store,
-	options: RegularAtomFamilyOptions<T, K>,
-): RegularAtomFamilyToken<T, K>
-export function createAtomFamily<T, K extends Canonical>(
-	store: Store,
-	options:
-		| MutableAtomFamilyOptions<any, any, any>
-		| RegularAtomFamilyOptions<T, K>,
-): AtomFamilyToken<any, any> {
-	const isMutable = `mutable` in options
-
-	if (isMutable) {
-		return createMutableAtomFamily(store, options)
-	}
-	return createRegularAtomFamily<T, K>(store, options)
-}

package/src/json/select-json-family.ts

@@ -1,55 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
-import { createWritablePureSelectorFamily } from "atom.io/internal"
-
-import type { Canonical, Json, JsonInterface } from "."
-
-export function selectJsonFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>,
-	transform: JsonInterface<T, J>,
-): AtomIO.WritablePureSelectorFamilyToken<J, K>
-export function selectJsonFamily<
-	T,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>,
-	transform: JsonInterface<T, J>,
-): AtomIO.WritablePureSelectorFamilyToken<J, K>
-export function selectJsonFamily<
-	T,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	atomFamilyToken:
-		| AtomIO.MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, J, K>
-		| AtomIO.RegularAtomFamilyToken<T, K>,
-	transform: JsonInterface<T, J>,
-): AtomIO.WritablePureSelectorFamilyToken<J, K> {
-	const jsonFamily = createWritablePureSelectorFamily<J, K>(
-		store,
-		{
-			key: `${atomFamilyToken.key}:JSON`,
-			get:
-				(key) =>
-				({ get }) => {
-					const baseState = get(atomFamilyToken, key)
-					return transform.toJson(baseState)
-				},
-			set:
-				(key) =>
-				({ set }, newValue) => {
-					set(atomFamilyToken, key, transform.fromJson(newValue))
-				},
-		},
-		[`mutable`, `json`],
-	)
-	return jsonFamily
-}

package/src/json/select-json.ts

@@ -1,19 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Store } from "atom.io/internal"
-import { createStandaloneSelector, IMPLICIT } from "atom.io/internal"
-
-import type { Json, JsonInterface } from "."
-
-export const selectJson = <T, J extends Json.Serializable>(
-	atom: AtomIO.AtomToken<T>,
-	transform: JsonInterface<T, J>,
-	store: Store = IMPLICIT.STORE,
-): AtomIO.WritablePureSelectorToken<J> => {
-	return createStandaloneSelector(store, {
-		key: `${atom.key}:JSON`,
-		get: ({ get }) => transform.toJson(get(atom)),
-		set: ({ set }, newValue) => {
-			set(atom, transform.fromJson(newValue))
-		},
-	})
-}