atom.io 0.31.1 → 0.32.1

package/realtime-client/src/continuity/register-and-attempt-confirmed-update.ts

@@ -102,7 +102,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 					key: subsequentOptimistic.key,
 				} as const
 				const { id, params } = subsequentOptimistic
-				actUponStore(token, id, store)(...params)
+				actUponStore(store, token, id)(...params)
 			}
 			store.logger.info(
 				`⏩`,
@@ -177,7 +177,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				continuityKey,
 				`has no optimistic updates to deal with`,
 			)
-			const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store)
+			const continuityEpoch = getEpochNumberOfContinuity(store, continuityKey)
 			const isRoot = isRootStore(store)
 
 			if (isRoot && continuityEpoch === confirmed.epoch - 1) {
@@ -189,7 +189,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				)
 				ingestTransactionUpdate(`newValue`, confirmed, store)
 				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
-				setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store)
+				setEpochNumberOfContinuity(store, continuityKey, confirmed.epoch)
 			} else if (isRoot && continuityEpoch !== undefined) {
 				store.logger.info(
 					`🧑‍⚖️`,

package/realtime-client/src/continuity/use-conceal-state.ts

@@ -5,7 +5,7 @@ import { disposeAtom } from "atom.io/internal"
 export function useConcealState(store: Store) {
 	return (concealed: AtomToken<unknown>[]): void => {
 		for (const token of concealed) {
-			disposeAtom(token, store)
+			disposeAtom(store, token)
 		}
 	}
 }

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

@@ -7,9 +7,9 @@ import type { Socket } from "socket.io-client"
 /* eslint-disable no-console */
 
 export function pullAtomFamilyMember<J extends Json.Serializable>(
-	token: AtomIO.RegularAtomToken<J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.RegularAtomToken<J>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)

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

@@ -4,9 +4,9 @@ import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 export function pullAtom<J extends Json.Serializable>(
-	token: AtomIO.RegularAtomToken<J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.RegularAtomToken<J>,
 ): () => void {
 	const setServedValue = (data: J) => {
 		setIntoStore(store, token, data)

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

@@ -11,9 +11,9 @@ export function pullMutableAtomFamilyMember<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
-	token: AtomIO.MutableAtomToken<T, J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.MutableAtomToken<T, J>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)

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

@@ -8,9 +8,9 @@ export function pullMutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
-	token: AtomIO.MutableAtomToken<T, J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.MutableAtomToken<T, J>,
 ): () => void {
 	const jsonToken = getJsonToken(store, token)
 	const updateToken = getUpdateToken(token)

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

@@ -8,9 +8,9 @@ import { pullMutableAtomFamilyMember } from "./pull-mutable-atom-family-member"
 /* eslint-disable no-console */
 
 export function pullSelectorFamilyMember<T>(
-	token: AtomIO.SelectorToken<T>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.SelectorToken<T>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)
@@ -26,11 +26,11 @@ export function pullSelectorFamilyMember<T>(
 			}
 			switch (atom.type) {
 				case `atom`: {
-					unsubscribes.push(pullAtomFamilyMember(atom, socket, store))
+					unsubscribes.push(pullAtomFamilyMember(store, socket, atom))
 					break
 				}
 				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtomFamilyMember(atom, socket, store))
+					unsubscribes.push(pullMutableAtomFamilyMember(store, socket, atom))
 					break
 				}
 			}

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

@@ -6,9 +6,9 @@ import { pullAtom } from "./pull-atom"
 import { pullMutableAtom } from "./pull-mutable-atom"
 
 export function pullSelector<T>(
-	token: AtomIO.SelectorToken<T>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.SelectorToken<T>,
 ): () => void {
 	const atomKeys = store.selectorAtoms.getRelatedKeys(token.key)
 	const unsubscribes: Array<() => void> = []
@@ -20,11 +20,11 @@ export function pullSelector<T>(
 			}
 			switch (atom.type) {
 				case `atom`: {
-					unsubscribes.push(pullAtom(atom, socket, store))
+					unsubscribes.push(pullAtom(store, socket, atom))
 					break
 				}
 				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtom(atom, socket, store))
+					unsubscribes.push(pullMutableAtom(store, socket, atom))
 					break
 				}
 			}

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

@@ -4,19 +4,14 @@ import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 export function pushState<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
-	socket: Socket,
 	store: Internal.Store,
