@pluv/client 0.17.3 → 0.19.0

package/src/PluvRoom.ts

@@ -1,8 +1,4 @@
-import type {
-    AbstractCrdtDoc,
-    AbstractCrdtType,
-    InferCrdtStorageJson,
-} from "@pluv/crdt";
+import type { AbstractCrdtDoc, AbstractCrdtType, InferCrdtStorageJson } from "@pluv/crdt";
 import type {
     BaseIOEventRecord,
     EventMessage,
@@ -17,7 +13,7 @@ import type {
     JsonObject,
 } from "@pluv/types";
 import { AbstractRoom } from "./AbstractRoom";
-import { AbstractStorageStore } from "./AbstractStorageStore";
+import type { AbstractStorageStore } from "./AbstractStorageStore";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
@@ -25,10 +21,7 @@ import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import { EventNotifier } from "./EventNotifier";
 import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
 import { OtherNotifier } from "./OtherNotifier";
-import type {
-    StateNotifierSubjects,
-    SubscriptionCallback,
-} from "./StateNotifier";
+import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
 import { StateNotifier } from "./StateNotifier";
 import { StorageStore } from "./StorageStore";
 import type { UsersManagerConfig } from "./UsersManager";
@@ -36,6 +29,7 @@ import { UsersManager } from "./UsersManager";
 import type {
     AuthorizationState,
     InternalSubscriptions,
+    UpdateMyPresenceAction,
     UserInfo,
     WebSocketConnection,
     WebSocketState,
@@ -89,10 +83,7 @@ interface TimeoutIds {
     reconnect: number | null;
 }
 
-export type AuthEndpoint =
-    | string
-    | ((room: string) => string | FetchOptions)
-    | true;
+export type AuthEndpoint = string | ((room: string) => string | FetchOptions) | true;
 export type WsEndpoint = string | ((room: string) => string);
 
 type FetchOptions = { url: string; options?: RequestInit };
@@ -111,9 +102,7 @@ export type PluvRoomAddon<
     TIO extends IOLike = IOLike,
     TPresence extends JsonObject = {},
     TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
-> = (
-    input: PluvRoomAddonInput<TIO, TPresence, TStorage>,
-) => Partial<PluvRoomAddonResult>;
+> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
 
 export interface PluvRoomAddonInput<
     TIO extends IOLike = IOLike,
@@ -220,10 +209,7 @@ export class PluvRoom<
         this._listeners = {
             onAuthorizationFail: (error) => {
                 this._clearTimeout(this._timeouts.reconnect);
-                this._timeouts.reconnect = setTimeout(
-                    this._reconnect.bind(this),
-                    RECONNECT_TIMEOUT_MS,
-                );
+                this._timeouts.reconnect = setTimeout(this._reconnect.bind(this), RECONNECT_TIMEOUT_MS);
 
                 onAuthorizationFail?.(error);
             },
@@ -247,17 +233,25 @@ export class PluvRoom<
         return this._state.webSocket;
     }
 
-    public broadcast<TEvent extends keyof InferIOInput<TIO>>(
-        event: TEvent,
-        data: Id<InferIOInput<TIO>[TEvent]>,
-    ): void {
-        if (!this._state.webSocket) return;
-        if (this._state.connection.state !== ConnectionState.Open) return;
+    public broadcast = new Proxy(
+        <TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void => {
+            if (!this._state.webSocket) return;
+            if (this._state.connection.state !== ConnectionState.Open) return;
 
-        const type = event.toString();
+            const type = event.toString();
 
-        this._sendMessage({ data, type });
-    }
+            this._sendMessage({ data, type });
+        },
+        {
+            get(fn, prop) {
+                return (data: Id<InferIOInput<TIO>[any]>): void => {
+                    return fn(prop, data);
+                };
+            },
+        },
+    ) as (<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>) => void) & {
+        [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => void;
+    };
 
     public canRedo = (): boolean => {
         return !!this._crdtManager.doc.canRedo();
@@ -272,10 +266,9 @@ export class PluvRoom<
             throw new Error("Must provide an wsEndpoint.");
         }
 
-        const canConnect = [
-            ConnectionState.Closed,
-            ConnectionState.Untouched,
-        ].some((state) => this._state.connection.state === state);
+        const canConnect = [ConnectionState.Closed, ConnectionState.Untouched].some(
+            (state) => this._state.connection.state === state,
+        );
 
         if (!canConnect) return;
 
@@ -298,8 +291,7 @@ export class PluvRoom<
         try {
             authToken = await this._getAuthorization(this.id);
 
-            authToken &&
-                url.searchParams.set("token", encodeURIComponent(authToken));
+            authToken && url.searchParams.set("token", encodeURIComponent(authToken));
 
             webSocket = new WebSocket(url.toString());
         } catch (err) {
@@ -328,10 +320,9 @@ export class PluvRoom<
 
         if (!this._state.webSocket) return;
 
-        const canDisconnect = [
-            ConnectionState.Connecting,
-            ConnectionState.Open,
-        ].some((state) => this._state.connection.state === state);
+        const canDisconnect = [ConnectionState.Connecting, ConnectionState.Open].some(
+            (state) => this._state.connection.state === state,
+        );
 
         if (!canDisconnect) return;
 
@@ -346,23 +337,31 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(null);
     }
 
-    public event = <TEvent extends keyof InferIOOutput<TIO>>(
+    public event = new Proxy(
+        <TEvent extends keyof InferIOOutput<TIO>>(
+            event: TEvent,
+            callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
+        ): (() => void) => this._eventNotifier.subscribe(event, callback),
+        {
+            get(fn, prop) {
+                return (callback: EventNotifierSubscriptionCallback<TIO, any>): (() => void) => fn(prop, callback);
+            },
+        },
+    ) as (<TEvent extends keyof InferIOOutput<TIO>>(
         event: TEvent,
         callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
-    ): (() => void) => {
-        return this._eventNotifier.subscribe(event, callback);
+    ) => () => void) & {
+        [event in keyof InferIOOutput<TIO>]: (callback: EventNotifierSubscriptionCallback<TIO, event>) => () => void;
     };
 
-    public getConnection(): WebSocketConnection {
+    public getConnection = (): WebSocketConnection => {
         // Create a read-only clone of the connection state
-        return Object.freeze(
-            JSON.parse(JSON.stringify(this._state.connection)),
-        );
-    }
+        return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
+    };
 
-    public getDoc(): AbstractCrdtDoc<TStorage> {
+    public getDoc = (): AbstractCrdtDoc<TStorage> => {
         return this._crdtManager.doc;
-    }
+    };
 
     public getMyPresence = (): TPresence => {
         return this._usersManager.myPresence;
@@ -372,9 +371,7 @@ export class PluvRoom<
         return this._usersManager.myself;
     };
 
-    public getOther = (
-        connectionId: string,
-    ): Id<UserInfo<TIO, TPresence>> | null => {
+    public getOther = (connectionId: string): Id<UserInfo<TIO, TPresence>> | null => {
         return this._usersManager.getOther(connectionId);
     };
 
@@ -382,9 +379,7 @@ export class PluvRoom<
         return this._usersManager.getOthers();
     };
 
-    public getStorage = <TKey extends keyof TStorage>(
-        key: TKey,
-    ): TStorage[TKey] | null => {
+    public getStorage = <TKey extends keyof TStorage>(key: TKey): TStorage[TKey] | null => {
         const sharedType = this._crdtManager.get(key);
 
         if (typeof sharedType === "undefined") return null;
@@ -392,10 +387,7 @@ export class PluvRoom<
         return sharedType;
     };
 
-    public other = (
-        connectionId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO>,
-    ): (() => void) => {
+    public other = (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): (() => void) => {
         return this._otherNotifier.subscribe(connectionId, callback);
     };
 
@@ -418,19 +410,14 @@ export class PluvRoom<
         return this._crdtNotifier.subcribeRoot(fn);
     };
 
-    public subscribe = <
-        TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-    >(
+    public subscribe = <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
         name: TSubject,
         callback: SubscriptionCallback<TIO, TPresence, TSubject>,
     ): (() => void) => {
         return this._stateNotifier.subscribe(name, callback);
     };
 
-    public transact = (
-        fn: (storage: TStorage) => void,
-        origin?: string,
-    ): void => {
+    public transact = (fn: (storage: TStorage) => void, origin?: string): void => {
         const _origin = origin ?? this._state.connection.id;
 
         /**
@@ -453,8 +440,10 @@ export class PluvRoom<
         this._crdtManager.doc.undo();
     };
 
-    public updateMyPresence = (presence: Partial<TPresence>): void => {
-        this._usersManager.updateMyPresence(presence);
+    public updateMyPresence = (presence: UpdateMyPresenceAction<TPresence>): void => {
+        const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+
+        this._usersManager.updateMyPresence(newPresence);
 
         const myPresence = this._usersManager.myPresence;
         const myself = this._usersManager.myself ?? null;
@@ -462,10 +451,7 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(myPresence);
         !!myself && this._stateNotifier.subjects["myself"].next(myself);
 
-        this.broadcast(
-            "$UPDATE_PRESENCE" as keyof InferIOInput<TIO>,
-            { presence } as any,
-        );
+        this.broadcast("$UPDATE_PRESENCE" as keyof InferIOInput<TIO>, { presence: newPresence } as any);
     };
 
     private async _addToStorageStore(update: string): Promise<void> {
@@ -499,14 +485,8 @@ export class PluvRoom<
             onVisibilityChange: this._onVisibilityChange.bind(this),
         };
 
-        window.addEventListener(
-            "online",
-            this._windowListeners.onNavigatorOnline,
-        );
-        document.addEventListener(
-            "visibilitychange",
-            this._windowListeners.onVisibilityChange,
-        );
+        window.addEventListener("online", this._windowListeners.onNavigatorOnline);
+        document.addEventListener("visibilitychange", this._windowListeners.onVisibilityChange);
     }
 
     private _attachWsListeners(): void {
@@ -519,22 +499,10 @@ export class PluvRoom<
             onOpen: this._onOpen.bind(this),
         };
 
-        this._state.webSocket.addEventListener(
-            "close",
-            this._wsListeners.onClose,
-        );
-        this._state.webSocket.addEventListener(
-            "error",
-            this._wsListeners.onError,
-        );
-        this._state.webSocket.addEventListener(
-            "message",
-            this._wsListeners.onMessage,
-        );
-        this._state.webSocket.addEventListener(
-            "open",
-            this._wsListeners.onOpen,
-        );
+        this._state.webSocket.addEventListener("close", this._wsListeners.onClose);
+        this._state.webSocket.addEventListener("error", this._wsListeners.onError);
+        this._state.webSocket.addEventListener("message", this._wsListeners.onMessage);
+        this._state.webSocket.addEventListener("open", this._wsListeners.onOpen);
     }
 
     private _clearInterval(interval: number | null) {
@@ -574,14 +542,8 @@ export class PluvRoom<
         if (typeof window === "undefined") return;
         if (typeof document === "undefined") return;
 
-        window.removeEventListener(
-            "online",
-            this._windowListeners.onNavigatorOnline,
-        );
-        document.removeEventListener(
-            "visibilitychange",
-            this._windowListeners.onVisibilityChange,
-        );
+        window.removeEventListener("online", this._windowListeners.onNavigatorOnline);
+        document.removeEventListener("visibilitychange", this._windowListeners.onVisibilityChange);
 
         this._windowListeners = null;
     }
@@ -589,22 +551,10 @@ export class PluvRoom<
     private _detachWsListeners(): void {
         if (!this._state.webSocket || !this._wsListeners) return;
 
-        this._state.webSocket.removeEventListener(
-            "close",
-            this._wsListeners.onClose,
-        );
-        this._state.webSocket.removeEventListener(
-            "error",
-            this._wsListeners.onError,
-        );
-        this._state.webSocket.removeEventListener(
-            "message",
-            this._wsListeners.onMessage,
-        );
-        this._state.webSocket.removeEventListener(
-            "open",
-            this._wsListeners.onOpen,
-        );
+        this._state.webSocket.removeEventListener("close", this._wsListeners.onClose);
+        this._state.webSocket.removeEventListener("error", this._wsListeners.onError);
+        this._state.webSocket.removeEventListener("message", this._wsListeners.onMessage);
+        this._state.webSocket.removeEventListener("open", this._wsListeners.onOpen);
 
         this._wsListeners = null;
     }
@@ -676,9 +626,7 @@ export class PluvRoom<
 
         const result = this._endpoints.authEndpoint(room);
 
-        return typeof result === "string"
-            ? { url: result, options: {} }
-            : result;
+        return typeof result === "string" ? { url: result, options: {} } : result;
     }
 
     private async _getAuthorization(room: string): Promise<string | null> {
@@ -697,9 +645,7 @@ export class PluvRoom<
         try {
             return await res.text().then((text) => text.trim());
         } catch (err) {
-            throw new Error(
-                err instanceof Error ? err.message : "Room is unauthorized",
-            );
+            throw new Error(err instanceof Error ? err.message : "Room is unauthorized");
         }
     }
 
@@ -737,14 +683,9 @@ export class PluvRoom<
         // Should not reach here
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
-        const data = message.data as BaseIOEventRecord<
-            InferIOAuthorize<TIO>
-        >["$PRESENCE_UPDATED"];
+        const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$PRESENCE_UPDATED"];
 
-        this._usersManager.patchPresence(
-            connectionId,
-            data.presence as TPresence,
-        );
+        this._usersManager.patchPresence(connectionId, data.presence as TPresence);
 
         const myPresence = this._usersManager.myPresence;
         const myself = this._usersManager.myself ?? null;
@@ -768,24 +709,16 @@ export class PluvRoom<
         // Should not reach here
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
-        const data = message.data as BaseIOEventRecord<
-            InferIOAuthorize<TIO>
-        >["$OTHERS_RECEIVED"];
+        const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$OTHERS_RECEIVED"];
 
         Object.keys(data.others).forEach((connectionId) => {
             const { presence, user } = data.others[connectionId];
 
-            if (!user) return;
-
             this._usersManager.setUser(connectionId, user);
 
             const other = this._usersManager.getOther(connectionId);
 
-            !!presence &&
-                this._usersManager.patchPresence(
-                    connectionId,
-                    presence as TPresence,
-                );
+            !!presence && this._usersManager.patchPresence(connectionId, presence as TPresence);
 
             this._otherNotifier.subject(connectionId).next(other);
         });
@@ -810,10 +743,7 @@ export class PluvRoom<
             return oldState;
         });
 
-        this._usersManager.setMyself(
-            connectionId,
-            user as Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>,
-        );
+        this._usersManager.setMyself(connectionId, user as Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>);
 
         const presence = this._usersManager.myPresence;
         const myself = this._usersManager.myself ?? null;
@@ -821,10 +751,7 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(presence);
         this._stateNotifier.subjects["myself"].next(myself);
 
-        const update =
-            this._state.connection.count > 1
-                ? this._crdtManager.doc.getEncodedState() ?? null
-                : null;
+        const update = this._state.connection.count > 1 ? this._crdtManager.doc.getEncodedState() ?? null : null;
 
         this._sendMessage({
             type: "$INITIALIZE_SESSION",
@@ -832,18 +759,14 @@ export class PluvRoom<
         });
     }
 
-    private async _handleStorageReceivedMessage(
-        message: IOEventMessage<TIO>,
-    ): Promise<void> {
+    private async _handleStorageReceivedMessage(message: IOEventMessage<TIO>): Promise<void> {
         const { connectionId } = message;
 
         if (!connectionId) return;
         // Should not reach here
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
-        const data = message.data as BaseIOEventRecord<
-            InferIOAuthorize<TIO>
-        >["$STORAGE_RECEIVED"];
+        const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$STORAGE_RECEIVED"];
 
         this._crdtManager.initialize({
             onInitialized: async (update) => {
@@ -878,9 +801,7 @@ export class PluvRoom<
         // Should not reach here
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
 
-        const data = message.data as BaseIOEventRecord<
-            InferIOAuthorize<TIO>
-        >[typeof ORIGIN_STORAGE_UPDATED];
+        const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>[typeof ORIGIN_STORAGE_UPDATED];
 
         if (!this._crdtManager) return;
 
@@ -917,9 +838,7 @@ export class PluvRoom<
         if (!this._state.webSocket) throw new Error("Could not find WebSocket");
         if (!this._usersManager.myself) return;
 
-        const data = message.data as BaseIOEventRecord<
-            InferIOAuthorize<TIO>
-        >["$USER_JOINED"];
+        const data = message.data as BaseIOEventRecord<InferIOAuthorize<TIO>>["$USER_JOINED"];
 
         const myself = this._usersManager.myself;
 
@@ -927,11 +846,7 @@ export class PluvRoom<
             this._sendMessage({ type: "$GET_OTHERS", data: {} });
         }
 
-        this._usersManager.setUser(
-            connectionId,
-            data.user,
-            data.presence as TPresence,
-        );
+        this._usersManager.setUser(connectionId, data.user, data.presence as TPresence);
 
         const other = this._usersManager.getOther(connectionId);
         const others = this._usersManager.getOthers();
@@ -942,10 +857,7 @@ export class PluvRoom<
 
     private _heartbeat(): void {
         this._clearTimeout(this._timeouts.pong);
-        this._timeouts.pong = setTimeout(
-            this._reconnect.bind(this),
-            PONG_TIMEOUT_MS,
-        );
+        this._timeouts.pong = setTimeout(this._reconnect.bind(this), PONG_TIMEOUT_MS);
 
         this._sendMessage({ type: "$PING", data: {} });
     }
@@ -968,10 +880,7 @@ export class PluvRoom<
             this._addToStorageStore(event.update);
             this._emitSharedTypes();
 
-            if (
-                origin === ORIGIN_INITIALIZED ||
-                origin === ORIGIN_STORAGE_UPDATED
-            ) {
+            if (origin === ORIGIN_INITIALIZED || origin === ORIGIN_STORAGE_UPDATED) {
                 return;
             }
 
@@ -989,8 +898,7 @@ export class PluvRoom<
     }
 
     private _onAuthorizationFail(error: unknown): void {
-        const authError =
-            error instanceof Error ? error : new Error("Authorization failed");
+        const authError = error instanceof Error ? error : new Error("Authorization failed");
 
         this._listeners.onAuthorizationFail(authError);
 
@@ -1040,17 +948,13 @@ export class PluvRoom<
         if (!message) return;
 
         const shouldLog =
-            typeof this._debug === "boolean"
-                ? this._debug
-                : this._debug.output.find((value) => value === message.type);
+            typeof this._debug === "boolean" ? this._debug : this._debug.output.find((value) => value === message.type);
 
         if (shouldLog) {
             this._logDebug("WebSocket event received: ", message.type, message);
         }
 
-        this._eventNotifier
-            .subject(message.type as keyof InferIOOutput<TIO>)
-            .next(message as any);
+        this._eventNotifier.subject(message.type as keyof InferIOOutput<TIO>).next(message as any);
 
         const { connectionId } = message;
 
@@ -1105,10 +1009,7 @@ export class PluvRoom<
         });
 
         this._clearInterval(this._intervals.heartbeat);
-        this._intervals.heartbeat = setInterval(
-            this._heartbeat.bind(this),
-            HEARTBEAT_INTERVAL_MS,
-        );
+        this._intervals.heartbeat = setInterval(this._heartbeat.bind(this), HEARTBEAT_INTERVAL_MS);
     }
 
     private async _onNavigatorOnline(): Promise<void> {
@@ -1137,9 +1038,7 @@ export class PluvRoom<
         }
     }
 
-    private _parseMessage(message: {
-        data: string | ArrayBuffer;
-    }): IOEventMessage<TIO> | null {
+    private _parseMessage(message: { data: string | ArrayBuffer }): IOEventMessage<TIO> | null {
         /**
          * !HACK
          * @description We'll only handle stringified JSONs for now
@@ -1181,17 +1080,13 @@ export class PluvRoom<
         await this.connect();
     }
 
-    private _sendMessage<
-        TMessage extends EventMessage<string, any> = EventMessage<string, any>,
-    >(data: TMessage): void {
+    private _sendMessage<TMessage extends EventMessage<string, any> = EventMessage<string, any>>(data: TMessage): void {
         const webSocket = this._state.webSocket;
 
         if (webSocket?.readyState !== WebSocket.OPEN) return;
 
         const shouldLog =
-            typeof this._debug === "boolean"
-                ? this._debug
-                : this._debug.input.find((value) => value === data.type);
+            typeof this._debug === "boolean" ? this._debug : this._debug.input.find((value) => value === data.type);
 
         if (shouldLog) {
             this._logDebug("WebSocket event sent: ", data.type, data);
@@ -1200,15 +1095,11 @@ export class PluvRoom<
         webSocket.send(JSON.stringify(data));
     }
 
-    private _updateState(
-        updater: (oldState: WebSocketState<TIO>) => WebSocketState<TIO>,
-    ): WebSocketState<TIO> {
+    private _updateState(updater: (oldState: WebSocketState<TIO>) => WebSocketState<TIO>): WebSocketState<TIO> {
         let authorization: AuthorizationState<TIO>;
 
         try {
-            authorization = JSON.parse(
-                JSON.stringify(this._state.authorization),
-            );
+            authorization = JSON.parse(JSON.stringify(this._state.authorization));
         } catch {
             throw new Error("User is not JSON serializable");
         }

package/src/StateNotifier.ts

@@ -3,10 +3,7 @@ import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
 import type { UserInfo, WebSocketState } from "./types";
 
-export interface StateNotifierSubjects<
-    TIO extends IOLike,
-    TPresence extends JsonObject,
-> {
+export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
     connection: Subject<Id<WebSocketState<TIO>>>;
     "my-presence": Subject<TPresence | null>;
     myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
@@ -18,12 +15,7 @@ type InferSubjectValue<
     TIO extends IOLike,
     TPresence extends JsonObject,
     TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-> =
-    StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<
-        infer IValue
-    >
-        ? Id<IValue>
-        : never;
+> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
 
 export type SubscriptionCallback<
     TIO extends IOLike,
@@ -31,10 +23,7 @@ export type SubscriptionCallback<
     TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
 > = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
 
-export class StateNotifier<
-    TIO extends IOLike,
-    TPresence extends JsonObject = {},
-> {
+export class StateNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
     public subjects: StateNotifierSubjects<TIO, TPresence> = {
         connection: makeSubject<Id<WebSocketState<TIO>>>(),
         "my-presence": makeSubject<TPresence>(),
@@ -43,9 +32,7 @@ export class StateNotifier<
         "storage-loaded": makeSubject<true>(),
     };
 
-    public subscribe<
-        TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-    >(
+    public subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
         name: TSubject,
         callback: SubscriptionCallback<TIO, TPresence, TSubject>,
     ): () => void {