@pluv/client 0.0.0

package/dist/index.js

@@ -0,0 +1,1001 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ConnectionState: () => ConnectionState,
+  PluvClient: () => PluvClient,
+  PluvRoom: () => PluvRoom,
+  createClient: () => createClient,
+  y: () => y_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PluvRoom.ts
+var import_crdt_yjs2 = require("@pluv/crdt-yjs");
+
+// src/CrdtManager.ts
+var import_crdt_yjs = require("@pluv/crdt-yjs");
+var CrdtManager = class {
+  constructor(options = {}) {
+    const { encodedState, initialStorage } = options;
+    const doc1 = encodedState ? (0, import_crdt_yjs.doc)().applyUpdate(encodedState) : null;
+    if (doc1 && !!Object.keys(doc1.toJSON()).length) {
+      this.doc = doc1;
+      return;
+    }
+    doc1 == null ? void 0 : doc1.destroy();
+    this.doc = (0, import_crdt_yjs.doc)(initialStorage == null ? void 0 : initialStorage());
+  }
+  destroy() {
+    this.doc.destroy();
+  }
+  get(key) {
+    return this.doc.get(key);
+  }
+};
+
+// src/CrdtNotifier.ts
+var import_wonka = require("wonka");
+var CrdtNotifier = class {
+  constructor() {
+    this.subjects = /* @__PURE__ */ new Map();
+  }
+  subject(key) {
+    const subject = this.subjects.get(key);
+    if (subject) {
+      return subject;
+    }
+    const newSubject = (0, import_wonka.makeSubject)();
+    this.subjects.set(key, newSubject);
+    return newSubject;
+  }
+  subscribe(key, callback) {
+    const subject = this.subject(key);
+    return (0, import_wonka.subscribe)(callback)(subject.source).unsubscribe;
+  }
+};
+
+// src/EventNotifier.ts
+var import_wonka2 = require("wonka");
+var EventNotifier = class {
+  constructor() {
+    this.subjects = /* @__PURE__ */ new Map();
+  }
+  subject(name) {
+    const subject = this.subjects.get(name);
+    if (subject)
+      return subject;
+    const newSubject = (0, import_wonka2.makeSubject)();
+    this.subjects.set(name, newSubject);
+    return newSubject;
+  }
+  subscribe(name, callback) {
+    const subject = this.subject(name);
+    return (0, import_wonka2.subscribe)(callback)(subject.source).unsubscribe;
+  }
+};
+
+// src/OtherNotifier.ts
+var import_wonka3 = require("wonka");
+var OtherNotifier = class {
+  constructor() {
+    this.subjects = /* @__PURE__ */ new Map();
+  }
+  subject(name) {
+    const subject = this.subjects.get(name);
+    if (subject)
+      return subject;
+    const newSubject = (0, import_wonka3.makeSubject)();
+    this.subjects.set(name, newSubject);
+    return newSubject;
+  }
+  subscribe(name, callback) {
+    const source = this.subject(name).source;
+    return (0, import_wonka3.subscribe)(callback)(source).unsubscribe;
+  }
+};
+
+// src/StateNotifier.ts
+var import_wonka4 = require("wonka");
+var StateNotifier = class {
+  constructor() {
+    this.subjects = {
+      connection: (0, import_wonka4.makeSubject)(),
+      "my-presence": (0, import_wonka4.makeSubject)(),
+      myself: (0, import_wonka4.makeSubject)(),
+      others: (0, import_wonka4.makeSubject)()
+    };
+  }
+  subscribe(name, callback) {
+    var _a;
+    const source = (_a = this.subjects[name]) == null ? void 0 : _a.source;
+    if (!source)
+      throw new Error(`Could not subscribe to source: ${name}`);
+    return (0, import_wonka4.subscribe)(callback)(source).unsubscribe;
+  }
+};
+
+// src/types.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["Closed"] = "Closed";
+  ConnectionState2["Connecting"] = "Connecting";
+  ConnectionState2["Open"] = "Open";
+  ConnectionState2["Unavailable"] = "Unavailable";
+  ConnectionState2["Untouched"] = "Untouched";
+  return ConnectionState2;
+})(ConnectionState || {});
+
+// src/UsersManager.ts
+var UsersManager = class {
+  constructor(config) {
+    this._myself = null;
+    this._others = /* @__PURE__ */ new Map();
+    this._presence = null;
+    const { initialPresence, presence = null } = config;
+    this._initialPresence = initialPresence;
+    this._presence = presence;
+  }
+  get myself() {
+    return this._myself;
+  }
+  clear() {
+    this._others.clear();
+  }
+  getOther(connectionId) {
+    var _a;
+    return (_a = this._others.get(connectionId)) != null ? _a : null;
+  }
+  getOthers() {
+    return Array.from(this._others.values());
+  }
+  patchPresence(connectionId, patch) {
+    var _a, _b;
+    if (((_a = this._myself) == null ? void 0 : _a.connectionId) === connectionId) {
+      this._myself.presence = Object.assign(
+        /* @__PURE__ */ Object.create(null),
+        this._myself.presence,
+        patch
+      );
+      return;
+    }
+    const other = this._others.get(connectionId);
+    if (!other)
+      return;
+    const presence = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      other.presence,
+      patch
+    );
+    (_b = this._presence) == null ? void 0 : _b.parse(presence);
+    this._others.set(connectionId, __spreadProps(__spreadValues({}, other), { presence }));
+  }
+  removeMyself() {
+    this._myself = null;
+  }
+  removeUser(connectionId) {
+    this._others.delete(connectionId);
+  }
+  setMyself(connectionId, user) {
+    this._myself = {
+      connectionId,
+      presence: this._initialPresence,
+      user
+    };
+  }
+  setPresence(connectionId, presence) {
+    var _a;
+    if (((_a = this._myself) == null ? void 0 : _a.connectionId) === connectionId) {
+      this._myself.presence = presence;
+      return;
+    }
+    const other = this._others.get(connectionId);
+    if (!other)
+      return;
+    this._others.set(connectionId, __spreadProps(__spreadValues({}, other), { presence }));
+  }
+  setUser(connectionId, user) {
+    var _a;
+    if (((_a = this._myself) == null ? void 0 : _a.connectionId) === connectionId)
+      return;
+    const other = this._others.get(connectionId);
+    if (other)
+      return;
+    this._others.set(connectionId, {
+      connectionId,
+      presence: this._initialPresence,
+      user
+    });
+  }
+};
+
+// src/PluvRoom.ts
+var HEARTBEAT_INTERVAL_MS = 1e4;
+var PONG_TIMEOUT_MS = 2e3;
+var RECONNECT_TIMEOUT_MS = 3e4;
+var PluvRoom = class {
+  constructor(room, options) {
+    this._crdtManager = null;
+    this._crdtNotifier = new CrdtNotifier();
+    this._eventNotifier = new EventNotifier();
+    this._initialStorage = null;
+    this._intervals = {
+      heartbeat: null
+    };
+    this._otherNotifier = new OtherNotifier();
+    this._state = {
+      authorization: {
+        token: null,
+        user: null
+      },
+      connection: {
+        id: null,
+        state: "Untouched" /* Untouched */
+      },
+      webSocket: null
+    };
+    this._stateNotifier = new StateNotifier();
+    this._subscriptions = {
+      observeCrdt: null
+    };
+    this._timeouts = {
+      pong: null,
+      reconnect: null
+    };
+    this._windowListeners = null;
+    this._wsListeners = null;
+    this.event = (name, callback) => {
+      return this._eventNotifier.subscribe(name, callback);
+    };
+    this.getMyPresence = () => {
+      var _a, _b;
+      return (_b = (_a = this._usersManager.myself) == null ? void 0 : _a.presence) != null ? _b : null;
+    };
+    this.getMyself = () => {
+      return this._usersManager.myself;
+    };
+    this.getOther = (connectionId) => {
+      return this._usersManager.getOther(connectionId);
+    };
+    this.getOthers = () => {
+      return this._usersManager.getOthers();
+    };
+    this.getStorage = (key) => {
+      var _a, _b;
+      return (_b = (_a = this._crdtManager) == null ? void 0 : _a.get(key)) != null ? _b : null;
+    };
+    this.other = (connectionId, callback) => {
+      return this._otherNotifier.subscribe(connectionId, callback);
+    };
+    this.storage = (key, fn) => {
+      return this._crdtNotifier.subscribe(key, fn);
+    };
+    this.subscribe = (name, callback) => {
+      return this._stateNotifier.subscribe(name, callback);
+    };
+    const {
+      authEndpoint,
+      debug = false,
+      initialPresence,
+      initialStorage,
+      onAuthorizationFail,
+      presence,
+      wsEndpoint
+    } = options;
+    this.room = room;
+    this._debug = debug;
+    this._endpoints = {
+      authEndpoint,
+      wsEndpoint
+    };
+    this._listeners = {
+      onAuthorizationFail: (error) => {
+        this._clearTimeout(this._timeouts.reconnect);
+        this._timeouts.reconnect = setTimeout(
+          this._reconnect.bind(this),
+          RECONNECT_TIMEOUT_MS
+        );
+        onAuthorizationFail == null ? void 0 : onAuthorizationFail(error);
+      }
+    };
+    this._usersManager = new UsersManager({
+      initialPresence,
+      presence
+    });
+    if (initialStorage)
+      this._initialStorage = initialStorage;
+  }
+  get webSocket() {
+    return this._state.webSocket;
+  }
+  broadcast(message) {
+    if (!this._state.webSocket)
+      return;
+    if (this._state.connection.state !== "Open" /* Open */)
+      return;
+    this._sendMessage(message);
+  }
+  connect() {
+    return __async(this, null, function* () {
+      if (!this._endpoints.wsEndpoint) {
+        throw new Error("Must provide an wsEndpoint.");
+      }
+      const canConnect = [
+        "Closed" /* Closed */,
+        "Untouched" /* Untouched */
+      ].some((state) => this._state.connection.state === state);
+      if (!canConnect)
+        return;
+      this._clearTimeout(this._timeouts.reconnect);
+      this._updateState((oldState) => {
+        oldState.connection.state = "Connecting" /* Connecting */;
+        return oldState;
+      });
+      const url = new URL(this._getWsEndpoint(this.room));
+      let authToken = null;
+      try {
+        authToken = yield this._getAuthorization(this.room);
+      } catch (err) {
+        this._onAuthorizationFail(err);
+        return;
+      }
+      authToken && url.searchParams.set("token", encodeURIComponent(authToken));
+      let webSocket;
+      try {
+        webSocket = new WebSocket(url.toString());
+      } catch (err) {
+        this._onAuthorizationFail(err);
+        return;
+      }
+      this._updateState((oldState) => {
+        oldState.authorization.token = authToken;
+        oldState.webSocket = webSocket;
+        return oldState;
+      });
+      this._attachWindowListeners();
+      this._attachWsListeners();
+    });
+  }
+  disconnect() {
+    var _a;
+    if (!this._endpoints.wsEndpoint) {
+      throw new Error("Must provide an wsEndpoint.");
+    }
+    if (!this._state.webSocket)
+      return;
+    const canDisconnect = [
+      "Connecting" /* Connecting */,
+      "Open" /* Open */
+    ].some((state) => this._state.connection.state === state);
+    if (!canDisconnect)
+      return;
+    this._closeWs();
+    (_a = this._crdtManager) == null ? void 0 : _a.destroy();
+    this._updateState((oldState) => {
+      oldState.authorization.token = null;
+      oldState.connection.state = "Closed" /* Closed */;
+      oldState.webSocket = null;
+      return oldState;
+    });
+  }
+  getConnection() {
+    return Object.freeze(
+      JSON.parse(JSON.stringify(this._state.connection))
+    );
+  }
+  _attachWindowListeners() {
+    if (typeof window === "undefined")
+      return;
+    if (typeof document === "undefined")
+      return;
+    this._windowListeners = {
+      onNavigatorOnline: this._onNavigatorOnline.bind(this),
+      onVisibilityChange: this._onVisibilityChange.bind(this)
+    };
+    window.addEventListener(
+      "online",
+      this._windowListeners.onNavigatorOnline
+    );
+    document.addEventListener(
+      "visibilitychange",
+      this._windowListeners.onVisibilityChange
+    );
+  }
+  _attachWsListeners() {
+    if (!this._state.webSocket)
+      return;
+    this._wsListeners = {
+      onClose: this._onClose.bind(this),
+      onError: this._onError.bind(this),
+      onMessage: this._onMessage.bind(this),
+      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
+    );
+  }
+  _clearInterval(interval) {
+    if (Number.isNaN(interval))
+      return;
+    clearInterval(interval);
+  }
+  _clearTimeout(timeout) {
+    if (Number.isNaN(timeout))
+      return;
+    clearTimeout(timeout);
+  }
+  _closeWs() {
+    var _a, _b;
+    if (!this._state.webSocket)
+      return;
+    (_b = (_a = this._subscriptions).observeCrdt) == null ? void 0 : _b.call(_a);
+    this._clearInterval(this._intervals.heartbeat);
+    this._clearTimeout(this._timeouts.pong);
+    this._clearTimeout(this._timeouts.reconnect);
+    this._detachWindowListeners();
+    this._usersManager.removeMyself();
+    const canClose = [WebSocket.CONNECTING, WebSocket.OPEN].some(
+      (readyState) => {
+        var _a2;
+        return readyState === ((_a2 = this._state.webSocket) == null ? void 0 : _a2.readyState);
+      }
+    );
+    if (canClose)
+      this._state.webSocket.close();
+    this._detachWsListeners();
+    this._stateNotifier.subjects["my-presence"].next(null);
+    this._stateNotifier.subjects["myself"].next(null);
+  }
+  _detachWindowListeners() {
+    if (!this._windowListeners)
+      return;
+    if (typeof window === "undefined")
+      return;
+    if (typeof document === "undefined")
+      return;
+    window.removeEventListener(
+      "online",
+      this._windowListeners.onNavigatorOnline
+    );
+    document.removeEventListener(
+      "visibilitychange",
+      this._windowListeners.onVisibilityChange
+    );
+    this._windowListeners = null;
+  }
+  _detachWsListeners() {
+    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._wsListeners = null;
+  }
+  _getAuthorization(room) {
+    return __async(this, null, function* () {
+      if (!this._endpoints.authEndpoint)
+        return null;
+      if (typeof this._endpoints.authEndpoint === "string") {
+        const token2 = yield fetch(this._endpoints.authEndpoint).then((res) => res.text()).then((text2) => text2.trim());
+        return token2;
+      }
+      const config = this._endpoints.authEndpoint(room);
+      const endpoint = typeof config === "string" ? config : config.url;
+      const options = typeof config === "string" ? void 0 : config.options;
+      const token = yield fetch(endpoint, options).then((res) => res.text()).then((text2) => text2.trim());
+      return token;
+    });
+  }
+  _getWsEndpoint(room) {
+    if (typeof this._endpoints.wsEndpoint === "string") {
+      return this._endpoints.wsEndpoint;
+    }
+    return this._endpoints.wsEndpoint(room);
+  }
+  _handleExit(message) {
+    const { connectionId } = message;
+    if (!connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    this._usersManager.removeUser(connectionId);
+    const others = this._usersManager.getOthers();
+    this._stateNotifier.subjects.others.next(others);
+    this._otherNotifier.subject(connectionId).next(null);
+    this._otherNotifier.subjects.delete(connectionId);
+  }
+  _handlePresenceUpdatedMessage(message) {
+    var _a, _b, _c;
+    const { connectionId } = message;
+    if (!connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    const data = message.data;
+    this._usersManager.patchPresence(
+      connectionId,
+      data.presence
+    );
+    const myPresence = (_b = (_a = this._usersManager.myself) == null ? void 0 : _a.presence) != null ? _b : null;
+    const myself = (_c = this._usersManager.myself) != null ? _c : null;
+    if ((myself == null ? void 0 : myself.connectionId) === connectionId) {
+      this._stateNotifier.subjects["my-presence"].next(myPresence);
+      this._stateNotifier.subjects["myself"].next(myself);
+      return;
+    }
+    const other = this._usersManager.getOther(connectionId);
+    const others = this._usersManager.getOthers();
+    this._otherNotifier.subject(connectionId).next(other);
+    this._stateNotifier.subjects["others"].next(others);
+  }
+  _handleReceiveOthers(message) {
+    if (!message.connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    const data = message.data;
+    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
+      );
+      this._otherNotifier.subject(connectionId).next(other);
+    });
+    const others = this._usersManager.getOthers();
+    this._stateNotifier.subjects["others"].next(others);
+  }
+  _handleRegisteredMessage(message) {
+    var _a, _b, _c;
+    const { connectionId, user } = message;
+    if (!connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    this._updateState((oldState) => {
+      oldState.connection.id = connectionId;
+      oldState.authorization.user = user;
+      return oldState;
+    });
+    this._usersManager.setMyself(
+      connectionId,
+      user
+    );
+    const myPresence = (_b = (_a = this._usersManager.myself) == null ? void 0 : _a.presence) != null ? _b : null;
+    const myself = (_c = this._usersManager.myself) != null ? _c : null;
+    this._stateNotifier.subjects["my-presence"].next(myPresence);
+    this._stateNotifier.subjects["myself"].next(myself);
+    this._sendMessage({ type: "$GET_OTHERS", data: {} });
+  }
+  _handleStorageReceivedMessage(message) {
+    var _a;
+    const { connectionId } = message;
+    if (!connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    const data = message.data;
+    this._crdtManager = new CrdtManager({
+      encodedState: data.state,
+      initialStorage: (_a = this._initialStorage) != null ? _a : void 0
+    });
+    this._observeCrdt();
+    const sharedTypes = this._crdtManager.doc.getSharedTypes();
+    Object.keys(sharedTypes).forEach((key) => {
+      const sharedType = sharedTypes[key];
+      const serialized = sharedType.toJSON();
+      this._crdtNotifier.subject(key).next(serialized);
+    });
+    const update = this._crdtManager.doc.encodeStateAsUpdate();
+    this._sendMessage({
+      type: "$UPDATE_STORAGE",
+      data: { origin: "$STORAGE_RECEIVED", update }
+    });
+  }
+  _handleStorageUpdatedMessage(message) {
+    const { connectionId } = message;
+    if (!connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    const data = message.data;
+    if (!this._crdtManager)
+      return;
+    const test = (0, import_crdt_yjs2.doc)({});
+    test.applyUpdate(data.state);
+    this._crdtManager.doc.applyUpdate(data.state, "$STORAGE_UPDATED");
+    const sharedTypes = this._crdtManager.doc.getSharedTypes();
+    Object.keys(sharedTypes).forEach((key) => {
+      if (!this._crdtManager)
+        return;
+      const sharedType = sharedTypes[key];
+      if (!sharedType)
+        return;
+      const serialized = sharedType.toJSON();
+      this._crdtNotifier.subject(key).next(serialized);
+    });
+  }
+  _handleUserJoinedMessage(message) {
+    const { connectionId } = message;
+    if (!connectionId)
+      return;
+    if (!this._state.webSocket)
+      throw new Error("Could not find WebSocket");
+    if (!this._usersManager.myself)
+      return;
+    const data = message.data;
+    this._usersManager.setUser(connectionId, data.user);
+    const other = this._usersManager.getOther(connectionId);
+    const others = this._usersManager.getOthers();
+    this._otherNotifier.subject(connectionId).next(other);
+    this._stateNotifier.subjects["others"].next(others);
+  }
+  _heartbeat() {
+    if (!this._state.webSocket)
+      return;
+    if (!this._state.connection.id)
+      return;
+    if (this._state.webSocket.readyState !== this._state.webSocket.OPEN) {
+      return;
+    }
+    this._clearTimeout(this._timeouts.pong);
+    this._timeouts.pong = setTimeout(
+      this._reconnect.bind(this),
+      PONG_TIMEOUT_MS
+    );
+    this._sendMessage({ type: "$PING", data: {} });
+  }
+  _logDebug(...data) {
+    var _a;
+    if (((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.NODE_ENV) === "production")
+      return;
+    this._debug && console.log(...data);
+  }
+  _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(
+      (update, _origin) => {
+        const origin = _origin != null ? _origin : null;
+        if (!this._crdtManager)
+          return;
+        if (!this._state.webSocket)
+          return;
+        if (!this._state.connection.id)
+          return;
+        if (this._state.webSocket.readyState !== WebSocket.OPEN)
+          return;
+        if (origin === "$STORAGE_UPDATED")
+          return;
+        this._sendMessage({
+          type: "$UPDATE_STORAGE",
+          data: { origin, update }
+        });
+      }
+    );
+    this._subscriptions.observeCrdt = unsubscribe;
+  }
+  _onAuthorizationFail(error) {
+    const authError = error instanceof Error ? error : new Error("Authorization failed");
+    this._listeners.onAuthorizationFail(authError);
+    this._updateState((oldState) => {
+      oldState.connection.state = "Unavailable" /* Unavailable */;
+      return oldState;
+    });
+  }
+  _onClose(event) {
+    this._logDebug("WebSocket closed");
+    !!event.reason && this._logDebug(event.reason);
+    this._clearInterval(this._intervals.heartbeat);
+    this._clearTimeout(this._timeouts.pong);
+    this._updateState((oldState) => {
+      oldState.connection.state = "Closed" /* Closed */;
+      oldState.webSocket = null;
+      return oldState;
+    });
+  }
+  _onError() {
+  }
+  _onMessage(event) {
+    const message = this._parseMessage(event);
+    if (!message)
+      return;
+    const shouldLog = 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).next(message);
+    const { connectionId } = message;
+    if (!connectionId)
+      return;
+    switch (message.type) {
+      case "$EXIT": {
+        this._handleExit(message);
+        return;
+      }
+      case "$OTHERS_RECEIVED": {
+        this._handleReceiveOthers(message);
+        return;
+      }
+      case "$PONG": {
+        this._clearTimeout(this._timeouts.pong);
+        return;
+      }
+      case "$PRESENCE_UPDATED": {
+        this._handlePresenceUpdatedMessage(message);
+        return;
+      }
+      case "$REGISTERED": {
+        this._handleRegisteredMessage(message);
+        return;
+      }
+      case "$STORAGE_RECEIVED": {
+        this._handleStorageReceivedMessage(message);
+        return;
+      }
+      case "$STORAGE_UPDATED": {
+        this._handleStorageUpdatedMessage(message);
+        return;
+      }
+      case "$USER_JOINED": {
+        this._handleUserJoinedMessage(message);
+        return;
+      }
+      default:
+    }
+  }
+  _onOpen() {
+    if (this._state.connection.state !== "Connecting" /* Connecting */)
+      return;
+    this._logDebug("WebSocket connected");
+    this._updateState((oldState) => {
+      oldState.connection.state = "Open" /* Open */;
+      return oldState;
+    });
+    this._clearInterval(this._intervals.heartbeat);
+    this._intervals.heartbeat = setInterval(
+      this._heartbeat.bind(this),
+      HEARTBEAT_INTERVAL_MS
+    );
+  }
+  _onNavigatorOnline() {
+    return __async(this, null, function* () {
+      if (this._state.connection.state !== "Unavailable" /* Unavailable */) {
+        return;
+      }
+      yield this._reconnect();
+    });
+  }
+  _onVisibilityChange() {
+    return __async(this, null, function* () {
+      if (typeof document === "undefined")
+        return;
+      if (document.visibilityState !== "visible")
+        return;
+      switch (this._state.connection.state) {
+        case "Open" /* Open */:
+          this._clearInterval(this._intervals.heartbeat);
+          setInterval(this._heartbeat.bind(this), HEARTBEAT_INTERVAL_MS);
+          return;
+        case "Unavailable" /* Unavailable */:
+          yield this._reconnect();
+          return;
+        default:
+      }
+    });
+  }
+  _parseMessage(message) {
+    if (typeof message.data !== "string")
+      return null;
+    try {
+      const config = JSON.parse(message.data);
+      if (typeof config !== "object")
+        return null;
+      if (typeof config.type !== "string")
+        return null;
+      if (typeof config.data !== "object")
+        return null;
+      return config;
+    } catch (e) {
+      return null;
+    }
+  }
+  _reconnect() {
+    return __async(this, null, function* () {
+      if (!this._endpoints.wsEndpoint) {
+        throw new Error("Must provide an wsEndpoint.");
+      }
+      if (!this._state.webSocket)
+        return;
+      this._closeWs();
+      this._updateState((oldState) => {
+        oldState.authorization.token = null;
+        oldState.connection.state = "Unavailable" /* Unavailable */;
+        oldState.webSocket = null;
+        return oldState;
+      });
+      yield this.connect();
+    });
+  }
+  _sendMessage(data) {
+    const webSocket = this._state.webSocket;
+    if ((webSocket == null ? void 0 : webSocket.readyState) !== WebSocket.OPEN)
+      return;
+    const shouldLog = typeof this._debug === "boolean" ? this._debug : this._debug.input.find((value) => value === data.type);
+    if (shouldLog) {
+      this._logDebug("WebSocket event sent: ", data.type, data);
+    }
+    webSocket.send(JSON.stringify(data));
+  }
+  _updateState(updater) {
+    let authorization;
+    try {
+      authorization = JSON.parse(
+        JSON.stringify(this._state.authorization)
+      );
+    } catch (e) {
+      throw new Error("User is not JSON serializable");
+    }
+    const oldState = __spreadProps(__spreadValues({}, this._state), {
+      authorization,
+      connection: JSON.parse(JSON.stringify(this._state.connection)),
+      webSocket: this._state.webSocket
+    });
+    const newState = updater(oldState);
+    this._logDebug("WebSocket new state: ", newState);
+    this._state = newState;
+    this._stateNotifier.subjects.connection.next(newState);
+    return newState;
+  }
+};
+
+// src/PluvClient.ts
+var PluvClient = class {
+  constructor(options) {
+    this._rooms = /* @__PURE__ */ new Map();
+    this.createRoom = (room, options) => {
+      const oldRoom = this.getRoom(room);
+      if (oldRoom)
+        return oldRoom;
+      const newRoom = new PluvRoom(room, {
+        authEndpoint: this._authEndpoint,
+        debug: options.debug,
+        initialPresence: options.initialPresence,
+        initialStorage: options.initialStorage,
+        onAuthorizationFail: options.onAuthorizationFail,
+        wsEndpoint: this._wsEndpoint
+      });
+      this._rooms.set(room, newRoom);
+      return newRoom;
+    };
+    this.enter = (room) => __async(this, null, function* () {
+      const toEnter = this.getRoom(room);
+      if (!toEnter) {
+        throw new Error(`Could not find room: ${room}.`);
+      }
+      yield toEnter.connect();
+    });
+    this.getRoom = (room) => {
+      const found = this._rooms.get(room);
+      return found != null ? found : null;
+    };
+    this.leave = (room) => {
+      const toLeave = this.getRoom(room);
+      if (!toLeave)
+        return;
+      toLeave.disconnect();
+      this._rooms.delete(room);
+    };
+    this._authEndpoint = options.authEndpoint;
+    this._wsEndpoint = options.wsEndpoint;
+  }
+};
+
+// src/createClient.ts
+var createClient = (options) => {
+  return new PluvClient(options);
+};
+
+// src/y.ts
+var y_exports = {};
+__export(y_exports, {
+  array: () => import_crdt_yjs3.array,
+  map: () => import_crdt_yjs3.map,
+  text: () => import_crdt_yjs3.text,
+  unstable__object: () => import_crdt_yjs3.unstable__object
+});
+var import_crdt_yjs3 = require("@pluv/crdt-yjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionState,
+  PluvClient,
+  PluvRoom,
+  createClient,
+  y
+});