+	socket: Socket,
+	token: AtomIO.WritableToken<J>,
 ): () => void {
 	socket.emit(`claim:${token.key}`)
-	Internal.subscribeToState(
-		token,
-		({ newValue }) => {
-			socket.emit(`pub:${token.key}`, newValue)
-		},
-		`push`,
-		store,
-	)
+	Internal.subscribeToState(store, token, `push`, ({ newValue }) => {
+		socket.emit(`pub:${token.key}`, newValue)
+	})
 	return () => {
 		socket.off(`pub:${token.key}`)
 		socket.emit(`unclaim:${token.key}`)

package/realtime-client/src/server-action.ts

@@ -3,17 +3,17 @@ import * as Internal from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
 export function serverAction<F extends Internal.Func>(
-	token: AtomIO.TransactionToken<F>,
-	socket: Socket,
 	store: Internal.Store,
+	socket: Socket,
+	token: AtomIO.TransactionToken<F>,
 ): () => void {
 	const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
+		store,
 		token,
+		`tx-run:${token.key}:${socket.id}`,
 		(clientUpdate) => {
 			socket.emit(`tx-run:${token.key}`, clientUpdate)
 		},
-		`tx-run:${token.key}:${socket.id}`,
-		store,
 	)
 
 	return () => {

package/realtime-client/src/sync-continuity.ts

@@ -20,9 +20,9 @@ import { useConcealState } from "./continuity/use-conceal-state"
 import { useRevealState } from "./continuity/use-reveal-state"
 
 export function syncContinuity(
-	continuity: ContinuityToken,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	continuity: ContinuityToken,
 ): () => void {
 	const continuityKey = continuity.key
 	const optimisticUpdates = getFromStore(store, optimisticUpdateQueue)
@@ -45,7 +45,7 @@ export function syncContinuity(
 			}
 			i++
 		}
-		setEpochNumberOfContinuity(continuityKey, epoch, store)
+		setEpochNumberOfContinuity(store, continuityKey, epoch)
 	}
 	socket.off(`continuity-init:${continuityKey}`)
 	socket.on(`continuity-init:${continuityKey}`, initializeContinuity)
@@ -61,9 +61,11 @@ export function syncContinuity(
 	socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate)
 
 	const unsubscribeFunctions = continuity.actions.map((transaction) => {
-		assignTransactionToContinuity(continuityKey, transaction.key, store)
+		assignTransactionToContinuity(store, continuityKey, transaction.key)
 		const unsubscribeFromTransactionUpdates = subscribeToTransaction(
+			store,
 			transaction,
+			`tx-run:${continuityKey}`,
 			(clientUpdate) => {
 				store.logger.info(
 					`🤞`,
@@ -104,8 +106,6 @@ export function syncContinuity(
 					params: clientUpdate.params,
 				})
 			},
-			`tx-run:${continuityKey}`,
-			store,
 		)
 		return unsubscribeFromTransactionUpdates
 	})

package/realtime-react/dist/index.js

@@ -1,155 +1,6 @@
+export { RealtimeContext, RealtimeProvider, usePullAtom, usePullAtomFamilyMember, usePullMutable, usePullMutableAtomFamilyMember, usePullSelector, usePullSelectorFamilyMember, usePush, useServerAction, useSyncContinuity } from '../../dist/chunk-KVI5OBF2.js';
+import '../../dist/chunk-3ZFTRSNG.js';
+import '../../dist/chunk-4LWKCEW3.js';
+import '../../dist/chunk-3PQTWLQQ.js';
+import '../../dist/chunk-UQEYZ3OI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { useI, StoreContext, useO } from 'atom.io/react';
-import * as RTC from 'atom.io/realtime-client';
-import { syncContinuity } from 'atom.io/realtime-client';
-import * as React from 'react';
-import { jsx } from 'react/jsx-runtime';
-import { findInStore, actUponStore, arbitrary } from 'atom.io/internal';
-
-var RealtimeContext = React.createContext({
-  socket: null,
-  services: null
-});
-var RealtimeProvider = ({ children, socket }) => {
-  const services = React.useRef(/* @__PURE__ */ new Map()).current;
-  const setMyId = useI(RTC.myIdState__INTERNAL);
-  React.useEffect(() => {
-    setMyId(socket?.id);
-    socket?.on(`connect`, () => {
-      setMyId(socket.id);
-    });
-    socket?.on(`disconnect`, () => {
-      setMyId(undefined);
-    });
-  }, [socket, setMyId]);
-  return /* @__PURE__ */ jsx(RealtimeContext.Provider, { value: { socket, services }, children });
-};
-var { NODE_ENV } = globalThis.env ?? {};
-var IN_DEV = NODE_ENV === `development`;
-function noop() {
-}
-function useSingleEffect(effect, deps) {
-  if (IN_DEV) {
-    const cleanup = React.useRef(noop);
-    React.useEffect(() => {
-      let dispose = cleanup.current;
-      if (dispose === noop) {
-        dispose = effect() ?? noop;
-        cleanup.current = dispose;
-      } else {
-        return () => {
-          dispose();
-          cleanup.current = noop;
-        };
-      }
-    }, deps);
-  } else {
-    React.useEffect(effect, deps);
-  }
-}
-
-// realtime-react/src/on-mount.ts
-function onMount(effect) {
-  useSingleEffect(effect, []);
-}
-
-// realtime-react/src/use-realtime-service.ts
-function useRealtimeService(key, create) {
-  const { socket, services } = React.useContext(RealtimeContext);
-  onMount(() => {
-    let service = services?.get(key);
-    if (service) {
-      service[0]++;
-    } else {
-      const dispose = socket ? create(socket) : undefined;
-      service = [1, dispose];
-      services?.set(key, service);
-    }
-    return () => {
-      if (service) {
-        service[0]--;
-        if (service[0] === 0) {
-          service[1]?.();
-          services?.delete(key);
-        }
-      }
-    };
-  });
-}
-
-// realtime-react/src/use-pull-atom.ts
-function usePullAtom(token) {
-  const store = React.useContext(StoreContext);
-  useRealtimeService(
-    `pull:${token.key}`,
-    (socket) => RTC.pullAtom(token, socket, store)
-  );
-  return useO(token);
-}
-function usePullAtomFamilyMember(family, subKey) {
-  const store = React.useContext(StoreContext);
-  const token = findInStore(store, family, subKey);
-  useRealtimeService(
-    `pull:${token.key}`,
-    (socket) => RTC.pullAtomFamilyMember(token, socket, store)
-  );
-  return useO(token);
-}
-function usePullMutable(token) {
-  const store = React.useContext(StoreContext);
-  useRealtimeService(
-    `pull:${token.key}`,
-    (socket) => RTC.pullMutableAtom(token, socket, store)
-  );
-  return useO(token);
-}
-function usePullMutableAtomFamilyMember(familyToken, key) {
-  const store = React.useContext(StoreContext);
-  const token = findInStore(store, familyToken, key);
-  useRealtimeService(
-    `pull:${token.key}`,
-    (socket) => RTC.pullMutableAtomFamilyMember(token, socket, store)
-  );
-  return useO(token);
-}
-function usePullSelector(token) {
-  const store = React.useContext(StoreContext);
-  useRealtimeService(
-    `pull:${token.key}`,
-    (socket) => RTC.pullSelector(token, socket, store)
-  );
-  return useO(token);
-}
-function usePullSelectorFamilyMember(familyToken, key) {
-  const store = React.useContext(StoreContext);
-  const token = findInStore(store, familyToken, key);
-  useRealtimeService(
-    `pull:${token.key}`,
-    (socket) => RTC.pullSelectorFamilyMember(token, socket, store)
-  );
-  return useO(token);
-}
-function usePush(token) {
-  const store = React.useContext(StoreContext);
-  useRealtimeService(
-    `push:${token.key}`,
-    (socket) => RTC.pushState(token, socket, store)
-  );
-  return useI(token);
-}
-function useServerAction(token) {
-  const store = React.useContext(StoreContext);
-  useRealtimeService(
-    `tx:${token.key}`,
-    (socket) => RTC.serverAction(token, socket, store)
-  );
-  return actUponStore(token, arbitrary(), store);
-}
-function useSyncContinuity(token) {
-  const store = React.useContext(StoreContext);
-  useRealtimeService(`tx-sync:${token.key}`, (socket) => {
-    return syncContinuity(token, socket, store);
-  });
-}
-
-export { RealtimeContext, RealtimeProvider, usePullAtom, usePullAtomFamilyMember, usePullMutable, usePullMutableAtomFamilyMember, usePullSelector, usePullSelectorFamilyMember, usePush, useServerAction, useSyncContinuity };

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

@@ -15,7 +15,7 @@ export function usePullAtomFamilyMember<
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, family, subKey)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullAtomFamilyMember(token, socket, store),
+		RTC.pullAtomFamilyMember(store, socket, token),
 	)
 	return useO(token)
 }

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

