@pluv/client 0.17.3 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/client",
-  "version": "0.17.3",
+  "version": "0.19.0",
   "description": "@pluv/io frontend client",
   "author": "leedavidcs",
   "license": "MIT",
@@ -18,15 +18,15 @@
   },
   "dependencies": {
     "wonka": "^6.3.4",
-    "@pluv/crdt": "^0.17.3",
-    "@pluv/types": "^0.17.3"
+    "@pluv/crdt": "^0.19.0",
+    "@pluv/types": "^0.19.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "tsup": "^8.0.2",
+    "tsup": "^8.1.0",
     "typescript": "^5.4.5",
-    "@pluv/tsconfig": "^0.17.3",
-    "eslint-config-pluv": "^0.17.3"
+    "@pluv/tsconfig": "^0.19.0",
+    "eslint-config-pluv": "^0.19.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/AbstractRoom.ts

@@ -1,22 +1,9 @@
-import type {
-    AbstractCrdtDoc,
-    AbstractCrdtType,
-    InferCrdtStorageJson,
-} from "@pluv/crdt";
-import type {
-    IOLike,
-    Id,
-    InferIOInput,
-    InferIOOutput,
-    JsonObject,
-} from "@pluv/types";
+import type { AbstractCrdtDoc, AbstractCrdtType, InferCrdtStorageJson } from "@pluv/crdt";
+import type { IOLike, Id, InferIOInput, InferIOOutput, JsonObject } from "@pluv/types";
 import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
-import type {
-    StateNotifierSubjects,
-    SubscriptionCallback,
-} from "./StateNotifier";
-import type { UserInfo, WebSocketConnection } from "./types";
+import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
+import type { UpdateMyPresenceAction, UserInfo, WebSocketConnection } from "./types";
 
 export abstract class AbstractRoom<
     TIO extends IOLike,
@@ -53,20 +40,13 @@ export abstract class AbstractRoom<
 
     public abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
 
-    public abstract getOther(
-        connectionId: string,
-    ): Id<UserInfo<TIO, TPresence>> | null;
+    public abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
 
     public abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
 
-    public abstract getStorage<TKey extends keyof TStorage>(
-        key: TKey,
-    ): TStorage[TKey] | null;
+    public abstract getStorage<TKey extends keyof TStorage>(key: TKey): TStorage[TKey] | null;
 
-    public abstract other(
-        connectionId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO>,
-    ): () => void;
+    public abstract other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): () => void;
 
     public abstract redo(): void;
 
@@ -81,19 +61,14 @@ export abstract class AbstractRoom<
         }) => void,
     ): () => void;
 
-    public abstract subscribe<
-        TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-    >(
+    public abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
         name: TSubject,
         callback: SubscriptionCallback<TIO, TPresence, TSubject>,
     ): () => void;
 
-    public abstract transact(
-        fn: (storage: TStorage) => void,
-        origin?: string,
-    ): void;
+    public abstract transact(fn: (storage: TStorage) => void, origin?: string): void;
 
     public abstract undo(): void;
 
-    public abstract updateMyPresence(presence: Partial<TPresence>): void;
+    public abstract updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
 }

package/src/CrdtManager.ts

@@ -1,13 +1,7 @@
-import type {
-    AbstractCrdtDoc,
-    AbstractCrdtDocFactory,
-    AbstractCrdtType,
-} from "@pluv/crdt";
+import type { AbstractCrdtDoc, AbstractCrdtDocFactory, AbstractCrdtType } from "@pluv/crdt";
 import { noop } from "@pluv/crdt";
 
