@rpgjs/client 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/index35.js

@@ -1,316 +1,501 @@
-import { BehaviorSubject, filter, combineLatest, map, finalize } from 'rxjs';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var ArraySubject = class extends BehaviorSubject {
-  static {
-    __name(this, "ArraySubject");
-  }
-  _items = [];
-  constructor(items = []) {
-    super({
-      type: "init",
-      items
-    });
-    this.createProxy(items);
-  }
-  createProxy(items) {
-    this._items = new Proxy(items, {
-      get: /* @__PURE__ */ __name((target, prop, receiver) => {
-        const origMethod = target[prop];
-        if (typeof origMethod === "function") {
-          return (...args) => {
-            let changeType = "update";
-            let index = void 0;
-            let isMutateFn = false;
-            let itemsToEmit = [];
-            let changeSplice = true;
-            switch (prop) {
-              case "push":
-                index = target.length;
-                changeType = "add";
-                isMutateFn = true;
-                break;
-              case "pop":
-                index = target.length - 1;
-                changeType = "remove";
-                isMutateFn = true;
-                break;
-              case "unshift":
-                index = 0;
-                changeType = "add";
-                isMutateFn = true;
-                break;
-              case "shift":
-                index = 0;
-                changeType = "remove";
-                isMutateFn = true;
-                break;
-              case "splice":
-                index = args[0];
-                const deleteCount = args[1];
-                const newItems = args.slice(2);
-                itemsToEmit = newItems;
-                if (deleteCount > 0 && newItems.length === 0) {
-                  changeType = "remove";
-                } else if (deleteCount === 0 && newItems.length > 0) {
-                  changeType = "add";
-                } else if (deleteCount === 0 && newItems.length === 0) {
-                  changeSplice = false;
-                } else {
-                  changeType = "update";
-                }
-                isMutateFn = true;
-                break;
-            }
-            const result = origMethod.apply(target, args);
-            if (isMutateFn && changeSplice) {
-              if (prop === "splice") {
-                this.next({
-                  type: changeType,
-                  index,
-                  items: itemsToEmit
-                });
-              } else {
-                this.next({
-                  type: changeType,
-                  index,
-                  items: args
-                });
-              }
-            }
-            return result;
-          };
-        }
-        return Reflect.get(target, prop, receiver);
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
-        target[prop] = value;
-        this.next({
-          type: "update",
-          index,
-          items: [
-            value
-          ]
-        });
-        return true;
-      }, "set")
-    });
-  }
-  get items() {
-    return this._items;
+// src/ws.ts
+if (!globalThis.EventTarget || !globalThis.Event) {
+  console.error(`
+  PartySocket requires a global 'EventTarget' class to be available!
+  You can polyfill this global by adding this to your code before any partysocket imports: 
+  
+  \`\`\`
+  import 'partysocket/event-target-polyfill';
+  \`\`\`
+  Please file an issue at https://github.com/partykit/partykit if you're still having trouble.
+`);
+}
+var ErrorEvent = class extends Event {
+  message;
+  error;
+  // biome-ignore lint/suspicious/noExplicitAny: vibes
+  constructor(error, target) {
+    super("error", target);
+    this.message = error.message;
+    this.error = error;
   }
-  set items(newItems) {
-    this.createProxy(newItems);
-    this.next({
-      type: "reset",
-      items: newItems
-    });
+};
+var CloseEvent = class extends Event {
+  code;
+  reason;
+  wasClean = true;
+  // biome-ignore lint/style/useDefaultParameterLast: legacy
+  // biome-ignore lint/suspicious/noExplicitAny: legacy
+  constructor(code = 1e3, reason = "", target) {
+    super("close", target);
+    this.code = code;
+    this.reason = reason;
   }
 };
-var ObjectSubject = class extends BehaviorSubject {
-  static {
-    __name(this, "ObjectSubject");
-  }
-  _obj;
-  constructor(obj = {}) {
-    super({
-      type: "init",
-      value: obj
-    });
-    this.createProxy(obj);
-  }
-  createProxy(obj) {
-    this._obj = new Proxy(obj, {
-      get: /* @__PURE__ */ __name((target, prop, receiver) => {
-        return Reflect.get(target, prop, receiver);
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value, receiver) => {
-        const key = prop;
-        const changeType = key in target ? "update" : "add";
-        target[key] = value;
-        this.next({
-          type: changeType,
-          key,
-          value
-        });
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        const key = prop;
-        if (key in target) {
-          const value = target[key];
-          delete target[key];
-          this.next({
-            type: "remove",
-            key,
-            value
-          });
-          return true;
-        }
-        return false;
-      }, "deleteProperty")
-    });
+var Events = {
+  Event,
+  ErrorEvent,
+  CloseEvent
+};
+function assert(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
   }
-  get obj() {
-    return this._obj;
+}
+function cloneEventBrowser(e) {
+  return new e.constructor(e.type, e);
+}
+function cloneEventNode(e) {
+  if ("data" in e) {
+    const evt2 = new MessageEvent(e.type, e);
+    return evt2;
   }
-  set obj(newObj) {
-    this.createProxy(newObj);
-    this.next({
-      type: "reset",
-      value: newObj
-    });
+  if ("code" in e || "reason" in e) {
+    const evt2 = new CloseEvent(
+      // @ts-expect-error we need to fix event/listener types
+      e.code || 1999,
+      // @ts-expect-error we need to fix event/listener types
+      e.reason || "unknown reason",
+      e
+    );
+    return evt2;
   }
-};
-var getGlobalReactiveStore = /* @__PURE__ */ __name(() => {
-  const globalKey = "__REACTIVE_STORE__";
-  if (typeof globalThis !== "undefined") {
-    if (!globalThis[globalKey]) {
-      globalThis[globalKey] = {
-        currentDependencyTracker: null,
-        currentSubscriptionsTracker: null
-      };
+  if ("error" in e) {
+    const evt2 = new ErrorEvent(e.error, e);
+    return evt2;
+  }
+  const evt = new Event(e.type, e);
+  return evt;
+}
+var _a;
+var isNode =
+  typeof process !== "undefined" &&
+  typeof ((_a = process.versions) == null ? void 0 : _a.node) !== "undefined" &&
+  typeof document === "undefined";
+var cloneEvent = isNode ? cloneEventNode : cloneEventBrowser;
+var DEFAULT = {
+  maxReconnectionDelay: 1e4,
+  minReconnectionDelay: 1e3 + Math.random() * 4e3,
+  minUptime: 5e3,
+  reconnectionDelayGrowFactor: 1.3,
+  connectionTimeout: 4e3,
+  maxRetries: Number.POSITIVE_INFINITY,
+  maxEnqueuedMessages: Number.POSITIVE_INFINITY};
+var didWarnAboutMissingWebSocket = false;
+var ReconnectingWebSocket = class _ReconnectingWebSocket extends EventTarget {
+  _ws;
+  _retryCount = -1;
+  _uptimeTimeout;
+  _connectTimeout;
+  _shouldReconnect = true;
+  _connectLock = false;
+  _binaryType = "blob";
+  _closeCalled = false;
+  _messageQueue = [];
+  _debugLogger = console.log.bind(console);
+  _url;
+  _protocols;
+  _options;
+  constructor(url, protocols, options = {}) {
+    super();
+    this._url = url;
+    this._protocols = protocols;
+    this._options = options;
+    if (this._options.startClosed) {
+      this._shouldReconnect = false;
+    }
+    if (this._options.debugLogger) {
+      this._debugLogger = this._options.debugLogger;
+    }
+    this._connect();
+  }
+  static get CONNECTING() {
+    return 0;
+  }
+  static get OPEN() {
+    return 1;
+  }
+  static get CLOSING() {
+    return 2;
+  }
+  static get CLOSED() {
+    return 3;
+  }
+  get CONNECTING() {
+    return _ReconnectingWebSocket.CONNECTING;
+  }
+  get OPEN() {
+    return _ReconnectingWebSocket.OPEN;
+  }
+  get CLOSING() {
+    return _ReconnectingWebSocket.CLOSING;
+  }
+  get CLOSED() {
+    return _ReconnectingWebSocket.CLOSED;
+  }
+  get binaryType() {
+    return this._ws ? this._ws.binaryType : this._binaryType;
+  }
+  set binaryType(value) {
+    this._binaryType = value;
+    if (this._ws) {
+      this._ws.binaryType = value;
     }
-    return globalThis[globalKey];
-  }
-  let globalObj;
-  if (typeof window !== "undefined") {
-    globalObj = window;
-  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    globalObj = Function("return this")();
-  } else if (typeof self !== "undefined") {
-    globalObj = self;
-  } else {
-    console.warn("Unable to find global object, using local instance");
-    return {
-      currentDependencyTracker: null,
-      currentSubscriptionsTracker: null
-    };
-  }
-  if (!globalObj[globalKey]) {
-    globalObj[globalKey] = {
-      currentDependencyTracker: null,
-      currentSubscriptionsTracker: null
-    };
-  }
-  return globalObj[globalKey];
-}, "getGlobalReactiveStore");
-var reactiveStore = getGlobalReactiveStore();
-var trackDependency = /* @__PURE__ */ __name((signal2) => {
-  if (reactiveStore.currentDependencyTracker) {
-    reactiveStore.currentDependencyTracker(signal2);
-  }
-}, "trackDependency");
-function signal(defaultValue) {
-  let subject;
-  if (Array.isArray(defaultValue)) {
-    subject = new ArraySubject(defaultValue);
-  } else if (typeof defaultValue === "object" && defaultValue !== null) {
-    subject = new ObjectSubject(defaultValue);
-  } else {
-    subject = new BehaviorSubject(defaultValue);
-  }
-  const getValue = /* @__PURE__ */ __name(() => {
-    if (subject instanceof ArraySubject) {
-      return subject.items;
-    } else if (subject instanceof ObjectSubject) {
-      return subject.obj;
+  }
+  /**
+   * Returns the number or connection retries
+   */
+  get retryCount() {
+    return Math.max(this._retryCount, 0);
+  }
+  /**
+   * The number of bytes of data that have been queued using calls to send() but not yet
+   * transmitted to the network. This value resets to zero once all queued data has been sent.
+   * This value does not reset to zero when the connection is closed; if you keep calling send(),
+   * this will continue to climb. Read only
+   */
+  get bufferedAmount() {
+    const bytes = this._messageQueue.reduce((acc, message) => {
+      if (typeof message === "string") {
+        acc += message.length;
+      } else if (message instanceof Blob) {
+        acc += message.size;
+      } else {
+        acc += message.byteLength;
+      }
+      return acc;
+    }, 0);
+    return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+  }
+  /**
+   * The extensions selected by the server. This is currently only the empty string or a list of
+   * extensions as negotiated by the connection
+   */
+  get extensions() {
+    return this._ws ? this._ws.extensions : "";
+  }
+  /**
+   * A string indicating the name of the sub-protocol the server selected;
+   * this will be one of the strings specified in the protocols parameter when creating the
+   * WebSocket object
+   */
+  get protocol() {
+    return this._ws ? this._ws.protocol : "";
+  }
+  /**
+   * The current state of the connection; this is one of the Ready state constants
+   */
+  get readyState() {
+    if (this._ws) {
+      return this._ws.readyState;
     }
-    return subject.value;
-  }, "getValue");
-  const fn = /* @__PURE__ */ __name(function() {
-    trackDependency(fn);
-    return getValue();
-  }, "fn");
-  fn.set = (value) => {
-    if (subject instanceof ArraySubject) {
-      subject.items = value;
-    } else if (subject instanceof ObjectSubject) {
-      subject.obj = value;
+    return this._options.startClosed
+      ? _ReconnectingWebSocket.CLOSED
+      : _ReconnectingWebSocket.CONNECTING;
+  }
+  /**
+   * The URL as resolved by the constructor
+   */
+  get url() {
+    return this._ws ? this._ws.url : "";
+  }
+  /**
+   * Whether the websocket object is now in reconnectable state
+   */
+  get shouldReconnect() {
+    return this._shouldReconnect;
+  }
+  /**
+   * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+   */
+  onclose = null;
+  /**
+   * An event listener to be called when an error occurs
+   */
+  onerror = null;
+  /**
+   * An event listener to be called when a message is received from the server
+   */
+  onmessage = null;
+  /**
+   * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+   * this indicates that the connection is ready to send and receive data
+   */
+  onopen = null;
+  /**
+   * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+   * CLOSED, this method does nothing
+   */
+  close(code = 1e3, reason) {
+    this._closeCalled = true;
+    this._shouldReconnect = false;
+    this._clearTimeouts();
+    if (!this._ws) {
+      this._debug("close enqueued: no ws instance");
+      return;
+    }
+    if (this._ws.readyState === this.CLOSED) {
+      this._debug("close: already closed");
+      return;
+    }
+    this._ws.close(code, reason);
+  }
+  /**
+   * Closes the WebSocket connection or connection attempt and connects again.
+   * Resets retry counter;
+   */
+  reconnect(code, reason) {
+    this._shouldReconnect = true;
+    this._closeCalled = false;
+    this._retryCount = -1;
+    if (!this._ws || this._ws.readyState === this.CLOSED) {
+      this._connect();
     } else {
-      subject.next(value);
+      this._disconnect(code, reason);
+      this._connect();
     }
-  };
-  fn._isFrozen = false;
-  fn.freeze = () => {
-    fn._isFrozen = true;
-  };
-  fn.unfreeze = () => {
-    fn._isFrozen = false;
-    if (subject instanceof ArraySubject) {
-      subject.next({
-        type: "init",
-        items: subject.items
-      });
-    } else if (subject instanceof ObjectSubject) {
-      subject.next({
-        type: "init",
-        value: subject.obj
-      });
+  }
+  /**
+   * Enqueue specified data to be transmitted to the server over the WebSocket connection
+   */
+  send(data) {
+    if (this._ws && this._ws.readyState === this.OPEN) {
+      this._debug("send", data);
+      this._ws.send(data);
     } else {
-      subject.next(subject.value);
+      const { maxEnqueuedMessages = DEFAULT.maxEnqueuedMessages } =
+        this._options;
+      if (this._messageQueue.length < maxEnqueuedMessages) {
+        this._debug("enqueue", data);
+        this._messageQueue.push(data);
+      }
     }
+  }
+  _debug(...args) {
+    if (this._options.debug) {
+      this._debugLogger("RWS>", ...args);
+    }
+  }
+  _getNextDelay() {
+    const {
+      reconnectionDelayGrowFactor = DEFAULT.reconnectionDelayGrowFactor,
+      minReconnectionDelay = DEFAULT.minReconnectionDelay,
+      maxReconnectionDelay = DEFAULT.maxReconnectionDelay
+    } = this._options;
+    let delay = 0;
+    if (this._retryCount > 0) {
+      delay =
+        minReconnectionDelay *
+        reconnectionDelayGrowFactor ** (this._retryCount - 1);
+      if (delay > maxReconnectionDelay) {
+        delay = maxReconnectionDelay;
+      }
+    }
+    this._debug("next delay", delay);
+    return delay;
+  }
+  _wait() {
+    return new Promise((resolve) => {
+      setTimeout(resolve, this._getNextDelay());
+    });
+  }
+  _getNextProtocols(protocolsProvider) {
+    if (!protocolsProvider) return Promise.resolve(null);
+    if (
+      typeof protocolsProvider === "string" ||
+      Array.isArray(protocolsProvider)
+    ) {
+      return Promise.resolve(protocolsProvider);
+    }
+    if (typeof protocolsProvider === "function") {
+      const protocols = protocolsProvider();
+      if (!protocols) return Promise.resolve(null);
+      if (typeof protocols === "string" || Array.isArray(protocols)) {
+        return Promise.resolve(protocols);
+      }
+      if (protocols.then) {
+        return protocols;
+      }
+    }
+    throw Error("Invalid protocols");
+  }
+  _getNextUrl(urlProvider) {
+    if (typeof urlProvider === "string") {
+      return Promise.resolve(urlProvider);
+    }
+    if (typeof urlProvider === "function") {
+      const url = urlProvider();
+      if (typeof url === "string") {
+        return Promise.resolve(url);
+      }
+      if (url.then) {
+        return url;
+      }
+    }
+    throw Error("Invalid URL");
+  }
+  _connect() {
+    if (this._connectLock || !this._shouldReconnect) {
+      return;
+    }
+    this._connectLock = true;
+    const {
+      maxRetries = DEFAULT.maxRetries,
+      connectionTimeout = DEFAULT.connectionTimeout
+    } = this._options;
+    if (this._retryCount >= maxRetries) {
+      this._debug("max retries reached", this._retryCount, ">=", maxRetries);
+      return;
+    }
+    this._retryCount++;
+    this._debug("connect", this._retryCount);
+    this._removeListeners();
+    this._wait()
+      .then(() =>
+        Promise.all([
+          this._getNextUrl(this._url),
+          this._getNextProtocols(this._protocols || null)
+        ])
+      )
+      .then(([url, protocols]) => {
+        if (this._closeCalled) {
+          this._connectLock = false;
+          return;
+        }
+        if (
+          !this._options.WebSocket &&
+          typeof WebSocket === "undefined" &&
+          !didWarnAboutMissingWebSocket
+        ) {
+          console.error(`\u203C\uFE0F No WebSocket implementation available. You should define options.WebSocket. 
+
+For example, if you're using node.js, run \`npm install ws\`, and then in your code:
+
+import PartySocket from 'partysocket';
+import WS from 'ws';
+
+const partysocket = new PartySocket({
+  host: "127.0.0.1:1999",
+  room: "test-room",
+  WebSocket: WS
+});
+
+`);
+          didWarnAboutMissingWebSocket = true;
+        }
+        const WS = this._options.WebSocket || WebSocket;
+        this._debug("connect", { url, protocols });
+        this._ws = protocols ? new WS(url, protocols) : new WS(url);
+        this._ws.binaryType = this._binaryType;
+        this._connectLock = false;
+        this._addListeners();
+        this._connectTimeout = setTimeout(
+          () => this._handleTimeout(),
+          connectionTimeout
+        );
+      })
+      .catch((err) => {
+        this._connectLock = false;
+        this._handleError(new Events.ErrorEvent(Error(err.message), this));
+      });
+  }
+  _handleTimeout() {
+    this._debug("timeout event");
+    this._handleError(new Events.ErrorEvent(Error("TIMEOUT"), this));
+  }
+  _disconnect(code = 1e3, reason) {
+    this._clearTimeouts();
+    if (!this._ws) {
+      return;
+    }
+    this._removeListeners();
+    try {
+      if (this._ws.readyState === this.OPEN) {
+        this._ws.close(code, reason);
+      }
+      this._handleClose(new Events.CloseEvent(code, reason, this));
+    } catch (error) {}
+  }
+  _acceptOpen() {
+    this._debug("accept open");
+    this._retryCount = 0;
+  }
+  _handleOpen = (event) => {
+    this._debug("open event");
+    const { minUptime = DEFAULT.minUptime } = this._options;
+    clearTimeout(this._connectTimeout);
+    this._uptimeTimeout = setTimeout(() => this._acceptOpen(), minUptime);
+    assert(this._ws, "WebSocket is not defined");
+    this._ws.binaryType = this._binaryType;
+    this._messageQueue.forEach((message) => {
+      var _a2;
+      return (_a2 = this._ws) == null ? void 0 : _a2.send(message);
+    });
+    this._messageQueue = [];
+    if (this.onopen) {
+      this.onopen(event);
+    }
+    this.dispatchEvent(cloneEvent(event));
   };
-  fn.mutate = (mutateFn) => {
-    const value = getValue();
-    mutateFn(value);
+  _handleMessage = (event) => {
+    this._debug("message event");
+    if (this.onmessage) {
+      this.onmessage(event);
+    }
+    this.dispatchEvent(cloneEvent(event));
   };
-  fn.update = (updateFn) => {
-    const updatedValue = updateFn(getValue());
-    fn.set(updatedValue);
+  _handleError = (event) => {
+    this._debug("error event", event.message);
+    this._disconnect(void 0, event.message === "TIMEOUT" ? "timeout" : void 0);
+    if (this.onerror) {
+      this.onerror(event);
+    }
+    this._debug("exec error listeners");
+    this.dispatchEvent(cloneEvent(event));
+    this._connect();
   };
-  fn.observable = subject.asObservable().pipe(filter(() => !fn._isFrozen));
-  fn._subject = subject;
-  return fn;
-}
-__name(signal, "signal");
-function isSignal(value) {
-  return !!(value && value.observable);
-}
-__name(isSignal, "isSignal");
-function isComputed(value) {
-  return isSignal(value) && !!value.dependencies;
-}
-__name(isComputed, "isComputed");
-function computed(computeFunction, disposableFn) {
-  const dependencies = /* @__PURE__ */ new Set();
-  let init = true;
-  let lastComputedValue;
-  const previousTracker = reactiveStore.currentDependencyTracker;
-  reactiveStore.currentDependencyTracker = (signal2) => {
-    dependencies.add(signal2);
+  _handleClose = (event) => {
+    this._debug("close event");
+    this._clearTimeouts();
+    if (this._shouldReconnect) {
+      this._connect();
+    }
+    if (this.onclose) {
+      this.onclose(event);
+    }
+    this.dispatchEvent(cloneEvent(event));
   };
-  lastComputedValue = computeFunction();
-  if (computeFunction["isEffect"]) {
-    disposableFn = lastComputedValue;
-  }
-  reactiveStore.currentDependencyTracker = previousTracker;
-  const computedObservable = combineLatest([
-    ...dependencies
-  ].map((signal2) => signal2.observable)).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
-  const fn = /* @__PURE__ */ __name(function() {
-    trackDependency(fn);
-    return lastComputedValue;
-  }, "fn");
-  fn.observable = computedObservable;
-  fn.subscription = computedObservable.subscribe((value) => {
-    lastComputedValue = value;
-  });
-  fn.dependencies = dependencies;
-  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
-  init = false;
-  return fn;
-}
-__name(computed, "computed");
-
-// src/effect.ts
-function effect(fn) {
-  fn["isEffect"] = true;
-  return computed(fn);
-}
-__name(effect, "effect");
+  _removeListeners() {
+    if (!this._ws) {
+      return;
+    }
+    this._debug("removeListeners");
+    this._ws.removeEventListener("open", this._handleOpen);
+    this._ws.removeEventListener("close", this._handleClose);
+    this._ws.removeEventListener("message", this._handleMessage);
+    this._ws.removeEventListener("error", this._handleError);
+  }
+  _addListeners() {
+    if (!this._ws) {
+      return;
+    }
+    this._debug("addListeners");
+    this._ws.addEventListener("open", this._handleOpen);
+    this._ws.addEventListener("close", this._handleClose);
+    this._ws.addEventListener("message", this._handleMessage);
+    this._ws.addEventListener("error", this._handleError);
+  }
+  _clearTimeouts() {
+    clearTimeout(this._connectTimeout);
+    clearTimeout(this._uptimeTimeout);
+  }
+};
+/*!
+ * Reconnecting WebSocket
+ * by Pedro Ladaria <pedro.ladaria@gmail.com>
+ * https://github.com/pladaria/reconnecting-websocket
+ * License MIT
+ */
 
-export { ArraySubject, ObjectSubject, computed, effect, isComputed, isSignal, signal };
+export { CloseEvent, ErrorEvent, ReconnectingWebSocket };
 //# sourceMappingURL=index35.js.map