@@ -11,7 +11,7 @@ export function usePullAtom<J extends Json.Serializable>(
 ): J {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullAtom(token, socket, store),
+		RTC.pullAtom(store, socket, token),
 	)
 	return useO(token)
 }

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

@@ -13,7 +13,7 @@ export function usePullMutable<
 >(token: AtomIO.MutableAtomToken<T, J>): T {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullMutableAtom(token, socket, store),
+		RTC.pullMutableAtom(store, socket, token),
 	)
 	return useO(token)
 }

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

@@ -17,7 +17,7 @@ export function usePullMutableAtomFamilyMember<
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullMutableAtomFamilyMember(token, socket, store),
+		RTC.pullMutableAtomFamilyMember(store, socket, token),
 	)
 	return useO(token)
 }

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

@@ -15,7 +15,7 @@ export function usePullSelectorFamilyMember<
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullSelectorFamilyMember(token, socket, store),
+		RTC.pullSelectorFamilyMember(store, socket, token),
 	)
 	return useO(token)
 }

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

@@ -12,7 +12,7 @@ export function usePullSelector<J extends Json.Serializable>(
 ): J {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullSelector(token, socket, store),
+		RTC.pullSelector(store, socket, token),
 	)
 	return useO(token)
 }

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

@@ -11,7 +11,7 @@ export function usePush<J extends Json.Serializable>(
 ): <New extends J>(next: New | ((old: J) => New)) => void {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`push:${token.key}`, (socket) =>
-		RTC.pushState(token, socket, store),
+		RTC.pushState(store, socket, token),
 	)
 	return useI(token)
 }

