atom.io 0.40.6 → 0.40.8

package/src/realtime-client/pull-selector-roots.ts

@@ -0,0 +1,90 @@
+import type { AtomToken, SelectorToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { getFamilyOfToken, subscribeToState } from "atom.io/internal"
+import { parseJson } from "atom.io/json"
+import type { Socket } from "socket.io-client"
+
+import { pullAtom } from "./pull-atom"
+import { pullAtomFamilyMember } from "./pull-atom-family-member"
+import { pullMutableAtom } from "./pull-mutable-atom"
+import { pullMutableAtomFamilyMember } from "./pull-mutable-atom-family-member"
+
+export function pullSelectorRoots(
+	store: Store,
+	socket: Socket,
+	selectorToken: SelectorToken<any>,
+): () => void {
+	const atomSubscriptions = new Map<string, () => void>()
+	const clearAtomSubscriptions = () => {
+		for (const [, unsub] of atomSubscriptions) unsub()
+		atomSubscriptions.clear()
+	}
+
+	const start = () => {
+		const atomKeys = store.selectorAtoms.getRelatedKeys(selectorToken.key)
+		if (atomKeys) {
+			for (const [atomKey, unsub] of atomSubscriptions) {
+				if (!atomKeys.has(atomKey)) {
+					unsub()
+					atomSubscriptions.delete(atomKey)
+				}
+			}
+
+			for (const atomKey of atomKeys) {
+				if (atomSubscriptions.has(atomKey)) {
+					continue
+				}
+				const atom = store.atoms.get(atomKey) as AtomToken<any, any>
+				switch (atom.type) {
+					case `atom`: {
+						if (atom.family) {
+							const { subKey: serializedSubKey } = atom.family
+							const subKey = parseJson(serializedSubKey)
+							const family = getFamilyOfToken(store, atom)
+							atomSubscriptions.set(
+								atomKey,
+								pullAtomFamilyMember(store, socket, family, subKey),
+							)
+						} else {
+							atomSubscriptions.set(atomKey, pullAtom(store, socket, atom))
+						}
+						break
+					}
+					case `mutable_atom`: {
+						if (atom.family) {
+							const { subKey: serializedSubKey } = atom.family
+							const subKey = parseJson(serializedSubKey)
+							const family = getFamilyOfToken(store, atom)
+							atomSubscriptions.set(
+								atomKey,
+								pullMutableAtomFamilyMember(store, socket, family, subKey),
+							)
+						} else {
+							atomSubscriptions.set(
+								atomKey,
+								pullMutableAtom(store, socket, atom),
+							)
+						}
+						break
+					}
+				}
+			}
+		}
+	}
+
+	const unsubFromSelector = subscribeToState(
+		store,
+		selectorToken,
+		`pull-watches-dependencies`,
+		() => {
+			start()
+		},
+	)
+
+	start()
+
+	return () => {
+		clearAtomSubscriptions()
+		unsubFromSelector()
+	}
+}

package/src/realtime-client/pull-selector.ts

@@ -2,37 +2,12 @@ import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-import { pullAtom } from "./pull-atom"
-import { pullMutableAtom } from "./pull-mutable-atom"
+import { pullSelectorRoots } from "./pull-selector-roots"
 
 export function pullSelector<T>(
 	store: Store,
 	socket: Socket,
 	token: AtomIO.SelectorToken<T>,
 ): () => void {
-	const atomKeys = store.selectorAtoms.getRelatedKeys(token.key)
-	const unsubscribes: Array<() => void> = []
-	if (atomKeys) {
-		for (const atomKey of atomKeys) {
-			const atom = store.atoms.get(atomKey)
-			if (!atom) {
-				continue
-			}
-			switch (atom.type) {
-				case `atom`: {
-					unsubscribes.push(pullAtom(store, socket, atom))
-					break
-				}
-				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtom(store, socket, atom))
-					break
-				}
-			}
-		}
-	}
-	return () => {
-		for (const unsubscribe of unsubscribes) {
-			unsubscribe()
-		}
-	}
+	return pullSelectorRoots(store, socket, token)
 }

package/src/realtime-client/push-state.ts

