atom.io 0.31.0 → 0.32.0

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.d.ts

@@ -1,9 +1,5 @@
 import * as React from 'react';
 import { Socket } from 'socket.io-client';
-import * as AtomIO from 'atom.io';
-import { Json, Canonical } from 'atom.io/json';
-import { Transceiver, Func } from 'atom.io/internal';
-import { ContinuityToken } from 'atom.io/realtime';
 
 type RealtimeReactStore = {
     socket: Socket | null;
@@ -18,21 +14,179 @@ declare const RealtimeProvider: React.FC<{
     socket: Socket | null;
 }>;
 
-declare function usePullAtom<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>): J;
+type primitive = boolean | number | string | null;
+declare namespace Json {
+    namespace Tree {
+        type Array<Element = unknown> = ReadonlyArray<Element>;
+        type Object<K extends string = string, V = unknown> = Record<K, V>;
+        type Fork = Array | Object;
+        type Leaf = primitive;
+        type Node = Fork | Leaf;
+    }
+    type Serializable = primitive | Readonly<{
+        [key: string]: Serializable;
+    }> | ReadonlyArray<Serializable>;
+    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+}
+type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : string & {
+    __json?: J;
+};
+type Canonical = primitive | ReadonlyArray<Canonical>;
+
+type Func = (...parameters: any[]) => any;
 
-declare function usePullAtomFamilyMember<J extends Json.Serializable, K extends Canonical, Key extends K>(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: Key): J;
+interface Transceiver<S extends Json.Serializable> {
+    do: (update: S) => number | `OUT_OF_RANGE` | null;
+    undo: (update: S) => void;
+    subscribe: (key: string, fn: (update: S) => void) => () => void;
+    cacheUpdateNumber: number;
+    getUpdateNumber: (update: S) => number;
+}
 
-declare function usePullMutable<T extends Transceiver<any>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>): T;
+type RegularAtomFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `atom_family`;
+    __T?: T;
+    __K?: K;
+};
+type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
+    key: string;
+    type: `mutable_atom_family`;
+    __T?: T;
+    __J?: J;
+    __K?: K;
+};
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
 
-declare function usePullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T;
+type TransactionToken<F extends Func> = {
+    key: string;
+    type: `transaction`;
+    __F?: F;
+};
 
-declare function usePullSelector<J extends Json.Serializable>(token: AtomIO.SelectorToken<J>): J;
+type WritableSelectorFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `selector_family`;
+    __T?: T;
+    __K?: K;
+};
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `readonly_selector_family`;
+    __T?: T;
+    __K?: K;
+};
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
 
-declare function usePullSelectorFamilyMember<T, K extends Canonical, Key extends K>(familyToken: AtomIO.SelectorFamilyToken<T, K>, key: Key): T;
+type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
 
-declare function usePush<J extends Json.Serializable>(token: AtomIO.WritableToken<J>): <New extends J>(next: New | ((old: J) => New)) => void;
+/** @public */
+type RegularAtomToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
+    key: string;
+    /** Discriminator. */
+    type: `atom`;
+    /** Present if the atom belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the atom's value. */
+    __T?: T;
+};
+/** @public */
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
+    key: string;
+    /** Discriminator. */
+    type: `mutable_atom`;
+    /** Present if the atom belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+    __J?: J;
+    /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+    __U?: T extends Transceiver<infer Update> ? Update : never;
+};
+/** @public */
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+/** @public */
+type WritableSelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
+    key: string;
+    /** Discriminator. */
+    type: `selector`;
+    /** Present if the selector belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
+    __T?: T;
+};
+/** @public */
+type ReadonlySelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
+    key: string;
+    /** Discriminator. */
+    type: `readonly_selector`;
+    /** Present if the selector belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
+    __T?: T;
+};
+/** @public */
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states can be set.
+ */
+type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states cannot be set.
+ */
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
+/**
+ * @public
+ * States belonging to this family cannot be set.
+ */
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+ * @public
+ * Identifies a state's connection to its family.
+ */
+type FamilyMetadata<K extends Canonical = any> = {
+    /** The family's unique key. */
+    key: string;
+    /** The family member's unique identifier, in the form of a string. */
+    subKey: stringified<K>;
+};
 
-declare function useServerAction<F extends Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
+declare function usePullAtom<J extends Json.Serializable>(token: RegularAtomToken<J>): J;
+
+declare function usePullAtomFamilyMember<J extends Json.Serializable, K extends Canonical, Key extends K>(family: RegularAtomFamilyToken<J, K>, subKey: Key): J;
+
+declare function usePullMutable<T extends Transceiver<any>, J extends Json.Serializable>(token: MutableAtomToken<T, J>): T;
+
+declare function usePullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(familyToken: MutableAtomFamilyToken<T, J, K>, key: Key): T;
+
+declare function usePullSelector<J extends Json.Serializable>(token: SelectorToken<J>): J;
+
+declare function usePullSelectorFamilyMember<T, K extends Canonical, Key extends K>(familyToken: SelectorFamilyToken<T, K>, key: Key): T;
+
+declare function usePush<J extends Json.Serializable>(token: WritableToken<J>): <New extends J>(next: New | ((old: J) => New)) => void;
+
+declare function useServerAction<F extends Func>(token: TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
+
+type UserKey = `user::${string}`;
+
+type PerspectiveToken<F extends AtomFamilyToken<any>> = {
+    type: `realtime_perspective`;
+    resourceAtoms: F;
+    viewAtoms: ReadableFamilyToken<ReadableToken<TokenType<F>>[], UserKey>;
+};
+type ContinuityToken = {
+    readonly type: `continuity`;
+    readonly key: string;
+    readonly globals: AtomToken<any>[];
+    readonly actions: TransactionToken<any>[];
+    readonly perspectives: PerspectiveToken<AtomFamilyToken<any, Canonical>>[];
+};
 
 declare function useSyncContinuity(token: ContinuityToken): void;
 

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-354XQWHH.js';
+import '../../dist/chunk-Z2UJW4NQ.js';
+import '../../dist/chunk-4LWKCEW3.js';
+import '../../dist/chunk-5F2V7S3B.js';
+import '../../dist/chunk-GY2XQYZY.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)
 	})
 }