-export type CrdtManagerOptions<
-    TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
-> = {
+export type CrdtManagerOptions<TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> = {
     encodedState?: string | Uint8Array | null;
     initialStorage?: AbstractCrdtDocFactory<TStorage>;
 };
@@ -18,26 +12,19 @@ type CrdtManagerInitializeParams = {
     update: string | readonly string[];
 };
 
-export class CrdtManager<
-    TStorage extends Record<string, AbstractCrdtType<any, any>>,
-> {
+export class CrdtManager<TStorage extends Record<string, AbstractCrdtType<any, any>>> {
     public doc: AbstractCrdtDoc<TStorage>;
     public initialized: boolean = false;
 
     private readonly _docFactory: AbstractCrdtDocFactory<TStorage>;
 
     constructor(options: CrdtManagerOptions<TStorage>) {
-        const {
-            encodedState,
-            initialStorage = noop.doc({}) as AbstractCrdtDocFactory<TStorage>,
-        } = options;
+        const { encodedState, initialStorage = noop.doc({}) as AbstractCrdtDocFactory<TStorage> } = options;
 
         this._docFactory = initialStorage;
 
         this.doc = encodedState
-            ? initialStorage
-                  .getFresh()
-                  .applyEncodedState({ update: encodedState })
+            ? initialStorage.getFresh().applyEncodedState({ update: encodedState })
             : initialStorage.getFresh();
     }
 
@@ -50,8 +37,7 @@ export class CrdtManager<
     public applyUpdate(update: string | readonly string[], origin?: any): this {
         if (!this.initialized) return this;
 
-        const updates: readonly string[] =
-            typeof update === "string" ? [update] : update;
+        const updates: readonly string[] = typeof update === "string" ? [update] : update;
 
         this._applyDocUpdates(this.doc, updates, origin);
 
@@ -79,20 +65,12 @@ export class CrdtManager<
             return this;
         }
 
-        const onEmpty = this._applyDocUpdates(
-            this._docFactory.getEmpty(),
-            updates,
-            origin,
-        );
+        const onEmpty = this._applyDocUpdates(this._docFactory.getEmpty(), updates, origin);
 
         if (!onEmpty.isEmpty()) {
             onEmpty.destroy();
 
-            this.doc = this._applyDocUpdates(
-                this._docFactory.getFresh(),
-                updates,
-                origin,
-            ).track();
+            this.doc = this._applyDocUpdates(this._docFactory.getFresh(), updates, origin).track();
             this.initialized = true;
 
             onInitialized?.(this.doc.getEncodedState());
@@ -115,9 +93,7 @@ export class CrdtManager<
         origin?: string,
     ): AbstractCrdtDoc<TStorage> {
         doc.transact(() => {
-            doc.batchApplyEncodedState(
-                updates.map((update) => ({ origin, update })),
-            );
+            doc.batchApplyEncodedState(updates.map((update) => ({ origin, update })));
         }, origin);
 
         return doc;

package/src/CrdtNotifier.ts

@@ -1,21 +1,15 @@
 import type { AbstractCrdtType, InferCrdtStorageJson } from "@pluv/crdt";
-import { makeSubject, Subject, subscribe } from "wonka";
+import type { Subject } from "wonka";
+import { makeSubject, subscribe } from "wonka";
 
-export class CrdtNotifier<
-    TStorage extends Record<string, AbstractCrdtType<any, any>>,
-> {
+export class CrdtNotifier<TStorage extends Record<string, AbstractCrdtType<any, any>>> {
     public rootSubject = makeSubject<{
         [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
     }>();
 
-    public subjects = new Map<
-        keyof TStorage,
-        Subject<InferCrdtStorageJson<TStorage[keyof TStorage]>> | null
-    >();
+    public subjects = new Map<keyof TStorage, Subject<InferCrdtStorageJson<TStorage[keyof TStorage]>> | null>();
 
-    public subject<TKey extends keyof TStorage>(
-        key: TKey,
-    ): Subject<InferCrdtStorageJson<TStorage[TKey]>> {
+    public subject<TKey extends keyof TStorage>(key: TKey): Subject<InferCrdtStorageJson<TStorage[TKey]>> {
         const subject = this.subjects.get(key);
 
         if (subject) {

package/src/EventNotifier.ts

@@ -2,20 +2,14 @@ import type { Id, InferIOOutput, IOEventMessage, IOLike } from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
 
-export type EventNotifierSubscriptionCallback<
-    TIO extends IOLike,
-    TEvent extends keyof InferIOOutput<TIO>,
-> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+export type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (
+    value: Id<IOEventMessage<TIO, TEvent>>,
+) => void;
 
 export class EventNotifier<TIO extends IOLike> {
-    public subjects = new Map<
-        keyof InferIOOutput<TIO>,
-        Subject<Id<IOEventMessage<TIO, keyof InferIOOutput<TIO>>>>
-    >();
+    public subjects = new Map<keyof InferIOOutput<TIO>, Subject<Id<IOEventMessage<TIO, keyof InferIOOutput<TIO>>>>>();
 
-    public subject<TEvent extends keyof InferIOOutput<TIO>>(
-        name: TEvent,
-    ): Subject<Id<IOEventMessage<TIO, TEvent>>> {
+    public subject<TEvent extends keyof InferIOOutput<TIO>>(name: TEvent): Subject<Id<IOEventMessage<TIO, TEvent>>> {
         const subject = this.subjects.get(name);
 
         if (subject) return subject;

package/src/MockedRoom.ts

@@ -1,15 +1,5 @@
-import type {
-    AbstractCrdtDoc,
-    AbstractCrdtType,
-    InferCrdtStorageJson,
-} from "@pluv/crdt";
-import type {
-    IOLike,
-    Id,
-    InferIOInput,
-    InferIOOutput,
-    JsonObject,
-} from "@pluv/types";
+import type { AbstractCrdtDoc, AbstractCrdtType, InferCrdtStorageJson } from "@pluv/crdt";
+import type { IOLike, Id, InferIOInput, InferIOOutput, JsonObject } from "@pluv/types";
 import { AbstractRoom } from "./AbstractRoom";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
@@ -18,15 +8,13 @@ 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 type { UsersManagerConfig } from "./UsersManager";
 import { UsersManager } from "./UsersManager";
 import type {
     InternalSubscriptions,
+    UpdateMyPresenceAction,
     UserInfo,
     WebSocketConnection,
     WebSocketState,
@@ -34,19 +22,14 @@ import type {
 import { ConnectionState } from "./types";
 
 export type MockedRoomEvents<TIO extends IOLike> = Partial<{
-    [P in keyof InferIOInput<TIO>]: (
-        data: Id<InferIOInput<TIO>[P]>,
-    ) => Partial<InferIOOutput<TIO>>;
+    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
 }>;
 
 export type MockedRoomConfig<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
     TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
-> = { events?: MockedRoomEvents<TIO> } & Omit<
-    CrdtManagerOptions<TStorage>,
-    "encodedState"
-> &
+> = { events?: MockedRoomEvents<TIO> } & Omit<CrdtManagerOptions<TStorage>, "encodedState"> &
     UsersManagerConfig<TPresence>;
 
 export class MockedRoom<
@@ -77,10 +60,7 @@ export class MockedRoom<
     };
     private _usersManager: UsersManager<TIO, TPresence>;
 
-    constructor(
-        room: string,
-        options: MockedRoomConfig<TIO, TPresence, TStorage>,
-    ) {
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>) {
         const { events, initialPresence, initialStorage, presence } = options;
 
         super(room);
@@ -103,10 +83,7 @@ export class MockedRoom<
         return true;
     }
 
-    public broadcast<TEvent extends keyof InferIOInput<TIO>>(
-        event: TEvent,
-        data: Id<InferIOInput<TIO>[TEvent]>,
-    ): void {
+    public broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void {
         if (!this._events) return;
 
         const resolver = this._events[event];
@@ -140,12 +117,10 @@ export class MockedRoom<
         return this._eventNotifier.subscribe(event, callback);
     };
 
-    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> {
         return this._crdtManager.doc;
@@ -159,9 +134,7 @@ export class MockedRoom<
         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);
     };
 
@@ -169,9 +142,7 @@ export class MockedRoom<
         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;
@@ -179,10 +150,7 @@ export class MockedRoom<
         return sharedType.value;
     };
 
-    public other = (
-        connectionId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO>,
-    ): (() => void) => {
+    public other = (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): (() => void) => {
         return this._otherNotifier.subscribe(connectionId, callback);
     };
 
@@ -205,19 +173,14 @@ export class MockedRoom<
         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;
         const crdtManager = this._crdtManager;
 
@@ -242,8 +205,10 @@ export class MockedRoom<
         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;

package/src/OtherNotifier.ts

@@ -3,16 +3,12 @@ import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
 import type { UserInfo } from "./types";
 
-export type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (
-    value: Id<UserInfo<TIO>> | null,
-) => void;
+export type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
 
 export class OtherNotifier<TIO extends IOLike> {
     public subjects = new Map<string, Subject<Id<UserInfo<TIO>> | null>>();
 
-    public subject<TEvent extends string>(
-        name: TEvent,
-    ): Subject<Id<UserInfo<TIO>> | null> {
+    public subject<TEvent extends string>(name: TEvent): Subject<Id<UserInfo<TIO>> | null> {
         const subject = this.subjects.get(name);
 
         if (subject) return subject;

package/src/PluvClient.ts

@@ -1,13 +1,6 @@
 import type { AbstractCrdtType } from "@pluv/crdt";
 import type { IOLike, JsonObject } from "@pluv/types";
-import {
-    AuthEndpoint,
-    PluvRoom,
-    PluvRoomOptions,
-    RoomConfig,
-    RoomEndpoints,
-    WsEndpoint,
-} from "./PluvRoom";
+import { AuthEndpoint, PluvRoom, PluvRoomOptions, RoomConfig, RoomEndpoints, WsEndpoint } from "./PluvRoom";
 
 export type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO> & {
     debug?: boolean;
@@ -56,9 +49,7 @@ export class PluvClient<TIO extends IOLike = IOLike> {
         return newRoom;
     };
 
-    public enter = async (
-        room: string | PluvRoom<TIO, any, any>,
-    ): Promise<PluvRoom<TIO, JsonObject, any>> => {
+    public enter = async (room: string | PluvRoom<TIO, any, any>): Promise<PluvRoom<TIO, JsonObject, any>> => {
         const toEnter = typeof room === "string" ? this.getRoom(room) : room;
 
         if (!toEnter) {
@@ -80,9 +71,7 @@ export class PluvClient<TIO extends IOLike = IOLike> {
     >(
         room: string,
     ): PluvRoom<TIO, TPresence, TStorage> | null => {
-        const found = this._rooms.get(room) as
-            | PluvRoom<TIO, TPresence, TStorage>
-            | undefined;
+        const found = this._rooms.get(room) as PluvRoom<TIO, TPresence, TStorage> | undefined;
 
         return found ?? null;
     };
@@ -91,9 +80,7 @@ export class PluvClient<TIO extends IOLike = IOLike> {
         return Array.from(this._rooms.values());
     };
 
-    public leave = async (
-        room: string | PluvRoom<TIO, any, any>,
-    ): Promise<void> => {
+    public leave = async (room: string | PluvRoom<TIO, any, any>): Promise<void> => {
         const toLeave = typeof room === "string" ? this.getRoom(room) : room;
 
         if (!toLeave) return;