@@ -1,7 +1,9 @@
 import type { WritableToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import { subscribeToState } from "atom.io/internal"
+import { setIntoStore, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import { mutexAtoms } from "atom.io/realtime/mutex-store"
+import { employSocket } from "atom.io/realtime-server/employ-socket"
 import type { Socket } from "socket.io-client"
 
 export function pushState<J extends Json.Serializable>(
@@ -9,12 +11,38 @@ export function pushState<J extends Json.Serializable>(
 	socket: Socket,
 	token: WritableToken<J>,
 ): () => void {
-	socket.emit(`claim:${token.key}`)
-	subscribeToState(store, token, `push`, ({ newValue }) => {
+	const publish = (newValue: J) => {
 		socket.emit(`pub:${token.key}`, newValue)
-	})
+	}
+
+	const subscriptions = new Set<() => void>()
+	const clearSubscriptions = () => {
+		for (const unsub of subscriptions) unsub()
+		subscriptions.clear()
+	}
+
+	const init = () => {
+		subscriptions.add(
+			employSocket(socket, `claim-result:${token.key}`, (success: boolean) => {
+				if (!success) return
+
+				clearSubscriptions()
+				setIntoStore(store, mutexAtoms, token.key, true)
+				subscriptions.add(
+					subscribeToState(store, token, `push`, ({ newValue }) => {
+						publish(newValue)
+					}),
+				)
+			}),
+		)
+
+		socket.emit(`claim:${token.key}`)
+	}
+
+	init()
+
 	return () => {
-		socket.off(`pub:${token.key}`)
+		clearSubscriptions()
 		socket.emit(`unclaim:${token.key}`)
 	}
 }

package/src/realtime-client/realtime-client-stores/client-main-store.ts

@@ -1,5 +1,5 @@
 import * as AtomIO from "atom.io"
-import { persistSync } from "atom.io/web"
+import { storageSync } from "atom.io/web"
 
 export const myIdState__INTERNAL: AtomIO.RegularAtomToken<string | undefined> =
 	AtomIO.atom<string | undefined>({
@@ -16,8 +16,5 @@ export const myUsernameState: AtomIO.RegularAtomToken<string | null> =
 	AtomIO.atom<string | null>({
 		key: `myName`,
 		default: null,
-		effects:
-			typeof window === `undefined`
-				? []
-				: [persistSync(window.localStorage, JSON, `myUsername`)],
+		effects: [storageSync(globalThis.localStorage, JSON, `myUsername`)],
 	})

package/src/realtime-react/index.ts

@@ -1,4 +1,3 @@
-export * from "./on-mount"
 export * from "./realtime-context"
 export * from "./use-pull-atom"
 export * from "./use-pull-atom-family-member"
@@ -7,5 +6,6 @@ export * from "./use-pull-mutable-family-member"
 export * from "./use-pull-selector"
 export * from "./use-pull-selector-family-member"
 export * from "./use-push"
-export * from "./use-server-action"
+export * from "./use-realtime-service"
+export * from "./use-single-effect"
 export * from "./use-sync-continuity"

package/src/realtime-react/realtime-context.tsx

@@ -3,12 +3,14 @@ import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 import type { Socket } from "socket.io-client"
 
+export type RealtimeServiceCounter = {
+	consumerCount: number
+	dispose: () => void
+}
+
 export type RealtimeReactStore = {
 	socket: Socket | null
-	services: Map<
-		string,
-		[consumerCount: number, dispose: (() => void) | undefined]
-	> | null
+	services: Map<string, RealtimeServiceCounter> | null
 }
 
 export const RealtimeContext: React.Context<RealtimeReactStore> =
@@ -21,7 +23,9 @@ export const RealtimeProvider: React.FC<{
 	children: React.ReactNode
 	socket: Socket | null
 }> = ({ children, socket }) => {
-	const services = React.useRef(new Map<string, [number, () => void]>()).current
+	const services = React.useRef(
+		new Map<string, RealtimeServiceCounter>(),
+	).current
 	const setMyId = useI(RTC.myIdState__INTERNAL)
 	React.useEffect(() => {
 		setMyId(socket?.id)

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

@@ -10,12 +10,11 @@ import { useRealtimeService } from "./use-realtime-service"
 export function usePullAtomFamilyMember<
 	J extends Json.Serializable,
 	K extends Canonical,
-	Key extends K,
->(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: Key): J {
+>(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: NoInfer<K>): J {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, family, subKey)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullAtomFamilyMember(store, socket, token),
+		RTC.pullAtomFamilyMember(store, socket, family, subKey),
 	)
 	return useO(token)
 }

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

@@ -11,12 +11,11 @@ import { useRealtimeService } from "./use-realtime-service"
 export function usePullMutableAtomFamilyMember<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
-	Key extends K,
->(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: Key): T {
+>(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: NoInfer<K>): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullMutableAtomFamilyMember(store, socket, token),
+		RTC.pullMutableAtomFamilyMember(store, socket, familyToken, key),
 	)
 	return useO(token)
 }

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

@@ -7,15 +7,14 @@ import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function usePullSelectorFamilyMember<
-	T,
-	K extends Canonical,
-	Key extends K,
->(familyToken: AtomIO.SelectorFamilyToken<T, K>, key: Key): T {
+export function usePullSelectorFamilyMember<T, K extends Canonical>(
+	familyToken: AtomIO.SelectorFamilyToken<T, K>,
+	key: NoInfer<K>,
+): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullSelectorFamilyMember(store, socket, token),
+		RTC.pullSelectorFamilyMember(store, socket, familyToken, key),
 	)
 
 	return useO(token)

package/src/realtime-react/use-push.ts

@@ -1,6 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Json } from "atom.io/json"
-import { StoreContext, useI } from "atom.io/react"
+import { StoreContext, useI, useO } from "atom.io/react"
+import * as RT from "atom.io/realtime"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 
@@ -8,10 +9,13 @@ import { useRealtimeService } from "./use-realtime-service"
 
 export function usePush<J extends Json.Serializable>(
 	token: AtomIO.WritableToken<J>,
-): <New extends J>(next: New | ((old: J) => New)) => void {
+): (<New extends J>(next: New | ((old: J) => New)) => void) | null {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`push:${token.key}`, (socket) =>
 		RTC.pushState(store, socket, token),
 	)
-	return useI(token)
+	const mutex = useO(RT.mutexAtoms, token.key)
+	const setter = useI(token)
+
+	return mutex ? setter : null
 }

package/src/realtime-react/use-realtime-service.ts

@@ -1,31 +1,31 @@
 import * as React from "react"
 import type { Socket } from "socket.io-client"
 
-import { onMount } from "./on-mount"
 import { RealtimeContext } from "./realtime-context"
+import { useSingleEffect } from "./use-single-effect"
 
 export function useRealtimeService(
 	key: string,
-	create: (socket: Socket) => (() => void) | undefined,
+	create: (socket: Socket) => () => void,
 ): void {
 	const { socket, services } = React.useContext(RealtimeContext)
-	onMount(() => {
+	useSingleEffect(() => {
 		let service = services?.get(key)
 		if (service) {
-			service[0]++
-		} else {
-			const dispose = socket ? create(socket) : undefined
-			service = [1, dispose]
+			++service.consumerCount
+		} else if (socket) {
+			const dispose = create(socket)
+			service = { consumerCount: 1, dispose }
 			services?.set(key, service)
 		}
 		return () => {
 			if (service) {
-				service[0]--
-				if (service[0] === 0) {
-					service[1]?.()
+				--service.consumerCount
+				if (service.consumerCount === 0) {
+					service.dispose?.()
 					services?.delete(key)
 				}
 			}
 		}
-	})
+	}, [socket, key])
 }

package/src/realtime-react/use-single-effect.ts

@@ -1,28 +1,25 @@
 /** biome-ignore-all lint/correctness/useHookAtTopLevel: intentional */
 
+import { isFn } from "atom.io/internal/is-fn"
 import * as React from "react"
 
-// @ts-expect-error this is a safe way to check a property on the global object
-const { NODE_ENV } = globalThis[`env`] ?? {}
-const IN_DEV = NODE_ENV === `development`
-
-function noop() {}
-
 export function useSingleEffect(
 	effect: () => (() => void) | undefined | void,
 	deps: unknown[],
 ): void {
-	if (IN_DEV) {
-		const cleanup = React.useRef<() => void>(noop)
+	const globalEnv = (globalThis as unknown as { env: any })[`env`]
+	const isInDev = globalEnv?.NODE_ENV === `development`
+	if (isInDev) {
+		const cleanupRef = React.useRef<boolean | (() => void)>(false)
 		React.useEffect(() => {
-			let dispose = cleanup.current
-			if (dispose === noop) {
-				dispose = effect() ?? noop
-				cleanup.current = dispose
+			let cleanupFn = cleanupRef.current
+			if (cleanupFn === false) {
+				cleanupFn = effect() ?? true
+				cleanupRef.current = cleanupFn
 			} else {
 				return () => {
-					dispose()
-					cleanup.current = noop
+					if (isFn(cleanupFn)) cleanupFn()
+					cleanupRef.current = false
 				}
 			}
 		}, deps)

package/src/realtime-server/{realtime-server-stores/server-sync-store.ts → continuity/continuity-store.ts}

@@ -5,15 +5,7 @@ import type {
 } from "atom.io"
 import { atomFamily } from "atom.io"
 
-import type { UserKey } from "./server-user-store"
-
-// export const completeUpdateAtoms = atomFamily<
-// 	TransactionUpdate<any> | null,
-// 	string
-// >({
-// 	key: `completeUpdate`,
-// 	default: null,
-// })
+import type { UserKey } from "../realtime-server-stores/server-user-store"
 
 export function redactTransactionUpdateContent(
 	visibleStateKeys: string[],
@@ -67,29 +59,12 @@ export const redactorAtoms: RegularAtomFamilyToken<
 	key: `redactor`,
 	default: { occlude: (updates) => updates },
 })
-// export const redactedUpdateSelectors = selectorFamily<
-// 	TransactionUpdate<any> | null,
-// 	[transactionKey: string, updateId: string]
-// >({
-// 	key: `redactedUpdate`,
-// 	get:
-// 		([transactionKey, updateId]) =>
-// 		({ get, find }) => {
-// 			const update = get(find(completeUpdateAtoms, updateId))
-// 			const { filter } = get(find(transactionRedactorAtoms, transactionKey))
-
-// 			if (update && filter) {
-// 				return { ...update, updates: filter(update.updates) }
-// 			}
-// 			return null
-// 		},
-// })
 
 export type ContinuitySyncTransactionUpdate = Pick<
 	TransactionOutcomeEvent<any>,
 	`epoch` | `id` | `output` | `subEvents` | `token`
 >
-export const userUnacknowledgedQueues: RegularAtomFamilyToken<
+export const unacknowledgedUpdatesAtoms: RegularAtomFamilyToken<
 	ContinuitySyncTransactionUpdate[],
 	UserKey
 > = atomFamily<ContinuitySyncTransactionUpdate[], UserKey>({

package/src/realtime-server/continuity/provide-continuity.ts

@@ -0,0 +1,50 @@
+import { getFromStore, IMPLICIT } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { ServerConfig, UserKey } from ".."
+import { unacknowledgedUpdatesAtoms } from "./continuity-store"
+import { provideOutcomes } from "./provide-outcomes"
+import { providePerspectives } from "./provide-perspectives"
+import { provideStartupPayloads } from "./provide-startup-payloads"
+import { receiveActionRequests } from "./receive-action-requests"
+import { trackAcknowledgements } from "./track-acknowledgements"
+
+export type ProvideContinuity = (
+	continuity: ContinuityToken,
+	userKey: UserKey,
+) => () => void
+export function prepareToProvideContinuity({
+	socket,
+	store = IMPLICIT.STORE,
+}: ServerConfig): ProvideContinuity {
+	return function syncRealtimeContinuity(continuity, userKey) {
+		const continuityKey = continuity.key
+
+		const unacknowledgedUpdates = getFromStore(
+			store,
+			unacknowledgedUpdatesAtoms,
+			userKey,
+		)
+		for (const unacknowledgedUpdate of unacknowledgedUpdates) {
+			socket.emit(
+				`tx-new:${continuityKey}`,
+				unacknowledgedUpdate as Json.Serializable,
+			)
+		}
+
+		const subscriptions = new Set<() => void>()
+		const clearSubscriptions = () => {
+			for (const unsubscribe of subscriptions) unsubscribe()
+			subscriptions.clear()
+		}
+
+		subscriptions.add(providePerspectives(store, socket, continuity, userKey))
+		subscriptions.add(provideOutcomes(store, socket, continuity, userKey))
+		subscriptions.add(provideStartupPayloads(store, socket, continuity, userKey))
+		subscriptions.add(receiveActionRequests(store, socket, continuity, userKey))
+		subscriptions.add(trackAcknowledgements(store, socket, continuity, userKey))
+
+		return clearSubscriptions
+	}
+}

package/src/realtime-server/continuity/{subscribe-to-continuity-actions.ts → provide-outcomes.ts}

@@ -12,24 +12,24 @@ import type { ContinuityToken } from "atom.io/realtime"
 import type { Socket, UserKey } from ".."
 import {
 	redactTransactionUpdateContent,
-	userUnacknowledgedQueues,
-} from "../realtime-server-stores"
+	unacknowledgedUpdatesAtoms,
+} from "./continuity-store"
 
-export function subscribeToContinuityActions(
+export function provideOutcomes(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	socket: Socket | null,
-): (() => void)[] {
+): () => void {
 	const continuityKey = continuity.key
-	const unsubscribeFunctions: (() => void)[] = []
+	const unsubscribeFunctions = new Set<() => void>()
 
 	for (const transaction of continuity.actions) {
 		const unsubscribeFromTransaction = subscribeToTransaction(
 			store,
 			transaction,
 			`sync-continuity:${continuityKey}:${userKey}`,
-			(update) => {
+			(outcomes) => {
 				try {
 					const visibleKeys = continuity.globals
 						.map((atom) => {
@@ -59,13 +59,13 @@ export function subscribeToContinuityActions(
 						)
 					const redactedUpdates = redactTransactionUpdateContent(
 						visibleKeys,
-						update.subEvents,
+						outcomes.subEvents,
 					)
 					const redactedUpdate = {
-						...update,
+						...outcomes,
 						updates: redactedUpdates,
 					}
-					setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+					setIntoStore(store, unacknowledgedUpdatesAtoms, userKey, (updates) => {
 						if (redactedUpdate) {
 							updates.push(redactedUpdate)
 							updates.sort((a, b) => a.epoch - b.epoch)
@@ -81,7 +81,7 @@ export function subscribeToContinuityActions(
 						return updates
 					})
 
-					socket?.emit(
+					socket.emit(
 						`tx-new:${continuityKey}`,
 						redactedUpdate as Json.Serializable,
 					)
@@ -98,7 +98,9 @@ export function subscribeToContinuityActions(
 				}
 			},
 		)
-		unsubscribeFunctions.push(unsubscribeFromTransaction)
+		unsubscribeFunctions.add(unsubscribeFromTransaction)
+	}
+	return () => {
+		for (const unsubscribe of unsubscribeFunctions) unsubscribe()
 	}
-	return unsubscribeFunctions
 }

package/src/realtime-server/continuity/{subscribe-to-continuity-perpectives.ts → provide-perspectives.ts}

@@ -10,14 +10,14 @@ import type { ContinuityToken } from "atom.io/realtime"
 import type { Socket } from ".."
 import type { UserKey } from "../realtime-server-stores"
 
-export function subscribeToContinuityPerspectives(
+export function providePerspectives(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	socket: Socket | null,
-): (() => void)[] {
+): () => void {
 	const continuityKey = continuity.key
-	const unsubFns: (() => void)[] = []
+	const unsubFns = new Set<() => void>()
 	for (const perspective of continuity.perspectives) {
 		const { viewAtoms } = perspective
 		const userViewState = findInStore(store, viewAtoms, userKey)
@@ -47,14 +47,16 @@ export function subscribeToContinuityPerspectives(
 					{ oldKeys, newKeys, revealed, concealed },
 				)
 				if (revealed.length > 0) {
-					socket?.emit(`reveal:${continuityKey}`, revealed)
+					socket.emit(`reveal:${continuityKey}`, revealed)
 				}
 				if (concealed && concealed.length > 0) {
-					socket?.emit(`conceal:${continuityKey}`, concealed)
+					socket.emit(`conceal:${continuityKey}`, concealed)
 				}
 			},
 		)
-		unsubFns.push(unsubscribeFromUserView)
+		unsubFns.add(unsubscribeFromUserView)
+	}
+	return () => {
+		for (const unsubscribe of unsubFns) unsubscribe()
 	}
-	return unsubFns
 }

package/src/realtime-server/continuity/{prepare-to-send-initial-payload.ts → provide-startup-payloads.ts}

@@ -9,15 +9,16 @@ import type { Json } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 
 import type { Socket, UserKey } from ".."
+import { employSocket } from "../employ-socket"
 
-export function prepareToSendInitialPayload(
+export function provideStartupPayloads(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	socket: Socket | null,
 ): () => void {
 	const continuityKey = continuity.key
-	return function sendInitialPayload(): void {
+	function sendInitialPayload(): void {
 		const initialPayload: Json.Serializable[] = []
 		for (const atom of continuity.globals) {
 			const resourceToken =
@@ -49,6 +50,7 @@ export function prepareToSendInitialPayload(
 			? (store.transactionMeta.epoch.get(continuityKey) ?? null)
 			: null
 
-		socket?.emit(`continuity-init:${continuityKey}`, epoch, initialPayload)
+		socket.emit(`continuity-init:${continuityKey}`, epoch, initialPayload)
 	}
+	return employSocket(socket, `get:${continuityKey}`, sendInitialPayload)
 }