@rpgjs/client 5.0.0-alpha.8 → 5.0.0-alpha.9

package/dist/index36.js

@@ -1,501 +1,316 @@
-// 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;
-  }
-};
-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 Events = {
-  Event,
-  ErrorEvent,
-  CloseEvent
-};
-function assert(condition, msg) {
-  if (!condition) {
-    throw new Error(msg);
-  }
-}
-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;
-  }
-  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;
-  }
-  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;
-    }
-  }
-  /**
-   * 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 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);
+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")
+    });
   }
-  /**
-   * 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 {
-      this._disconnect(code, reason);
-      this._connect();
-    }
+  get items() {
+    return this._items;
   }
-  /**
-   * 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 {
-      const { maxEnqueuedMessages = DEFAULT.maxEnqueuedMessages } =
-        this._options;
-      if (this._messageQueue.length < maxEnqueuedMessages) {
-        this._debug("enqueue", data);
-        this._messageQueue.push(data);
-      }
-    }
+  set items(newItems) {
+    this.createProxy(newItems);
+    this.next({
+      type: "reset",
+      items: newItems
+    });
   }
-  _debug(...args) {
-    if (this._options.debug) {
-      this._debugLogger("RWS>", ...args);
-    }
+};
+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")
+    });
   }
-  _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;
+  get obj() {
+    return this._obj;
   }
-  _wait() {
-    return new Promise((resolve) => {
-      setTimeout(resolve, this._getNextDelay());
+  set obj(newObj) {
+    this.createProxy(newObj);
+    this.next({
+      type: "reset",
+      value: newObj
     });
   }
-  _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;
-      }
+};
+var getGlobalReactiveStore = /* @__PURE__ */ __name(() => {
+  const globalKey = "__REACTIVE_STORE__";
+  if (typeof globalThis !== "undefined") {
+    if (!globalThis[globalKey]) {
+      globalThis[globalKey] = {
+        currentDependencyTracker: null,
+        currentSubscriptionsTracker: null
+      };
     }
-    throw Error("Invalid URL");
-  }
-  _connect() {
-    if (this._connectLock || !this._shouldReconnect) {
-      return;
+    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;
     }
-    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;
+    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;
+    } else {
+      subject.next(value);
     }
-    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));
+  };
+  fn._isFrozen = false;
+  fn.freeze = () => {
+    fn._isFrozen = true;
+  };
+  fn.unfreeze = () => {
+    fn._isFrozen = false;
+    if (subject instanceof ArraySubject) {
+      subject.next({
+        type: "init",
+        items: subject.items
       });
-  }
-  _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);
+    } else if (subject instanceof ObjectSubject) {
+      subject.next({
+        type: "init",
+        value: subject.obj
+      });
+    } else {
+      subject.next(subject.value);
     }
-    this.dispatchEvent(cloneEvent(event));
   };
-  _handleMessage = (event) => {
-    this._debug("message event");
-    if (this.onmessage) {
-      this.onmessage(event);
-    }
-    this.dispatchEvent(cloneEvent(event));
+  fn.mutate = (mutateFn) => {
+    const value = getValue();
+    mutateFn(value);
   };
-  _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.update = (updateFn) => {
+    const updatedValue = updateFn(getValue());
+    fn.set(updatedValue);
   };
-  _handleClose = (event) => {
-    this._debug("close event");
-    this._clearTimeouts();
-    if (this._shouldReconnect) {
-      this._connect();
-    }
-    if (this.onclose) {
-      this.onclose(event);
-    }
-    this.dispatchEvent(cloneEvent(event));
+  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);
   };
-  _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
- */
+  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");
 
-export { CloseEvent, ErrorEvent, ReconnectingWebSocket };
+export { ArraySubject, ObjectSubject, computed, effect, isComputed, isSignal, signal };
 //# sourceMappingURL=index36.js.map