@pluv/io 2.1.0 → 2.2.1

package/dist/index.js

@@ -655,6 +655,7 @@ var IORoom = class {
             this._listeners.onUserDisconnected({
               context: this._context,
               encodedState,
+              platform: this._platform,
               room: this.id,
               user
             })
@@ -712,6 +713,7 @@ var IORoom = class {
           this._listeners.onUserConnected({
             context: this._context,
             encodedState,
+            platform: this._platform,
             room: this.id,
             user,
             webSocket: pluvWs.webSocket
@@ -875,6 +877,7 @@ var IORoom = class {
           this._listeners.onDestroy(__spreadProps(__spreadValues({}, "_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {}), {
             context: this._context,
             encodedState,
+            platform: this._platform,
             room: this.id
           }))
         );
@@ -913,6 +916,7 @@ var IORoom = class {
         garbageCollect: () => __async(this, null, function* () {
           yield this.garbageCollect();
         }),
+        platform: this._platform,
         get presence() {
           return session.presence;
         },
@@ -939,6 +943,7 @@ var IORoom = class {
         context: this._context,
         encodedState: doc.getEncodedState(),
         message,
+        platform: this._platform,
         room: this.id,
         user: session.user,
         webSocket: session.webSocket.webSocket
@@ -1105,6 +1110,7 @@ var IORoom = class {
         garbageCollect: () => __async(this, null, function* () {
           yield this.garbageCollect();
         }),
+        platform: this._platform,
         get presence() {
           return null;
         },
@@ -1156,14 +1162,56 @@ var pickBy = (obj, by) => {
 };
 
 // src/version.generated.ts
-var version = "2.1.0";
+var version = "2.2.1";
 
 // src/PluvServer.ts
 var PluvServer = class {
   constructor(options) {
     this.version = version;
-    this._authorize = null;
-    this._baseRouter = new PluvRouter({
+    this._config = __spreadValues({
+      crdt: import_crdt2.noop,
+      debug: false,
+      router: new PluvRouter({})
+    }, options);
+    const {
+      onRoomDeleted,
+      onRoomMessage,
+      onStorageUpdated,
+      onUserConnected,
+      onUserDisconnected
+    } = options;
+    this._listeners = {
+      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
+      onRoomMessage: (event) => onRoomMessage == null ? void 0 : onRoomMessage(event),
+      onStorageUpdated: (event) => onStorageUpdated == null ? void 0 : onStorageUpdated(event),
+      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
+      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
+    };
+  }
+  get fetch() {
+    const platform = this._config.platform();
+    return (...args) => {
+      if (!platform._fetch)
+        throw new Error(`\`${platform._name}\` does not support \`fetch\``);
+      return platform._fetch(...args);
+    };
+  }
+  /**
+   * @ignore
+   * @readonly
+   * @deprecated Internal use only. Changes to this will never be marked as breaking.
+   */
+  get _defs() {
+    return {
+      authorize: this._config.authorize,
+      context: this._config.context,
+      events: this._router._defs.events,
+      platform: this._config.platform()
+    };
+  }
+  get _baseRouter() {
+    const listeners = this._getListeners();
+    return new PluvRouter({
       $getOthers: this._procedure.sync((data, { room, session, sessions }) => {
         const currentTime = Date.now();
         const others = sessions.filter((wsSession) => {
@@ -1198,46 +1246,54 @@ var PluvServer = class {
             timers: { presence: timers.presence }
           }
         };
-      }).self((_0, _1) => __async(this, [_0, _1], function* (data, { context, doc, room, session }) {
-        var _a;
-        const oldState = yield this._platform.persistence.getStorageState(room);
+      }).self((_0, _1) => __async(this, [_0, _1], function* (data, { context, doc, platform, room, session }) {
+        var _a, _b;
+        const oldState = yield platform.persistence.getStorageState(room);
         const update = data == null ? void 0 : data.update;
         if (!oldState) {
-          const loadedState = yield (_a = this._getInitialStorage) == null ? void 0 : _a.call(this, { context, room });
+          const loadedState = yield (_b = (_a = this._config).getInitialStorage) == null ? void 0 : _b.call(_a, {
+            context,
+            room
+          });
           if (!!loadedState) {
             doc.applyEncodedState({ update: loadedState }).getEncodedState();
           }
         }
         if (!doc.isEmpty()) {
           const encodedState2 = doc.getEncodedState();
-          return { $storageReceived: { changeKind: "unchanged", state: encodedState2 } };
+          return {
+            $storageReceived: { changeKind: "unchanged", state: encodedState2 }
+          };
         }
         if (!!update) {
           const encodedState2 = doc.applyEncodedState({ update }).getEncodedState();
           const storageSize = new TextEncoder().encode(encodedState2).length;
-          if (!!this._limits.storageMaxSize && storageSize > this._limits.storageMaxSize) {
+          if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) {
             throw new Error("Storage has exceeded the size limit");
           }
-          yield this._platform.persistence.setStorageState(room, encodedState2).catch((error) => {
+          yield platform.persistence.setStorageState(room, encodedState2).catch((error) => {
             this._logDebug(error);
           });
-          this._getListeners().onStorageUpdated({
+          listeners.onStorageUpdated({
             context,
             encodedState: encodedState2,
+            platform,
             room,
             user: session == null ? void 0 : session.user,
             webSocket: session == null ? void 0 : session.webSocket.webSocket
           });
-          return { $storageReceived: { changeKind: "initialized", state: encodedState2 } };
+          return {
+            $storageReceived: { changeKind: "initialized", state: encodedState2 }
+          };
         }
         const encodedState = doc.getEncodedState();
         return { $storageReceived: { changeKind: "empty", state: encodedState } };
       })),
-      $ping: this._procedure.self((data, { session }) => {
+      $ping: this._procedure.self((data, { platform, session }) => {
         if (!session) return {};
         const currentTime = (/* @__PURE__ */ new Date()).getTime();
         const prevState = session.webSocket.state;
-        this._platform.setSerializedState(session.webSocket, __spreadProps(__spreadValues({}, prevState), {
+        platform.setSerializedState(session.webSocket, __spreadProps(__spreadValues({}, prevState), {
           timers: __spreadProps(__spreadValues({}, prevState.timers), {
             ping: currentTime
           })
@@ -1248,10 +1304,13 @@ var PluvServer = class {
         const presence = data == null ? void 0 : data.presence;
         const { session } = context;
         if (!session) return {};
-        const cleanedPatch = pickBy(presence != null ? presence : {}, (value) => typeof value !== "undefined");
+        const cleanedPatch = pickBy(
+          presence != null ? presence : {},
+          (value) => typeof value !== "undefined"
+        );
         const updated = Object.assign(/* @__PURE__ */ Object.create(null), session.presence, cleanedPatch);
         const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
-        if (!!this._limits.presenceMaxSize && bytes > this._limits.presenceMaxSize) {
+        if (!!this._config.limits.presenceMaxSize && bytes > this._config.limits.presenceMaxSize) {
           throw new Error(
             `Large presence. Presence must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
           );
@@ -1264,7 +1323,7 @@ var PluvServer = class {
           }
         };
       }),
-      $updateStorage: this._procedure.broadcast((data, { context, doc, room }) => {
+      $updateStorage: this._procedure.broadcast((data, { context, doc, platform, room }) => {
         var _a;
         const origin = data == null ? void 0 : data.origin;
         const update = (_a = data == null ? void 0 : data.update) != null ? _a : null;
@@ -1272,113 +1331,72 @@ var PluvServer = class {
         const updated = update === null ? doc : doc.applyEncodedState({ update });
         const encodedState = updated.getEncodedState();
         const storageSize = new TextEncoder().encode(encodedState).length;
-        if (!!this._limits.storageMaxSize && storageSize > this._limits.storageMaxSize) {
+        if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) {
           throw new Error("Storage has exceeded the size limit");
         }
-        this._platform.persistence.setStorageState(room, encodedState).then(() => {
-          this._getListeners().onStorageUpdated({
+        platform.persistence.setStorageState(room, encodedState).then(() => {
+          listeners.onStorageUpdated({
             context,
             encodedState,
+            platform,
             room
           });
         });
         return { $storageUpdated: { state: encodedState } };
       })
     });
-    this._context = {};
-    this._getInitialStorage = null;
-    const {
-      authorize: authorize2,
-      context,
-      crdt = import_crdt2.noop,
-      debug = false,
-      getInitialStorage,
-      io,
-      limits,
-      platform,
-      router = new PluvRouter({})
-    } = options;
-    const {
-      onRoomDeleted,
-      onRoomMessage,
-      onStorageUpdated,
-      onUserConnected,
-      onUserDisconnected
-    } = options;
-    platform.validateConfig(options);
-    this._crdt = crdt;
-    this._debug = debug;
-    this._io = io;
-    this._limits = limits;
-    this._platform = platform;
-    this._router = router ? PluvRouter.merge(this._baseRouter, router) : this._baseRouter;
-    if (authorize2) this._authorize = authorize2;
-    if (context) this._context = context;
-    if (getInitialStorage) this._getInitialStorage = getInitialStorage;
-    this._listeners = {
-      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
-      onRoomMessage: (event) => onRoomMessage == null ? void 0 : onRoomMessage(event),
-      onStorageUpdated: (event) => onStorageUpdated == null ? void 0 : onStorageUpdated(event),
-      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
-      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
-    };
-  }
-  get fetch() {
-    return (...args) => {
-      if (!this._platform._fetch)
-        throw new Error(`\`${this._platform._name}\` does not support \`fetch\``);
-      return this._platform._fetch(...args);
-    };
-  }
-  /**
-   * @ignore
-   * @readonly
-   * @deprecated Internal use only. Changes to this will never be marked as breaking.
-   */
-  get _defs() {
-    return {
-      authorize: this._authorize,
-      context: this._context,
-      events: this._router._defs.events,
-      platform: this._platform
-    };
   }
   get _procedure() {
     return new PluvProcedure();
   }
+  get _router() {
+    return this._config.router ? PluvRouter.merge(this._baseRouter, this._config.router) : this._baseRouter;
+  }
   createRoom(room, ...options) {
     var _a, _c;
     const _b = (_a = options[0]) != null ? _a : {}, { _meta, debug, onDestroy, onMessage } = _b, platformRoomContext = __objRest(_b, ["_meta", "debug", "onDestroy", "onMessage"]);
-    if (this._platform._config.handleMode !== "io") {
-      throw new Error(`\`createRoom\` is unsupported for \`${this._platform._name}\``);
+    const platform = this._config.platform();
+    platform.validateConfig(this._config);
+    if (platform._config.handleMode !== "io") {
+      throw new Error(`\`createRoom\` is unsupported for \`${platform._name}\``);
     }
     if (!/^[a-z0-9](?:[a-z0-9-_]*[a-z0-9])?$/i.test(room))
       throw new Error("Unsupported room name");
     const roomContext = platformRoomContext;
-    const context = typeof this._context === "function" ? this._context(roomContext) : this._context;
+    const context = typeof this._config.context === "function" ? this._config.context(roomContext) : this._config.context;
+    const listeners = this._getListeners();
+    const logDebug = this._logDebug.bind(this);
     const newRoom = new IORoom(room, __spreadProps(__spreadValues({}, !!_meta ? { _meta } : {}), {
-      authorize: (_c = this._authorize) != null ? _c : void 0,
+      authorize: (_c = this._config.authorize) != null ? _c : void 0,
       context,
-      crdt: this._crdt,
-      debug: debug != null ? debug : this._debug,
-      onDestroy: (event) => __async(this, null, function* () {
-        this._logDebug(`${import_kleur2.default.blue("Deleting empty room:")} ${room}`);
-        yield Promise.resolve(onDestroy == null ? void 0 : onDestroy(event));
-        yield Promise.resolve(this._getListeners().onRoomDeleted(event));
-        yield this._platform.persistence.deleteStorageState(room);
-        this._logDebug(`${import_kleur2.default.blue("Deleted room:")} ${room}`);
-      }),
-      onMessage: (event) => __async(this, null, function* () {
-        yield Promise.resolve(onMessage == null ? void 0 : onMessage(event));
-        yield Promise.resolve(this._getListeners().onRoomMessage(event));
-      }),
-      onUserConnected: (event) => __async(this, null, function* () {
-        yield Promise.resolve(this._getListeners().onUserConnected(event));
-      }),
-      onUserDisconnected: (event) => __async(this, null, function* () {
-        yield Promise.resolve(this._getListeners().onUserDisconnected(event));
-      }),
-      platform: this._platform,
+      crdt: this._config.crdt,
+      debug: debug != null ? debug : this._config.debug,
+      onDestroy(event) {
+        return __async(this, null, function* () {
+          logDebug(`${import_kleur2.default.blue("Deleting empty room:")} ${room}`);
+          yield Promise.resolve(onDestroy == null ? void 0 : onDestroy(event));
+          yield Promise.resolve(listeners.onRoomDeleted(event));
+          yield event.platform.persistence.deleteStorageState(room);
+          logDebug(`${import_kleur2.default.blue("Deleted room:")} ${room}`);
+        });
+      },
+      onMessage(event) {
+        return __async(this, null, function* () {
+          yield Promise.resolve(onMessage == null ? void 0 : onMessage(event));
+          yield Promise.resolve(listeners.onRoomMessage(event));
+        });
+      },
+      onUserConnected(event) {
+        return __async(this, null, function* () {
+          yield Promise.resolve(listeners.onUserConnected(event));
+        });
+      },
+      onUserDisconnected(event) {
+        return __async(this, null, function* () {
+          yield Promise.resolve(listeners.onUserDisconnected(event));
+        });
+      },
+      platform,
       roomContext,
       router: this._router
     }));
@@ -1387,14 +1405,14 @@ var PluvServer = class {
   }
   createToken(params) {
     return __async(this, null, function* () {
-      return yield this._io.createToken(params);
+      return yield this._config.io.createToken(params);
     });
   }
   _getListeners() {
     return this._listeners;
   }
   _logDebug(...data) {
-    if (this._debug) console.log(...data);
+    if (this._config.debug) console.log(...data);
   }
 };
 
@@ -1439,10 +1457,13 @@ var PluvIO = class {
           `createToken called with large payload. User must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
         );
       }
-      if (this._platform._createToken) return yield this._platform._createToken(params);
+      const platform = this._platform();
+      if (platform._createToken) {
+        return yield platform._createToken(__spreadProps(__spreadValues({}, params), { authorize: ioAuthorize }));
+      }
       const secret = (_a = ioAuthorize == null ? void 0 : ioAuthorize.secret) != null ? _a : null;
       if (!secret) throw new Error("`authorize` was specified without a valid secret");
-      return yield authorize({ platform: this._platform, secret }).encode(
+      return yield authorize({ platform, secret }).encode(
         params
       );
     });