@nice2dev/ui-graphics 1.3.15 → 1.3.17

package/dist/esm/node_modules/y-websocket/src/y-websocket.js

@@ -1,38 +1,20 @@
-import { publish, subscribe, unsubscribe } from '../../lib0/broadcastchannel.js';
-import { getUnixTime } from '../../lib0/time.js';
-import { writeVarUint, toUint8Array, length, writeVarUint8Array, createEncoder } from '../../lib0/encoding.js';
-import { readVarUint, createDecoder, readVarUint8Array } from '../../lib0/decoding.js';
-import { writeSyncStep1, writeUpdate, writeSyncStep2, readSyncMessage, messageYjsSyncStep2 } from '../../y-protocols/sync.js';
-import { readAuthMessage } from '../../y-protocols/auth.js';
-import { Awareness, encodeAwarenessUpdate, removeAwarenessStates, applyAwarenessUpdate } from '../../y-protocols/awareness.js';
-import { ObservableV2 } from '../../lib0/observable.js';
-import { min, pow } from '../../lib0/math.js';
-import { encodeQueryParams } from '../../lib0/url.js';
-import { isNode } from '../../lib0/environment.js';
-
-/**
- * @module provider/websocket
- */
-
-
+import { publish, subscribe, unsubscribe } from "../../lib0/broadcastchannel.js";
+import { getUnixTime } from "../../lib0/time.js";
+import { writeVarUint, toUint8Array, length, writeVarUint8Array, createEncoder } from "../../lib0/encoding.js";
+import { readVarUint, createDecoder, readVarUint8Array } from "../../lib0/decoding.js";
+import { writeSyncStep1, writeUpdate, writeSyncStep2, readSyncMessage, messageYjsSyncStep2 } from "../../y-protocols/sync.js";
+import { readAuthMessage } from "../../y-protocols/auth.js";
+import { Awareness, encodeAwarenessUpdate, removeAwarenessStates, applyAwarenessUpdate } from "../../y-protocols/awareness.js";
+import { ObservableV2 } from "../../lib0/observable.js";
+import { min, pow } from "../../lib0/math.js";
+import { encodeQueryParams } from "../../lib0/url.js";
+import { isNode } from "../../lib0/environment.js";
 const messageSync = 0;
 const messageQueryAwareness = 3;
 const messageAwareness = 1;
 const messageAuth = 2;
-
-/**
- *                       encoder,          decoder,          provider,          emitSynced, messageType
- * @type {Array<function(encoding.Encoder, decoding.Decoder, WebsocketProvider, boolean,    number):void>}
- */
 const messageHandlers = [];