package/realtime-react/src/use-server-action.ts

@@ -13,7 +13,7 @@ export function useServerAction<F extends Func>(
 	const store = React.useContext(StoreContext)
 
 	useRealtimeService(`tx:${token.key}`, (socket) =>
-		RTC.serverAction(token, socket, store),
+		RTC.serverAction(store, socket, token),
 	)
-	return actUponStore(token, arbitrary(), store)
+	return actUponStore(store, token, arbitrary())
 }

package/realtime-react/src/use-sync-continuity.ts

@@ -8,6 +8,6 @@ import { useRealtimeService } from "./use-realtime-service"
 export function useSyncContinuity(token: ContinuityToken): void {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`tx-sync:${token.key}`, (socket) => {
-		return syncContinuity(token, socket, store)
+		return syncContinuity(store, socket, token)
 	})
 }

package/realtime-server/dist/index.d.ts

@@ -3,9 +3,7 @@ import { Json, stringified, JsonIO, Canonical } from 'atom.io/json';
 import { ContinuityToken, UserInRoomMeta } from 'atom.io/realtime';
 import { ChildProcessWithoutNullStreams } from 'node:child_process';
 import * as AtomIO from 'atom.io';
-import { TransactionUpdateContent, TransactionUpdate, Hierarchy, WritableToken } from 'atom.io';
-import * as atom_io_data from 'atom.io/data';
-import { Loadable } from 'atom.io/data';
+import { Loadable, TransactionUpdateContent, TransactionUpdate, Hierarchy, WritableToken } from 'atom.io';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 type ExposeRealtimeContinuity = (continuity: ContinuityToken) => () => void;
@@ -117,7 +115,7 @@ type SocketSystemHierarchy = Hierarchy<[
 declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, `socket::${string}`>;
 declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<`socket::${string}`>, SetRTXJson<`socket::${string}`>>;
 declare const userIndex: AtomIO.MutableAtomToken<SetRTX<`user::${string}`>, SetRTXJson<`user::${string}`>>;
-declare const usersOfSockets: atom_io_data.JoinToken<"user", `user::${string}`, "socket", `socket::${string}`, "1:1", null>;
+declare const usersOfSockets: AtomIO.JoinToken<"user", `user::${string}`, "socket", `socket::${string}`, "1:1", null>;
 
 type StateProvider = ReturnType<typeof realtimeStateProvider>;
 declare function realtimeStateProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: AtomIO.WritableToken<J>) => () => void;