@pluv/client 0.25.4 → 0.26.0

package/dist/index.mjs

@@ -199,6 +199,31 @@ var StateNotifier = class {
   }
 };
 
+// src/StorageStore.ts
+var StorageStore = class extends AbstractStorageStore {
+  addUpdate() {
+    return Promise.resolve();
+  }
+  applyUpdates() {
+    return Promise.resolve();
+  }
+  destroy() {
+    return Promise.resolve();
+  }
+  flatten() {
+    return Promise.resolve();
+  }
+  getShouldFlatten() {
+    return Promise.resolve(false);
+  }
+  getUpdates() {
+    return Promise.resolve([]);
+  }
+  initialize() {
+    return Promise.resolve();
+  }
+};
+
 // src/UsersManager.ts
 var UsersManager = class {
   constructor(config) {
@@ -302,179 +327,6 @@ var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
   return ConnectionState2;
 })(ConnectionState || {});
 
-// src/MockedRoom.ts
-var MockedRoom = class extends AbstractRoom {
-  constructor(room, options) {
-    const { events, initialPresence, initialStorage, presence } = options;
-    super(room);
-    this._crdtNotifier = new CrdtNotifier();
-    this._eventNotifier = new EventNotifier();
-    this._otherNotifier = new OtherNotifier();
-    this._state = {
-      authorization: {
-        token: null,
-        user: null
-      },
-      connection: {
-        count: 1,
-        id: null,
-        state: "Untouched" /* Untouched */
-      },
-      webSocket: null
-    };
-    this._stateNotifier = new StateNotifier();
-    this._subscriptions = {
-      observeCrdt: null
-    };
-    this.canRedo = () => {
-      return !!this._crdtManager.doc.canRedo();
-    };
-    this.canUndo = () => {
-      return !!this._crdtManager.doc.canUndo();
-    };
-    this.event = (event, callback) => {
-      return this._eventNotifier.subscribe(event, callback);
-    };
-    this.getConnection = () => {
-      return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
-    };
-    this.getMyPresence = () => {
-      return this._usersManager.myPresence;
-    };
-    this.getMyself = () => {
-      return this._usersManager.myself;
-    };
-    this.getOther = (connectionId) => {
-      return this._usersManager.getOther(connectionId);
-    };
-    this.getOthers = () => {
-      return this._usersManager.getOthers();
-    };
-    this.getStorage = (type) => {
-      const sharedType = this._crdtManager.get(type);
-      if (typeof sharedType === "undefined") return null;
-      return sharedType;
-    };
-    this.other = (connectionId, callback) => {
-      return this._otherNotifier.subscribe(connectionId, callback);
-    };
-    this.redo = () => {
-      this._crdtManager.doc.redo();
-    };
-    this.storage = (key, fn) => {
-      return this._crdtNotifier.subscribe(key, fn);
-    };
-    this.storageRoot = (fn) => {
-      return this._crdtNotifier.subcribeRoot(fn);
-    };
-    this.subscribe = (name, callback) => {
-      return this._stateNotifier.subscribe(name, callback);
-    };
-    this.transact = (fn, origin) => {
-      const _origin = origin != null ? origin : this._state.connection.id;
-      const crdtManager = this._crdtManager;
-      if (typeof _origin !== "string") return;
-      if (!crdtManager) return;
-      crdtManager.doc.transact(() => {
-        const storage = crdtManager.doc.get();
-        fn(storage);
-      }, _origin);
-    };
-    this.undo = () => {
-      this._crdtManager.doc.undo();
-    };
-    this.updateMyPresence = (presence) => {
-      var _a;
-      const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
-      this._usersManager.updateMyPresence(newPresence);
-      const myPresence = this._usersManager.myPresence;
-      const myself = (_a = this._usersManager.myself) != null ? _a : null;
-      this._stateNotifier.subjects["my-presence"].next(myPresence);
-      !!myself && this._stateNotifier.subjects["myself"].next(myself);
-    };
-    this._events = events;
-    this._usersManager = new UsersManager({
-      initialPresence,
-      presence
-    });
-    this._crdtManager = new CrdtManager({
-      initialStorage
-    });
-    this._observeCrdt();
-  }
-  get storageLoaded() {
-    return true;
-  }
-  broadcast(event, data) {
-    if (!this._events) return;
-    const resolver = this._events[event];
-    if (!resolver) return;
-    const result = resolver(data);
-    Object.keys(result).forEach((type) => {
-      const _type = type.toString();
-      const data2 = result[_type];
-      if (!data2) return;
-      this._eventNotifier.subject(_type).next(data2);
-    });
-  }
-  getDoc() {
-    return this._crdtManager.doc;
-  }
-  getStorageJson(type) {
-    if (this._state.connection.id === null) return null;
-    if (typeof type === "undefined") return this._crdtManager.doc.toJson();
-    return this._crdtManager.doc.toJson(type);
-  }
-  _observeCrdt() {
-    var _a, _b;
-    (_b = (_a = this._subscriptions).observeCrdt) == null ? void 0 : _b.call(_a);
-    if (!this._crdtManager) return;
-    const unsubscribe = this._crdtManager.doc.subscribe((event) => {
-      var _a2;
-      const origin = (_a2 = event.origin) != null ? _a2 : null;
-      if (!this._crdtManager) return;
-      if (origin === "$STORAGE_UPDATED") return;
-      const sharedTypes = this._crdtManager.doc.get();
-      const storageRoot = Object.keys(sharedTypes).reduce(
-        (acc, prop) => {
-          if (!this._crdtManager) return acc;
-          const serialized = this._crdtManager.doc.toJson(prop);
-          this._crdtNotifier.subject(prop).next(serialized);
-          return __spreadProps(__spreadValues({}, acc), { [prop]: serialized });
-        },
-        {}
-      );
-      this._crdtNotifier.rootSubject.next(storageRoot);
-    });
-    this._subscriptions.observeCrdt = unsubscribe;
-  }
-};
-
-// src/StorageStore.ts
-var StorageStore = class extends AbstractStorageStore {
-  addUpdate() {
-    return Promise.resolve();
-  }
-  applyUpdates() {
-    return Promise.resolve();
-  }
-  destroy() {
-    return Promise.resolve();
-  }
-  flatten() {
-    return Promise.resolve();
-  }
-  getShouldFlatten() {
-    return Promise.resolve(false);
-  }
-  getUpdates() {
-    return Promise.resolve([]);
-  }
-  initialize() {
-    return Promise.resolve();
-  }
-};
-
 // src/utils/debounce.ts
 var debounce = (fn, options) => {
   const { wait, immediate = false } = options != null ? options : {};
@@ -512,6 +364,7 @@ var PluvRoom = class extends AbstractRoom {
       debug = false,
       initialPresence,
       initialStorage,
+      metadata,
       onAuthorizationFail,
       presence,
       wsEndpoint
@@ -522,6 +375,7 @@ var PluvRoom = class extends AbstractRoom {
     this._intervals = {
       heartbeat: null
     };
+    this._metadata = {};
     this._otherNotifier = new OtherNotifier();
     this._state = {
       authorization: {
@@ -652,9 +506,10 @@ var PluvRoom = class extends AbstractRoom {
     };
     const addon = this._getAddon(addons);
     const { storage } = __spreadValues(__spreadValues({}, DEFAULT_PLUV_CLIENT_ADDON({ room: this })), addon({ room: this }));
-    this._storageStore = storage;
     this._debug = debug;
     this._endpoints = { authEndpoint, wsEndpoint };
+    this._storageStore = storage;
+    if (!!metadata) this._metadata = metadata;
     this._listeners = {
       onAuthorizationFail: (error) => {
         this._clearTimeout(this._timeouts.reconnect);
@@ -846,7 +701,7 @@ var PluvRoom = class extends AbstractRoom {
         options: {}
       };
     }
-    const result = this._endpoints.authEndpoint(room);
+    const result = this._endpoints.authEndpoint({ metadata: this._metadata, room });
     return typeof result === "string" ? { url: result, options: {} } : result;
   }
   _getAuthorization(room) {
@@ -872,7 +727,7 @@ var PluvRoom = class extends AbstractRoom {
       case "string":
         return this._endpoints.wsEndpoint;
       default:
-        return this._endpoints.wsEndpoint(room);
+        return this._endpoints.wsEndpoint({ metadata: this._metadata, room });
     }
   }
   _handleExit(message) {
@@ -1231,6 +1086,7 @@ var PluvClient = class {
         debug: options.debug,
         initialPresence: options.initialPresence,
         initialStorage: options.initialStorage,
+        metadata: options.metadata,
         onAuthorizationFail: options.onAuthorizationFail,
         wsEndpoint: this._wsEndpoint
       });
@@ -1240,9 +1096,7 @@ var PluvClient = class {
     };
     this.enter = (room) => __async(this, null, function* () {
       const toEnter = typeof room === "string" ? this.getRoom(room) : room;
-      if (!toEnter) {
-        throw new Error(`Could not find room: ${room}.`);
-      }
+      if (!toEnter) throw new Error(`Could not find room: ${room}.`);
       this._rooms.set(toEnter.id, toEnter);
       yield toEnter.connect();
       this._logDebug(`Entered room: ${room}`);
@@ -1278,6 +1132,154 @@ var PluvClient = class {
 var createClient = (options) => {
   return new PluvClient(options);
 };
+
+// src/MockedRoom.ts
+var MockedRoom = class extends AbstractRoom {
+  constructor(room, options) {
+    const { events, initialPresence, initialStorage, presence } = options;
+    super(room);
+    this._crdtNotifier = new CrdtNotifier();
+    this._eventNotifier = new EventNotifier();
+    this._otherNotifier = new OtherNotifier();
+    this._state = {
+      authorization: {
+        token: null,
+        user: null
+      },
+      connection: {
+        count: 1,
+        id: null,
+        state: "Untouched" /* Untouched */
+      },
+      webSocket: null
+    };
+    this._stateNotifier = new StateNotifier();
+    this._subscriptions = {
+      observeCrdt: null
+    };
+    this.canRedo = () => {
+      return !!this._crdtManager.doc.canRedo();
+    };
+    this.canUndo = () => {
+      return !!this._crdtManager.doc.canUndo();
+    };
+    this.event = (event, callback) => {
+      return this._eventNotifier.subscribe(event, callback);
+    };
+    this.getConnection = () => {
+      return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
+    };
+    this.getMyPresence = () => {
+      return this._usersManager.myPresence;
+    };
+    this.getMyself = () => {
+      return this._usersManager.myself;
+    };
+    this.getOther = (connectionId) => {
+      return this._usersManager.getOther(connectionId);
+    };
+    this.getOthers = () => {
+      return this._usersManager.getOthers();
+    };
+    this.getStorage = (type) => {
+      const sharedType = this._crdtManager.get(type);
+      if (typeof sharedType === "undefined") return null;
+      return sharedType;
+    };
+    this.other = (connectionId, callback) => {
+      return this._otherNotifier.subscribe(connectionId, callback);
+    };
+    this.redo = () => {
+      this._crdtManager.doc.redo();
+    };
+    this.storage = (key, fn) => {
+      return this._crdtNotifier.subscribe(key, fn);
+    };
+    this.storageRoot = (fn) => {
+      return this._crdtNotifier.subcribeRoot(fn);
+    };
+    this.subscribe = (name, callback) => {
+      return this._stateNotifier.subscribe(name, callback);
+    };
+    this.transact = (fn, origin) => {
+      const _origin = origin != null ? origin : this._state.connection.id;
+      const crdtManager = this._crdtManager;
+      if (typeof _origin !== "string") return;
+      if (!crdtManager) return;
+      crdtManager.doc.transact(() => {
+        const storage = crdtManager.doc.get();
+        fn(storage);
+      }, _origin);
+    };
+    this.undo = () => {
+      this._crdtManager.doc.undo();
+    };
+    this.updateMyPresence = (presence) => {
+      var _a;
+      const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+      this._usersManager.updateMyPresence(newPresence);
+      const myPresence = this._usersManager.myPresence;
+      const myself = (_a = this._usersManager.myself) != null ? _a : null;
+      this._stateNotifier.subjects["my-presence"].next(myPresence);
+      !!myself && this._stateNotifier.subjects["myself"].next(myself);
+    };
+    this._events = events;
+    this._usersManager = new UsersManager({
+      initialPresence,
+      presence
+    });
+    this._crdtManager = new CrdtManager({
+      initialStorage
+    });
+    this._observeCrdt();
+  }
+  get storageLoaded() {
+    return true;
+  }
+  broadcast(event, data) {
+    if (!this._events) return;
+    const resolver = this._events[event];
+    if (!resolver) return;
+    const result = resolver(data);
+    Object.keys(result).forEach((type) => {
+      const _type = type.toString();
+      const data2 = result[_type];
+      if (!data2) return;
+      this._eventNotifier.subject(_type).next(data2);
+    });
+  }
+  getDoc() {
+    return this._crdtManager.doc;
+  }
+  getStorageJson(type) {
+    if (this._state.connection.id === null) return null;
+    if (typeof type === "undefined") return this._crdtManager.doc.toJson();
+    return this._crdtManager.doc.toJson(type);
+  }
+  _observeCrdt() {
+    var _a, _b;
+    (_b = (_a = this._subscriptions).observeCrdt) == null ? void 0 : _b.call(_a);
+    if (!this._crdtManager) return;
+    const unsubscribe = this._crdtManager.doc.subscribe((event) => {
+      var _a2;
+      const origin = (_a2 = event.origin) != null ? _a2 : null;
+      if (!this._crdtManager) return;
+      if (origin === "$STORAGE_UPDATED") return;
+      const sharedTypes = this._crdtManager.doc.get();
+      const storageRoot = Object.keys(sharedTypes).reduce(
+        (acc, prop) => {
+          if (!this._crdtManager) return acc;
+          const serialized = this._crdtManager.doc.toJson(prop);
+          this._crdtNotifier.subject(prop).next(serialized);
+          return __spreadProps(__spreadValues({}, acc), { [prop]: serialized });
+        },
+        {}
+      );
+      this._crdtNotifier.rootSubject.next(storageRoot);
+    });
+    this._subscriptions.observeCrdt = unsubscribe;
+  }
+};
 export {
   AbstractRoom,
   AbstractStorageStore,

package/package.json

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

package/src/PluvClient.ts

@@ -3,42 +3,43 @@ import type { IOLike, JsonObject } from "@pluv/types";
 import type { AuthEndpoint, PluvRoomOptions, RoomConfig, RoomEndpoints, WsEndpoint } from "./PluvRoom";
 import { PluvRoom } from "./PluvRoom";
 
-export type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO> & {
+export type PluvClientOptions<TIO extends IOLike, TMetadata extends JsonObject> = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
 };
 
-export class PluvClient<TIO extends IOLike = IOLike> {
-    private _authEndpoint: AuthEndpoint | undefined;
+export class PluvClient<TIO extends IOLike = IOLike, TMetadata extends JsonObject = {}> {
+    private _authEndpoint: AuthEndpoint<TMetadata> | undefined;
     private _debug: boolean;
-    private _wsEndpoint: WsEndpoint | undefined;
+    private _wsEndpoint: WsEndpoint<TMetadata> | undefined;
 
-    private _rooms = new Map<string, PluvRoom<TIO, any, any>>();
+    private _rooms = new Map<string, PluvRoom<TIO, TMetadata, any, any>>();
 
-    constructor(options: PluvClientOptions<TIO>) {
+    constructor(options: PluvClientOptions<TIO, TMetadata>) {
         const { authEndpoint, debug = false, wsEndpoint } = options;
 
-        this._authEndpoint = authEndpoint as AuthEndpoint;
+        this._authEndpoint = authEndpoint as AuthEndpoint<TMetadata>;
         this._debug = debug;
         this._wsEndpoint = wsEndpoint;
     }
 
     public createRoom = <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(
         room: string,
-        options: PluvRoomOptions<TIO, TPresence, TStorage>,
-    ): PluvRoom<TIO, TPresence, TStorage> => {
+        options: PluvRoomOptions<TIO, TMetadata, TPresence, TStorage>,
+    ): PluvRoom<TIO, TMetadata, TPresence, TStorage> => {
         const oldRoom = this.getRoom<TPresence, TStorage>(room);
 
         if (oldRoom) return oldRoom;
 
-        const newRoom = new PluvRoom<TIO, TPresence, TStorage>(room, {
+        const newRoom = new PluvRoom<TIO, TMetadata, TPresence, TStorage>(room, {
             addons: options.addons,
             authEndpoint: this._authEndpoint,
             debug: options.debug,
             initialPresence: options.initialPresence,
             initialStorage: options.initialStorage,
+            metadata: options.metadata,
             onAuthorizationFail: options.onAuthorizationFail,
             wsEndpoint: this._wsEndpoint,
-        } as RoomConfig<TIO, TPresence, TStorage>);
+        } as RoomConfig<TIO, TMetadata, TPresence, TStorage>);
 
         this._rooms.set(room, newRoom);
 
@@ -47,12 +48,12 @@ 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, any>,
+    ): Promise<PluvRoom<TIO, TMetadata, JsonObject, any>> => {
         const toEnter = typeof room === "string" ? this.getRoom(room) : room;
 
-        if (!toEnter) {
-            throw new Error(`Could not find room: ${room}.`);
-        }
+        if (!toEnter) throw new Error(`Could not find room: ${room}.`);
 
         this._rooms.set(toEnter.id, toEnter);
 
@@ -65,17 +66,17 @@ export class PluvClient<TIO extends IOLike = IOLike> {
 
     public getRoom = <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(
         room: string,
-    ): PluvRoom<TIO, TPresence, TStorage> | null => {
-        const found = this._rooms.get(room) as PluvRoom<TIO, TPresence, TStorage> | undefined;
+    ): PluvRoom<TIO, TMetadata, TPresence, TStorage> | null => {
+        const found = this._rooms.get(room) as PluvRoom<TIO, TMetadata, TPresence, TStorage> | undefined;
 
         return found ?? null;
     };
 
-    public getRooms = (): readonly PluvRoom<TIO, JsonObject, any>[] => {
+    public getRooms = (): readonly PluvRoom<TIO, TMetadata, JsonObject, any>[] => {
         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, any>): Promise<void> => {
         const toLeave = typeof room === "string" ? this.getRoom(room) : room;
 
         if (!toLeave) return;