@pluv/io 0.0.0

package/dist/index.mjs

@@ -0,0 +1,857 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/AbstractPersistance.ts
+var AbstractPersistance = class {
+};
+
+// src/Persistance.ts
+var Persistance = class extends AbstractPersistance {
+  constructor() {
+    super(...arguments);
+    this._storages = /* @__PURE__ */ new Map();
+    this._users = /* @__PURE__ */ new Map();
+  }
+  addUser(room, connectionId, user) {
+    var _a;
+    const users = (_a = this._users.get(room)) != null ? _a : /* @__PURE__ */ new Map();
+    this._users.set(room, users);
+    users.set(connectionId, user);
+    return Promise.resolve();
+  }
+  deleteStorageState(room) {
+    this._storages.delete(room);
+    return Promise.resolve();
+  }
+  deleteUser(room, connectionId) {
+    return __async(this, null, function* () {
+      const users = this._users.get(room);
+      if (!users)
+        return;
+      users.delete(connectionId);
+      if (!users.size) {
+        yield this.deleteUsers(room);
+        yield this.deleteStorageState(room);
+      }
+      return Promise.resolve();
+    });
+  }
+  deleteUsers(room) {
+    this._users.delete(room);
+    return Promise.resolve();
+  }
+  getStorageState(room) {
+    var _a;
+    const storage = (_a = this._storages.get(room)) != null ? _a : null;
+    return Promise.resolve(storage);
+  }
+  getUser(room, connectionId) {
+    var _a;
+    const user = (_a = this._users.get(room)) == null ? void 0 : _a.get(connectionId);
+    return Promise.resolve(user != null ? user : null);
+  }
+  getUsers(room) {
+    const users = this._users.get(room);
+    if (!users)
+      return Promise.resolve([]);
+    return Promise.resolve(Array.from(users.values()));
+  }
+  setStorageState(room, state) {
+    this._storages.set(room, state);
+    return Promise.resolve();
+  }
+};
+
+// src/PubSub.ts
+import { makeSubject, subscribe } from "wonka";
+
+// src/AbstractPubSub.ts
+var AbstractPubSub = class {
+};
+
+// src/PubSub.ts
+var PubSub = class extends AbstractPubSub {
+  constructor() {
+    super(...arguments);
+    this._currentSubscriptionId = 0;
+    this._subjects = /* @__PURE__ */ new Map();
+    this._subscriptionsRefs = /* @__PURE__ */ new Map();
+    this._unsubscriptions = /* @__PURE__ */ new Map();
+  }
+  publish(roomName, payload) {
+    return __async(this, null, function* () {
+      const subject = this._subjects.get(roomName);
+      if (!subject)
+        return;
+      Promise.resolve(subject.next(payload));
+    });
+  }
+  subscribe(roomName, onMessage) {
+    var _a;
+    const id = this._currentSubscriptionId++;
+    const refs = (_a = this._subscriptionsRefs.get(roomName)) != null ? _a : [];
+    const subject = makeSubject();
+    this._subjects.set(roomName, subject);
+    this._subscriptionsRefs.set(roomName, [...refs, id]);
+    const unsubscribe = subscribe(onMessage)(subject.source).unsubscribe;
+    this._unsubscriptions.set(id, [roomName, unsubscribe]);
+    return Promise.resolve(id);
+  }
+  unsubscribe(subscriptionId) {
+    var _a;
+    const [roomName, unsubscribe] = (_a = this._unsubscriptions.get(subscriptionId)) != null ? _a : [];
+    if (!roomName || !unsubscribe)
+      return;
+    const refs = this._subscriptionsRefs.get(roomName);
+    if (!refs)
+      return;
+    if (refs.length === 1) {
+      this._subjects.delete(roomName);
+      this._subscriptionsRefs.delete(roomName);
+      this._unsubscriptions.delete(subscriptionId);
+      return;
+    }
+    const index = refs.indexOf(subscriptionId);
+    this._subscriptionsRefs.set(
+      roomName,
+      index === -1 ? refs : [...refs.slice(0, index), ...refs.slice(index + 1)]
+    );
+    unsubscribe();
+    this._unsubscriptions.delete(subscriptionId);
+  }
+};
+
+// src/AbstractPlatform.ts
+var AbstractPlatform = class {
+  constructor(config = {}) {
+    const { persistance, pubSub } = config;
+    this.persistance = persistance != null ? persistance : new Persistance();
+    this.pubSub = pubSub != null ? pubSub : new PubSub();
+  }
+};
+
+// src/AbstractWebSocket.ts
+var AbstractWebSocket = class {
+  constructor(config) {
+    this.CONNECTING = 0;
+    this.OPEN = 1;
+    this.CLOSING = 2;
+    this.CLOSED = 3;
+    const { room } = config;
+    this.room = room;
+  }
+  handleError(params) {
+    var _a, _b, _c;
+    const {
+      error,
+      message = error instanceof Error ? error.message : "Unexpected error",
+      session
+    } = params;
+    const stack = error instanceof Error ? (_a = error.stack) != null ? _a : null : null;
+    return this.sendMessage({
+      connectionId: (_b = session == null ? void 0 : session.id) != null ? _b : null,
+      data: { message, stack },
+      room: this.room,
+      type: "$ERROR",
+      user: (_c = session == null ? void 0 : session.user) != null ? _c : null
+    });
+  }
+  sendMessage(data) {
+    return this.send(JSON.stringify(data));
+  }
+};
+
+// src/PluvIO.ts
+import chalk2 from "chalk";
+
+// src/authorize.ts
+import hkdf from "@panva/hkdf";
+import { EncryptJWT, jwtDecrypt } from "jose";
+var DEFAULT_MAX_AGE_MS = 6e4;
+var getEncryptionKey = (secret) => __async(void 0, null, function* () {
+  return yield hkdf(
+    "sha256",
+    secret,
+    "",
+    "Pluv.io Generated Encryption Key",
+    32
+  );
+});
+var now = () => Date.now() / 1e3 | 0;
+var authorize = (params) => {
+  const { platform, secret } = params;
+  const encode = (encodeParams) => __async(void 0, null, function* () {
+    const { maxAge = DEFAULT_MAX_AGE_MS, room, user } = encodeParams;
+    const encryptionSecret = yield getEncryptionKey(secret);
+    const token = yield new EncryptJWT({
+      room,
+      sub: room ? `${room}|${user.id}` : user.id,
+      user
+    }).setProtectedHeader({ alg: "dir", enc: "A256GCM" }).setIssuedAt().setExpirationTime(now() + maxAge).setJti(platform.randomUUID()).encrypt(encryptionSecret);
+    return token.toString();
+  });
+  const decode = (jwt) => __async(void 0, null, function* () {
+    const encryptionSecret = yield getEncryptionKey(secret);
+    const { payload } = yield jwtDecrypt(jwt, encryptionSecret, {
+      clockTolerance: 15
+    });
+    return payload != null ? payload : null;
+  });
+  return { decode, encode };
+};
+
+// src/IORoom.ts
+import { doc } from "@pluv/crdt-yjs";
+import chalk from "chalk";
+var PING_TIMEOUT_MS = 3e4;
+var IORoom = class {
+  constructor(room, config) {
+    this._doc = doc();
+    this._sessions = /* @__PURE__ */ new Map();
+    this._uninitialize = null;
+    this._authorize = null;
+    const { authorize: authorize2, context, debug, events, onDestroy, platform } = config;
+    this._context = context;
+    this._debug = debug;
+    this._events = events;
+    this._platform = platform;
+    this.room = room;
+    this._listeners = {
+      onDestroy: () => onDestroy == null ? void 0 : onDestroy()
+    };
+    if (authorize2)
+      this._authorize = authorize2;
+  }
+  broadcast(message) {
+    return Promise.resolve(this._broadcast({ message }));
+  }
+  register(webSocket, options) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!this._uninitialize)
+        yield this._initialize();
+      const token = options == null ? void 0 : options.token;
+      const sessionId = this._platform.randomUUID();
+      const pluvWs = this._platform.convertWebSocket(webSocket, {
+        room: this.room
+      });
+      this._logDebug(
+        `${chalk.blue(
+          `Registering connection for room ${this.room}:`
+        )} ${sessionId}`
+      );
+      const uninitializeWs = yield pluvWs.initialize();
+      const user = yield this._getAuthorizedUser(token);
+      const isUnauthorized = !!((_a = this._authorize) == null ? void 0 : _a.required) && !user;
+      const isTokenInUse = !!user && Array.from(this._sessions.values()).some(
+        (session2) => {
+          var _a2;
+          return ((_a2 = session2.user) == null ? void 0 : _a2.id) === user.id;
+        }
+      );
+      if (isUnauthorized || isTokenInUse) {
+        this._logDebug(
+          `${chalk.blue(
+            "Authorization failed for connection:"
+          )} ${sessionId}`
+        );
+        pluvWs.handleError({ error: new Error("Not authorized") });
+        pluvWs.close(3e3, "WebSocket unauthorized.");
+        return;
+      }
+      const currentTime = new Date().getTime();
+      const session = {
+        id: sessionId,
+        presence: null,
+        quit: false,
+        room: this.room,
+        timers: {
+          ping: currentTime
+        },
+        webSocket: pluvWs,
+        user
+      };
+      this._sessions.set(session.id, session);
+      yield this._platform.persistance.addUser(
+        this.room,
+        sessionId,
+        user != null ? user : {}
+      );
+      this._emitRegistered(session);
+      this._emitStorageReceived(session);
+      this._emitUserJoined(session);
+      const context = {
+        context: this._context,
+        doc: this._doc,
+        room: this.room,
+        session,
+        sessions: this._sessions
+      };
+      pluvWs.addEventListener("message", (event) => {
+        if (!this._uninitialize)
+          return;
+        if (session.quit) {
+          session.webSocket.close(1011, "WebSocket broken.");
+          return;
+        }
+        const message = this._parseMessage(event);
+        if (!message)
+          return;
+        const eventConfig = this._getEventConfig(message);
+        if (!eventConfig)
+          return;
+        this._resolveMessage(message, context).then((output) => {
+          var _a2, _b;
+          if (!output)
+            return;
+          const eventType = (_b = (_a2 = eventConfig.options) == null ? void 0 : _a2.type) != null ? _b : "broadcast";
+          switch (eventType) {
+            case "self": {
+              Object.entries(output).forEach(([type, data]) => {
+                this._sendSelfMessage({ data, type }, session);
+              });
+              return;
+            }
+            case "sync": {
+              this._platform.pubSub.publish(this.room, __spreadValues({
+                connectionId: session.id,
+                options: eventConfig.options,
+                room: this.room,
+                user: session.user
+              }, message));
+              Object.entries(output).forEach(([type, data]) => {
+                this._sendSelfMessage({ data, type }, session);
+              });
+              return;
+            }
+            case "broadcast":
+            default: {
+              Object.entries(output).forEach(([type, data]) => {
+                this._broadcast({
+                  message: { data, type },
+                  senderId: session.id
+                });
+              });
+            }
+          }
+        });
+      });
+      const closeHandler = () => {
+        if (!this._uninitialize)
+          return;
+        session.quit = true;
+        this._logDebug(
+          `${chalk.blue(
+            `(Unregistering connection for room ${this.room}:`
+          )} ${sessionId}`
+        );
+        this._sessions.delete(session.id);
+        this._platform.persistance.deleteUser(this.room, session.id);
+        this._broadcast({
+          message: {
+            type: "$EXIT",
+            data: { sessionId: session.id }
+          },
+          senderId: session.id
+        });
+        uninitializeWs();
+        const size2 = this._getSessionsSize();
+        this._logDebug(
+          `${chalk.blue(
+            `Unregistered connection for room ${this.room}:`
+          )} ${sessionId}`
+        );
+        this._logDebug(`${chalk.blue(`Room ${this.room} size:`)} ${size2}`);
+        if (size2)
+          return;
+        this._uninitialize();
+      };
+      pluvWs.addEventListener("close", closeHandler);
+      pluvWs.addEventListener("error", closeHandler);
+      this._logDebug(
+        `${chalk.blue(
+          `Registered connection for room ${this.room}:`
+        )} ${sessionId}`
+      );
+      const size = this._getSessionsSize();
+      this._logDebug(`${chalk.blue(`Room ${this.room} size:`)} ${size}`);
+    });
+  }
+  _broadcast(params) {
+    var _a;
+    const { message, senderId } = params;
+    const currentTime = new Date().getTime();
+    const sender = senderId ? this._sessions.get(senderId) : null;
+    const quitters = Array.from(this._sessions.values()).filter(
+      (session) => session.quit || currentTime - session.timers.ping > PING_TIMEOUT_MS
+    );
+    quitters.forEach((session) => {
+      this._sessions.delete(session.id);
+    });
+    this._emitQuitters(quitters);
+    this._platform.pubSub.publish(this.room, __spreadValues({
+      connectionId: senderId != null ? senderId : null,
+      room: this.room,
+      user: (_a = sender == null ? void 0 : sender.user) != null ? _a : null
+    }, message));
+  }
+  _emitQuitters(quitters) {
+    quitters.forEach((quitter) => {
+      this._broadcast({
+        message: {
+          type: "$EXIT",
+          data: { sessionId: quitter.id }
+        },
+        senderId: quitter.id
+      });
+    });
+  }
+  _emitRegistered(session) {
+    this._sendSelfMessage(
+      {
+        type: "$REGISTERED",
+        data: { sessionId: session.id }
+      },
+      session
+    );
+  }
+  _emitStorageReceived(session) {
+    this._platform.persistance.getStorageState(this.room).then((_state) => {
+      const state = _state != null ? _state : this._doc.encodeStateAsUpdate();
+      this._sendSelfMessage(
+        {
+          type: "$STORAGE_RECEIVED",
+          data: { state }
+        },
+        session
+      );
+    });
+  }
+  _emitUserJoined(session) {
+    const user = session.user;
+    if (!user)
+      return;
+    this._broadcast({
+      message: {
+        type: "$USER_JOINED",
+        data: {
+          connectionId: session.id,
+          user
+        }
+      },
+      senderId: session.id
+    });
+  }
+  _getAuthorizedUser(token) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!this._authorize)
+        return null;
+      if (!token)
+        return null;
+      const payload = yield authorize({
+        platform: this._platform,
+        secret: this._authorize.secret
+      }).decode(token);
+      if (!payload) {
+        this._logDebug(chalk.blue("Could not decode token:"));
+        this._logDebug(token);
+        return null;
+      }
+      if (payload.room !== this.room) {
+        this._logDebug(
+          chalk.blue(`Token is not authorized for room ${this.room}:`)
+        );
+        this._logDebug(chalk.blue("Received:"), payload.room);
+        this._logDebug(token);
+        return null;
+      }
+      try {
+        return (_a = this._authorize.user.parse(payload.user)) != null ? _a : null;
+      } catch (e) {
+        this._logDebug(`${chalk.blue("Token fails validation:")} ${token}`);
+        return null;
+      }
+    });
+  }
+  _getSessionsSize() {
+    const currentTime = new Date().getTime();
+    return Array.from(this._sessions.values()).reduce((count, session) => {
+      if (session.quit)
+        return count;
+      return currentTime - session.timers.ping > PING_TIMEOUT_MS ? count : count + 1;
+    }, 0);
+  }
+  _getEventConfig(message) {
+    var _a;
+    return (_a = this._events[message.type]) != null ? _a : null;
+  }
+  _initialize() {
+    return __async(this, null, function* () {
+      this._logDebug(`${chalk.blue(`Initializing room ${this.room}:`)}`);
+      if (!!this._uninitialize) {
+        yield this._uninitialize();
+        this._uninitialize = null;
+      }
+      const pubSubId = yield this._platform.pubSub.subscribe(
+        this.room,
+        (_a) => {
+          var _b = _a, { options = {} } = _b, message = __objRest(_b, ["options"]);
+          const session = {
+            id: message.connectionId,
+            user: message.user
+          };
+          this._sendMessage(message, session, options);
+        }
+      );
+      this._uninitialize = () => __async(this, null, function* () {
+        this._platform.pubSub.unsubscribe(pubSubId);
+        this._doc.destroy();
+        this._doc = doc();
+        this._listeners.onDestroy();
+      });
+    });
+  }
+  _logDebug(...data) {
+    this._debug && console.log(...data);
+  }
+  _parseMessage(message) {
+    const parsed = this._platform.parseData(message.data);
+    try {
+      if (typeof parsed !== "object")
+        return null;
+      if (typeof parsed.type !== "string")
+        return null;
+      if (typeof parsed.data !== "object")
+        return null;
+      return parsed;
+    } catch (e) {
+      return null;
+    }
+  }
+  _resolveMessage(message, context) {
+    return __async(this, null, function* () {
+      const { session } = context;
+      const eventConfig = this._getEventConfig(message);
+      if (!eventConfig)
+        return null;
+      let input;
+      try {
+        input = eventConfig.input ? eventConfig.input.parse(message.data) : message.data;
+      } catch (error) {
+        session == null ? void 0 : session.webSocket.handleError({
+          error,
+          message: "Invalid input",
+          session
+        });
+        return null;
+      }
+      const output = yield eventConfig.resolver(input, context);
+      if (!output)
+        return null;
+      return output;
+    });
+  }
+  _sendMessage(message, sender, options = {}) {
+    switch (options.type) {
+      case "self": {
+        this._sendSelfMessage(message, sender);
+        return;
+      }
+      case "sync": {
+        this._sendSyncMessage(message, sender);
+        return;
+      }
+      case "broadcast":
+      default: {
+        const sessionIds = options.sessionIds;
+        this._sendBroadcastMessage(message, sender, sessionIds);
+      }
+    }
+  }
+  _sendBroadcastMessage(message, sender, sessionIds) {
+    var _a, _b;
+    const senderId = (_a = sender == null ? void 0 : sender.id) != null ? _a : null;
+    const sessions = (_b = sessionIds == null ? void 0 : sessionIds.reduce((dict, id) => {
+      const _session = this._sessions.get(id);
+      return _session ? dict.set(id, _session) : dict;
+    }, /* @__PURE__ */ new Map())) != null ? _b : this._sessions;
+    Array.from(sessions.values()).forEach((_session) => {
+      _session.webSocket.sendMessage(__spreadValues({
+        connectionId: senderId,
+        room: this.room,
+        user: _session.user
+      }, message));
+    });
+  }
+  _sendSelfMessage(message, sender) {
+    const senderId = sender == null ? void 0 : sender.id;
+    if (!senderId)
+      return;
+    const session = this._sessions.get(senderId);
+    if (!session)
+      return;
+    session.webSocket.sendMessage(__spreadValues({
+      connectionId: sender.id,
+      room: this.room,
+      user: sender.user
+    }, message));
+  }
+  _sendSyncMessage(message, sender) {
+    const senderId = sender == null ? void 0 : sender.id;
+    if (!senderId)
+      return;
+    this._resolveMessage(message, {
+      context: this._context,
+      doc: this._doc,
+      room: this.room,
+      session: null,
+      sessions: this._sessions
+    }).then((output) => {
+      if (!output)
+        return;
+      Object.keys(output).forEach((type) => {
+        var _a, _b;
+        const data = (_a = output[type]) != null ? _a : {};
+        this._platform.pubSub.publish(this.room, {
+          connectionId: senderId,
+          data,
+          options: { type: "self" },
+          room: this.room,
+          type,
+          user: (_b = sender.user) != null ? _b : null
+        });
+      });
+    });
+  }
+};
+
+// src/PluvIO.ts
+var PluvIO = class {
+  constructor(options) {
+    this._authorize = null;
+    this._events = {
+      $PING: {
+        resolver: (data, { session }) => {
+          if (!session)
+            return {};
+          const currentTime = new Date().getTime();
+          session.timers.ping = currentTime;
+          return { $PONG: {} };
+        },
+        options: { type: "self" }
+      },
+      $GET_OTHERS: {
+        resolver: (data, { session, sessions }) => {
+          const others = Array.from(sessions.entries()).filter(([, wsSession]) => wsSession.id !== (session == null ? void 0 : session.id)).reduce(
+            (acc, [connectionId, { presence, user }]) => __spreadProps(__spreadValues({}, acc), {
+              [connectionId]: {
+                connectionId,
+                presence,
+                room: this.room,
+                user
+              }
+            }),
+            {}
+          );
+          return { $OTHERS_RECEIVED: { others } };
+        },
+        options: { type: "sync" }
+      },
+      $UPDATE_PRESENCE: {
+        resolver: ({ presence }, { session }) => {
+          if (!session)
+            return {};
+          session.presence = Object.assign(
+            /* @__PURE__ */ Object.create(null),
+            session.presence,
+            presence
+          );
+          return { $PRESENCE_UPDATED: { presence } };
+        }
+      },
+      $UPDATE_STORAGE: {
+        resolver: ({ origin, update }, { doc: doc2, room }) => {
+          if (origin === "$STORAGE_RECEIVED" && Object.keys(doc2.toJSON()).length) {
+            return;
+          }
+          const updated = doc2.applyUpdate(update);
+          const state = updated.encodeStateAsUpdate();
+          this._platform.persistance.setStorageState(room, state);
+          return { $STORAGE_UPDATED: { state } };
+        }
+      }
+    };
+    this.room = null;
+    this._context = {};
+    this._rooms = /* @__PURE__ */ new Map();
+    const {
+      authorize: authorize2,
+      context,
+      debug = false,
+      events,
+      platform,
+      room
+    } = options;
+    this._debug = debug;
+    this._platform = platform;
+    if (authorize2)
+      this._authorize = authorize2;
+    if (context)
+      this._context = context;
+    if (events)
+      this._events = events;
+    if (room)
+      this.room = room;
+  }
+  createToken(params) {
+    return __async(this, null, function* () {
+      if (!this._authorize) {
+        throw new Error(
+          "IO does not specify authorize during initialization."
+        );
+      }
+      return yield authorize({
+        platform: this._platform,
+        secret: this._authorize.secret
+      }).encode(params);
+    });
+  }
+  event(event, config) {
+    if (event.startsWith("$")) {
+      throw new Error('Event name must not start with "$".');
+    }
+    const newEvent = {
+      [event]: config
+    };
+    return PluvIO.merge(
+      this,
+      new PluvIO({
+        events: newEvent,
+        platform: this._platform
+      })
+    );
+  }
+  getRoom(room) {
+    var _a;
+    if (this.room) {
+      throw new Error("IO cannot getRoom from within a room.");
+    }
+    if (!/^[a-z0-9]+[a-z0-9\-_]+[a-z0-9]+$/i.test(room)) {
+      throw new Error("Unsupported room name");
+    }
+    const platform = this._platform;
+    const oldRoom = this._rooms.get(room);
+    if (oldRoom)
+      return oldRoom;
+    const newRoom = new IORoom(room, {
+      authorize: (_a = this._authorize) != null ? _a : void 0,
+      context: this._context,
+      debug: this._debug,
+      events: this._events,
+      onDestroy: () => {
+        this._logDebug(`${chalk2.blue("Deleting empty room:")} ${room}`);
+        this._rooms.delete(room);
+        if (this._debug) {
+          const rooms = Array.from(this._rooms.keys());
+          this._logDebug(`${chalk2.blue("Deleted room:")} ${room}`);
+          this._logDebug(
+            `${chalk2.blue("Rooms available:")} ${rooms.join(", ")}`
+          );
+        }
+      },
+      platform
+    });
+    this._rooms.set(room, newRoom);
+    if (this._debug) {
+      const rooms = Array.from(this._rooms.keys());
+      this._logDebug(`${chalk2.blue("Created room:")} ${room}`);
+      this._logDebug(
+        `${chalk2.blue("Rooms available:")} ${rooms.join(", ")}`
+      );
+    }
+    return newRoom;
+  }
+  static merge(first, second) {
+    var _a, _b;
+    const authorize2 = (_a = first._authorize) != null ? _a : void 0;
+    const debug = first._debug;
+    const platform = first._platform;
+    const room = (_b = first.room) != null ? _b : void 0;
+    const events1 = first._events;
+    const events2 = second._events;
+    const events = Object.assign(/* @__PURE__ */ Object.create(null), events1, events2);
+    return new PluvIO({
+      authorize: authorize2,
+      debug,
+      events,
+      platform,
+      room
+    });
+  }
+  _logDebug(...data) {
+    this._debug && console.log(...data);
+  }
+};
+
+// src/createIO.ts
+var createIO = (params) => {
+  const { authorize: authorize2, context, debug, platform } = params;
+  return new PluvIO({ authorize: authorize2, context, debug, platform });
+};
+export {
+  AbstractPersistance,
+  AbstractPlatform,
+  AbstractPubSub,
+  AbstractWebSocket,
+  createIO
+};