-
-messageHandlers[messageSync] = (
-  encoder,
-  decoder,
-  provider,
-  emitSynced,
-  _messageType
-) => {
+messageHandlers[messageSync] = (encoder, decoder, provider, emitSynced, _messageType) => {
   writeVarUint(encoder, messageSync);
   const syncMessageType = readSyncMessage(
     decoder,
@@ -40,21 +22,11 @@ messageHandlers[messageSync] = (
     provider.doc,
     provider
   );
-  if (
-    emitSynced && syncMessageType === messageYjsSyncStep2 &&
-    !provider.synced
-  ) {
+  if (emitSynced && syncMessageType === messageYjsSyncStep2 && !provider.synced) {
     provider.synced = true;
   }
 };
-
-messageHandlers[messageQueryAwareness] = (
-  encoder,
-  _decoder,
-  provider,
-  _emitSynced,
-  _messageType
-) => {
+messageHandlers[messageQueryAwareness] = (encoder, _decoder, provider, _emitSynced, _messageType) => {
   writeVarUint(encoder, messageAwareness);
   writeVarUint8Array(
     encoder,
@@ -64,97 +36,60 @@ messageHandlers[messageQueryAwareness] = (
     )
   );
 };
-
-messageHandlers[messageAwareness] = (
-  _encoder,
-  decoder,
-  provider,
-  _emitSynced,
-  _messageType
-) => {
+messageHandlers[messageAwareness] = (_encoder, decoder, provider, _emitSynced, _messageType) => {
   applyAwarenessUpdate(
     provider.awareness,
     readVarUint8Array(decoder),
     provider
   );
 };
-
-messageHandlers[messageAuth] = (
-  _encoder,
-  decoder,
-  provider,
-  _emitSynced,
-  _messageType
-) => {
+messageHandlers[messageAuth] = (_encoder, decoder, provider, _emitSynced, _messageType) => {
   readAuthMessage(
     decoder,
     provider.doc,
     (_ydoc, reason) => permissionDeniedHandler(provider, reason)
   );
 };
-
-// @todo - this should depend on awareness.outdatedTime
-const messageReconnectTimeout = 30000;
-
-/**
- * @param {WebsocketProvider} provider
- * @param {string} reason
- */
-const permissionDeniedHandler = (provider, reason) =>
-  console.warn(`Permission denied to access ${provider.url}.\n${reason}`);
-
-/**
- * @param {WebsocketProvider} provider
- * @param {Uint8Array} buf
- * @param {boolean} emitSynced
- * @return {encoding.Encoder}
- */
+const messageReconnectTimeout = 3e4;
+const permissionDeniedHandler = (provider, reason) => console.warn(`Permission denied to access ${provider.url}.
+${reason}`);
 const readMessage = (provider, buf, emitSynced) => {
   const decoder = createDecoder(buf);
   const encoder = createEncoder();
   const messageType = readVarUint(decoder);
   const messageHandler = provider.messageHandlers[messageType];
-  if (/** @type {any} */ (messageHandler)) {
+  if (
+    /** @type {any} */
+    messageHandler
+  ) {
     messageHandler(encoder, decoder, provider, emitSynced, messageType);
   } else {
-    console.error('Unable to compute message');
+    console.error("Unable to compute message");
   }
-  return encoder
+  return encoder;
 };
-
-/**
- * Outsource this function so that a new websocket connection is created immediately.
- * I suspect that the `ws.onclose` event is not always fired if there are network issues.
- *
- * @param {WebsocketProvider} provider
- * @param {WebSocket} ws
- * @param {CloseEvent | null} event
- */
 const closeWebsocketConnection = (provider, ws, event) => {
   if (ws === provider.ws) {
-    provider.emit('connection-close', [event, provider]);
+    provider.emit("connection-close", [event, provider]);
     provider.ws = null;
     ws.close();
     provider.wsconnecting = false;
     if (provider.wsconnected) {
       provider.wsconnected = false;
       provider.synced = false;
-      // update awareness (all users except local left)
       removeAwarenessStates(
         provider.awareness,
-        Array.from(provider.awareness.getStates().keys()).filter((client) =>
-          client !== provider.doc.clientID
+        Array.from(provider.awareness.getStates().keys()).filter(
+          (client) => client !== provider.doc.clientID
         ),
         provider
       );
-      provider.emit('status', [{
-        status: 'disconnected'
+      provider.emit("status", [{
+        status: "disconnected"
       }]);
     } else {
       provider.wsUnsuccessfulReconnects++;
     }
-    // Start with no reconnect timeout and increase timeout by
-    // using exponential backoff starting with 100ms
     setTimeout(
       setupWS,
       min(
@@ -165,19 +100,14 @@ const closeWebsocketConnection = (provider, ws, event) => {
     );
   }
 };
-
-/**
- * @param {WebsocketProvider} provider
- */
 const setupWS = (provider) => {
   if (provider.shouldConnect && provider.ws === null) {
     const websocket = new provider._WS(provider.url, provider.protocols);
-    websocket.binaryType = 'arraybuffer';
+    websocket.binaryType = "arraybuffer";
     provider.ws = websocket;
     provider.wsconnecting = true;
     provider.wsconnected = false;
     provider.synced = false;
-
     websocket.onmessage = (event) => {
       provider.wsLastMessageReceived = getUnixTime();
       const encoder = readMessage(provider, new Uint8Array(event.data), true);
@@ -186,7 +116,7 @@ const setupWS = (provider) => {
       }
     };
     websocket.onerror = (event) => {
-      provider.emit('connection-error', [event, provider]);
+      provider.emit("connection-error", [event, provider]);
     };
     websocket.onclose = (event) => {
       closeWebsocketConnection(provider, websocket, event);
@@ -196,15 +126,13 @@ const setupWS = (provider) => {
       provider.wsconnecting = false;
       provider.wsconnected = true;
       provider.wsUnsuccessfulReconnects = 0;
-      provider.emit('status', [{
-        status: 'connected'
+      provider.emit("status", [{
+        status: "connected"
       }]);
-      // always send sync step 1 when connected
       const encoder = createEncoder();
       writeVarUint(encoder, messageSync);
       writeSyncStep1(encoder, provider.doc);
       websocket.send(toUint8Array(encoder));
-      // broadcast local awareness state
       if (provider.awareness.getLocalState() !== null) {
         const encoderAwarenessState = createEncoder();
         writeVarUint(encoderAwarenessState, messageAwareness);
@@ -217,16 +145,11 @@ const setupWS = (provider) => {
         websocket.send(toUint8Array(encoderAwarenessState));
       }
     };
-    provider.emit('status', [{
-      status: 'connecting'
+    provider.emit("status", [{
+      status: "connecting"
     }]);
   }
 };
-
-/**
- * @param {WebsocketProvider} provider
- * @param {ArrayBuffer} buf
- */
 const broadcastMessage = (provider, buf) => {
   const ws = provider.ws;
   if (provider.wsconnected && ws && ws.readyState === ws.OPEN) {
@@ -236,20 +159,6 @@ const broadcastMessage = (provider, buf) => {
     publish(provider.bcChannel, buf, provider);
   }
 };
-
-/**
- * Websocket Provider for Yjs. Creates a websocket connection to sync the shared document.
- * The document name is attached to the provided url. I.e. the following example
- * creates a websocket connection to http://localhost:1234/my-document-name
- *
- * @example
- *   import * as Y from 'yjs'
- *   import { WebsocketProvider } from 'y-websocket'
- *   const doc = new Y.Doc()
- *   const provider = new WebsocketProvider('http://localhost:1234', 'my-document-name', doc)
- *
- * @extends {ObservableV2<{ 'connection-close': (event: CloseEvent | null,  provider: WebsocketProvider) => any, 'status': (event: { status: 'connected' | 'disconnected' | 'connecting' }) => any, 'connection-error': (event: Event, provider: WebsocketProvider) => any, 'sync': (state: boolean) => any }>}
- */
 class WebsocketProvider extends ObservableV2 {
   /**
    * @param {string} serverUrl
@@ -265,7 +174,7 @@ class WebsocketProvider extends ObservableV2 {
    * @param {number} [opts.maxBackoffTime] Maximum amount of time to wait before trying to reconnect (we try to reconnect using exponential backoff)
    * @param {boolean} [opts.disableBc] Disable cross-tab BroadcastChannel communication
    */
-  constructor (serverUrl, roomname, doc, {
+  constructor(serverUrl, roomname, doc, {
     connect = true,
     awareness = new Awareness(doc),
     params = {},
@@ -276,18 +185,12 @@ class WebsocketProvider extends ObservableV2 {
     disableBc = false
   } = {}) {
     super();
-    // ensure that url is always ends with /
-    while (serverUrl[serverUrl.length - 1] === '/') {
+    while (serverUrl[serverUrl.length - 1] === "/") {
       serverUrl = serverUrl.slice(0, serverUrl.length - 1);
     }
     this.serverUrl = serverUrl;
-    this.bcChannel = serverUrl + '/' + roomname;
+    this.bcChannel = serverUrl + "/" + roomname;
     this.maxBackoffTime = maxBackoffTime;
-    /**
-     * The specified url parameters. This can be safely updated. The changed parameters will be used
-     * when a new connection is established.
-     * @type {Object<string,string>}
-     */
     this.params = params;
     this.protocols = protocols;
     this.roomname = roomname;
@@ -300,41 +203,22 @@ class WebsocketProvider extends ObservableV2 {
     this.disableBc = disableBc;
     this.wsUnsuccessfulReconnects = 0;
     this.messageHandlers = messageHandlers.slice();
-    /**
-     * @type {boolean}
-     */
     this._synced = false;
-    /**
-     * @type {WebSocket?}
-     */
     this.ws = null;
     this.wsLastMessageReceived = 0;
-    /**
-     * Whether to connect to other peers or not
-     * @type {boolean}
-     */
     this.shouldConnect = connect;
-
-    /**
-     * @type {number}
-     */
     this._resyncInterval = 0;
     if (resyncInterval > 0) {
-      this._resyncInterval = /** @type {any} */ (setInterval(() => {
+      this._resyncInterval = /** @type {any} */
+      setInterval(() => {
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-          // resend sync step 1
           const encoder = createEncoder();
           writeVarUint(encoder, messageSync);
           writeSyncStep1(encoder, doc);
           this.ws.send(toUint8Array(encoder));
         }
-      }, resyncInterval));
+      }, resyncInterval);
     }
-
-    /**
-     * @param {ArrayBuffer} data
-     * @param {any} origin
-     */
     this._bcSubscriber = (data, origin) => {
       if (origin !== this) {
         const encoder = readMessage(this, new Uint8Array(data), false);
@@ -343,11 +227,6 @@ class WebsocketProvider extends ObservableV2 {
         }
       }
     };
-    /**
-     * Listens to Yjs updates and sends them to remote peers (ws and broadcastchannel)
-     * @param {Uint8Array} update
-     * @param {any} origin
-     */
     this._updateHandler = (update, origin) => {
       if (origin !== this) {
         const encoder = createEncoder();
@@ -356,11 +235,7 @@ class WebsocketProvider extends ObservableV2 {
         broadcastMessage(this, toUint8Array(encoder));
       }
     };
-    this.doc.on('update', this._updateHandler);
-    /**
-     * @param {any} changed
-     * @param {any} _origin
-     */
+    this.doc.on("update", this._updateHandler);
     this._awarenessUpdateHandler = ({ added, updated, removed }, _origin) => {
       const changedClients = added.concat(updated).concat(removed);
       const encoder = createEncoder();
@@ -375,85 +250,74 @@ class WebsocketProvider extends ObservableV2 {
       removeAwarenessStates(
         this.awareness,
         [doc.clientID],
-        'app closed'
+        "app closed"
       );
     };
-    if (isNode && typeof process !== 'undefined') {
-      process.on('exit', this._exitHandler);
+    if (isNode && typeof process !== "undefined") {
+      process.on("exit", this._exitHandler);
     }
-    awareness.on('update', this._awarenessUpdateHandler);
-    this._checkInterval = /** @type {any} */ (setInterval(() => {
-      if (
-        this.wsconnected &&
-        messageReconnectTimeout <
-          getUnixTime() - this.wsLastMessageReceived
-      ) {
-        // no message received in a long time - not even your own awareness
-        // updates (which are updated every 15 seconds)
-        closeWebsocketConnection(this, /** @type {WebSocket} */ (this.ws), null);
+    awareness.on("update", this._awarenessUpdateHandler);
+    this._checkInterval = /** @type {any} */
+    setInterval(() => {
+      if (this.wsconnected && messageReconnectTimeout < getUnixTime() - this.wsLastMessageReceived) {
+        closeWebsocketConnection(
+          this,
+          /** @type {WebSocket} */
+          this.ws,
+          null
+        );
       }
-    }, messageReconnectTimeout / 10));
+    }, messageReconnectTimeout / 10);
     if (connect) {
       this.connect();
     }
   }
-
-  get url () {
+  get url() {
     const encodedParams = encodeQueryParams(this.params);
-    return this.serverUrl + '/' + this.roomname +
-      (encodedParams.length === 0 ? '' : '?' + encodedParams)
+    return this.serverUrl + "/" + this.roomname + (encodedParams.length === 0 ? "" : "?" + encodedParams);
   }
-
   /**
    * @type {boolean}
    */
-  get synced () {
-    return this._synced
+  get synced() {
+    return this._synced;
   }
-
-  set synced (state) {
+  set synced(state) {
     if (this._synced !== state) {
       this._synced = state;
-      // @ts-ignore
-      this.emit('synced', [state]);
-      this.emit('sync', [state]);
+      this.emit("synced", [state]);
+      this.emit("sync", [state]);
     }
   }
-
-  destroy () {
+  destroy() {
     if (this._resyncInterval !== 0) {
       clearInterval(this._resyncInterval);
     }
     clearInterval(this._checkInterval);
     this.disconnect();
-    if (isNode && typeof process !== 'undefined') {
-      process.off('exit', this._exitHandler);
+    if (isNode && typeof process !== "undefined") {
+      process.off("exit", this._exitHandler);
     }
-    this.awareness.off('update', this._awarenessUpdateHandler);
-    this.doc.off('update', this._updateHandler);
+    this.awareness.off("update", this._awarenessUpdateHandler);
+    this.doc.off("update", this._updateHandler);
     super.destroy();
   }
-
-  connectBc () {
+  connectBc() {
     if (this.disableBc) {
-      return
+      return;
     }
     if (!this.bcconnected) {
       subscribe(this.bcChannel, this._bcSubscriber);
       this.bcconnected = true;
     }
-    // send sync step1 to bc
-    // write sync step 1
     const encoderSync = createEncoder();
     writeVarUint(encoderSync, messageSync);
     writeSyncStep1(encoderSync, this.doc);
     publish(this.bcChannel, toUint8Array(encoderSync), this);
-    // broadcast local state
     const encoderState = createEncoder();
     writeVarUint(encoderState, messageSync);
     writeSyncStep2(encoderState, this.doc);
     publish(this.bcChannel, toUint8Array(encoderState), this);
-    // write queryAwareness
     const encoderAwarenessQuery = createEncoder();
     writeVarUint(encoderAwarenessQuery, messageQueryAwareness);
     publish(
@@ -461,7 +325,6 @@ class WebsocketProvider extends ObservableV2 {
       toUint8Array(encoderAwarenessQuery),
       this
     );
-    // broadcast local awareness state
     const encoderAwarenessState = createEncoder();
     writeVarUint(encoderAwarenessState, messageAwareness);
     writeVarUint8Array(
@@ -476,16 +339,14 @@ class WebsocketProvider extends ObservableV2 {
       this
     );
   }
-
-  disconnectBc () {
-    // broadcast message with local awareness state set to null (indicating disconnect)
+  disconnectBc() {
     const encoder = createEncoder();
     writeVarUint(encoder, messageAwareness);
     writeVarUint8Array(
       encoder,
       encodeAwarenessUpdate(this.awareness, [
         this.doc.clientID
-      ], new Map())
+      ], /* @__PURE__ */ new Map())
     );
     broadcastMessage(this, toUint8Array(encoder));
     if (this.bcconnected) {
@@ -493,16 +354,14 @@ class WebsocketProvider extends ObservableV2 {
       this.bcconnected = false;
     }
   }
-
-  disconnect () {
+  disconnect() {
     this.shouldConnect = false;
     this.disconnectBc();
     if (this.ws !== null) {
       closeWebsocketConnection(this, this.ws, null);
     }
   }
-
-  connect () {
+  connect() {
     this.shouldConnect = true;
     if (!this.wsconnected && this.ws === null) {
       setupWS(this);
@@ -510,5 +369,10 @@ class WebsocketProvider extends ObservableV2 {
     }
   }
 }
-
-export { WebsocketProvider, messageAuth, messageAwareness, messageQueryAwareness, messageSync };
+export {
+  WebsocketProvider,
+  messageAuth,
+  messageAwareness,
+  messageQueryAwareness,
+  messageSync
+};