@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/node_modules/@microsoft/signalr/dist/esm/MessageBuffer.js

@@ -1,196 +1,160 @@
-import { MessageType } from './IHubProtocol.js';
-import { isArrayBuffer } from './Utils.js';
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-/** @private */
-class MessageBuffer {
-    constructor(protocol, connection, bufferSize) {
-        this._bufferSize = 100000;
-        this._messages = [];
-        this._totalMessageCount = 0;
-        this._waitForSequenceMessage = false;
-        // Message IDs start at 1 and always increment by 1
-        this._nextReceivingSequenceId = 1;
-        this._latestReceivedSequenceId = 0;
-        this._bufferedByteCount = 0;
-        this._reconnectInProgress = false;
-        this._protocol = protocol;
-        this._connection = connection;
-        this._bufferSize = bufferSize;
-    }
-    async _send(message) {
-        const serializedMessage = this._protocol.writeMessage(message);
-        let backpressurePromise = Promise.resolve();
-        // Only count invocation messages. Acks, pings, etc. don't need to be resent on reconnect
-        if (this._isInvocationMessage(message)) {
-            this._totalMessageCount++;
-            let backpressurePromiseResolver = () => { };
-            let backpressurePromiseRejector = () => { };
-            if (isArrayBuffer(serializedMessage)) {
-                this._bufferedByteCount += serializedMessage.byteLength;
-            }
-            else {
-                this._bufferedByteCount += serializedMessage.length;
-            }
-            if (this._bufferedByteCount >= this._bufferSize) {
-                backpressurePromise = new Promise((resolve, reject) => {
-                    backpressurePromiseResolver = resolve;
-                    backpressurePromiseRejector = reject;
-                });
-            }
-            this._messages.push(new BufferedItem(serializedMessage, this._totalMessageCount, backpressurePromiseResolver, backpressurePromiseRejector));
-        }
-        try {
-            // If this is set it means we are reconnecting or resending
-            // We don't want to send on a disconnected connection
-            // And we don't want to send if resend is running since that would mean sending
-            // this message twice
-            if (!this._reconnectInProgress) {
-                await this._connection.send(serializedMessage);
-            }
-        }
-        catch {
-            this._disconnected();
-        }
-        await backpressurePromise;
-    }
-    _ack(ackMessage) {
-        let newestAckedMessage = -1;
-        // Find index of newest message being acked
-        for (let index = 0; index < this._messages.length; index++) {
-            const element = this._messages[index];
-            if (element._id <= ackMessage.sequenceId) {
-                newestAckedMessage = index;
-                if (isArrayBuffer(element._message)) {
-                    this._bufferedByteCount -= element._message.byteLength;
-                }
-                else {
-                    this._bufferedByteCount -= element._message.length;
-                }
-                // resolve items that have already been sent and acked
-                element._resolver();
-            }
-            else if (this._bufferedByteCount < this._bufferSize) {
-                // resolve items that now fall under the buffer limit but haven't been acked
-                element._resolver();
-            }
-            else {
-                break;
-            }
-        }
-        if (newestAckedMessage !== -1) {
-            // We're removing everything including the message pointed to, so add 1
-            this._messages = this._messages.slice(newestAckedMessage + 1);
-        }
-    }
-    _shouldProcessMessage(message) {
-        if (this._waitForSequenceMessage) {
-            if (message.type !== MessageType.Sequence) {
-                return false;
-            }
-            else {
-                this._waitForSequenceMessage = false;
-                return true;
-            }
-        }
-        // No special processing for acks, pings, etc.
-        if (!this._isInvocationMessage(message)) {
-            return true;
-        }
-        const currentId = this._nextReceivingSequenceId;
-        this._nextReceivingSequenceId++;
-        if (currentId <= this._latestReceivedSequenceId) {
-            if (currentId === this._latestReceivedSequenceId) {
-                // Should only hit this if we just reconnected and the server is sending
-                // Messages it has buffered, which would mean it hasn't seen an Ack for these messages
-                this._ackTimer();
-            }
-            // Ignore, this is a duplicate message
-            return false;
-        }
-        this._latestReceivedSequenceId = currentId;
-        // Only start the timer for sending an Ack message when we have a message to ack. This also conveniently solves
-        // timer throttling by not having a recursive timer, and by starting the timer via a network call (recv)
-        this._ackTimer();
-        return true;
-    }
-    _resetSequence(message) {
-        if (message.sequenceId > this._nextReceivingSequenceId) {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this._connection.stop(new Error("Sequence ID greater than amount of messages we've received."));
-            return;
-        }
-        this._nextReceivingSequenceId = message.sequenceId;
-    }
-    _disconnected() {
-        this._reconnectInProgress = true;
-        this._waitForSequenceMessage = true;
-    }
-    async _resend() {
-        const sequenceId = this._messages.length !== 0
-            ? this._messages[0]._id
-            : this._totalMessageCount + 1;
-        await this._connection.send(this._protocol.writeMessage({ type: MessageType.Sequence, sequenceId }));
-        // Get a local variable to the _messages, just in case messages are acked while resending
-        // Which would slice the _messages array (which creates a new copy)
-        const messages = this._messages;
-        for (const element of messages) {
-            await this._connection.send(element._message);
-        }
-        this._reconnectInProgress = false;
-    }
-    _dispose(error) {
-        error !== null && error !== void 0 ? error : (error = new Error("Unable to reconnect to server."));
-        // Unblock backpressure if any
-        for (const element of this._messages) {
-            element._rejector(error);
-        }
-    }
-    _isInvocationMessage(message) {
-        // There is no way to check if something implements an interface.
-        // So we individually check the messages in a switch statement.
-        // To make sure we don't miss any message types we rely on the compiler
-        // seeing the function returns a value and it will do the
-        // exhaustive check for us on the switch statement, since we don't use 'case default'
-        switch (message.type) {
-            case MessageType.Invocation:
-            case MessageType.StreamItem:
-            case MessageType.Completion:
-            case MessageType.StreamInvocation:
-            case MessageType.CancelInvocation:
-                return true;
-            case MessageType.Close:
-            case MessageType.Sequence:
-            case MessageType.Ping:
-            case MessageType.Ack:
-                return false;
-        }
-    }
-    _ackTimer() {
-        if (this._ackTimerHandle === undefined) {
-            this._ackTimerHandle = setTimeout(async () => {
-                try {
-                    if (!this._reconnectInProgress) {
-                        await this._connection.send(this._protocol.writeMessage({ type: MessageType.Ack, sequenceId: this._latestReceivedSequenceId }));
-                    }
-                    // Ignore errors, that means the connection is closed and we don't care about the Ack message anymore.
-                }
-                catch { }
-                clearTimeout(this._ackTimerHandle);
-                this._ackTimerHandle = undefined;
-                // 1 second delay so we don't spam Ack messages if there are many messages being received at once.
-            }, 1000);
-        }
-    }
-}
-class BufferedItem {
-    constructor(message, id, resolver, rejector) {
-        this._message = message;
-        this._id = id;
-        this._resolver = resolver;
-        this._rejector = rejector;
-    }
+import { MessageType } from "./IHubProtocol.js";
+import { isArrayBuffer } from "./Utils.js";
+class MessageBuffer {
+  constructor(protocol, connection, bufferSize) {
+    this._bufferSize = 1e5;
+    this._messages = [];
+    this._totalMessageCount = 0;
+    this._waitForSequenceMessage = false;
+    this._nextReceivingSequenceId = 1;
+    this._latestReceivedSequenceId = 0;
+    this._bufferedByteCount = 0;
+    this._reconnectInProgress = false;
+    this._protocol = protocol;
+    this._connection = connection;
+    this._bufferSize = bufferSize;
+  }
+  async _send(message) {
+    const serializedMessage = this._protocol.writeMessage(message);
+    let backpressurePromise = Promise.resolve();
+    if (this._isInvocationMessage(message)) {
+      this._totalMessageCount++;
+      let backpressurePromiseResolver = () => {
+      };
+      let backpressurePromiseRejector = () => {
+      };
+      if (isArrayBuffer(serializedMessage)) {
+        this._bufferedByteCount += serializedMessage.byteLength;
+      } else {
+        this._bufferedByteCount += serializedMessage.length;
+      }
+      if (this._bufferedByteCount >= this._bufferSize) {
+        backpressurePromise = new Promise((resolve, reject) => {
+          backpressurePromiseResolver = resolve;
+          backpressurePromiseRejector = reject;
+        });
+      }
+      this._messages.push(new BufferedItem(serializedMessage, this._totalMessageCount, backpressurePromiseResolver, backpressurePromiseRejector));
+    }
+    try {
+      if (!this._reconnectInProgress) {
+        await this._connection.send(serializedMessage);
+      }
+    } catch {
+      this._disconnected();
+    }
+    await backpressurePromise;
+  }
+  _ack(ackMessage) {
+    let newestAckedMessage = -1;
+    for (let index = 0; index < this._messages.length; index++) {
+      const element = this._messages[index];
+      if (element._id <= ackMessage.sequenceId) {
+        newestAckedMessage = index;
+        if (isArrayBuffer(element._message)) {
+          this._bufferedByteCount -= element._message.byteLength;
+        } else {
+          this._bufferedByteCount -= element._message.length;
+        }
+        element._resolver();
+      } else if (this._bufferedByteCount < this._bufferSize) {
+        element._resolver();
+      } else {
+        break;
+      }
+    }
+    if (newestAckedMessage !== -1) {
+      this._messages = this._messages.slice(newestAckedMessage + 1);
+    }
+  }
+  _shouldProcessMessage(message) {
+    if (this._waitForSequenceMessage) {
+      if (message.type !== MessageType.Sequence) {
+        return false;
+      } else {
+        this._waitForSequenceMessage = false;
+        return true;
+      }
+    }
+    if (!this._isInvocationMessage(message)) {
+      return true;
+    }
+    const currentId = this._nextReceivingSequenceId;
+    this._nextReceivingSequenceId++;
+    if (currentId <= this._latestReceivedSequenceId) {
+      if (currentId === this._latestReceivedSequenceId) {
+        this._ackTimer();
+      }
+      return false;
+    }
+    this._latestReceivedSequenceId = currentId;
+    this._ackTimer();
+    return true;
+  }
+  _resetSequence(message) {
+    if (message.sequenceId > this._nextReceivingSequenceId) {
+      this._connection.stop(new Error("Sequence ID greater than amount of messages we've received."));
+      return;
+    }
+    this._nextReceivingSequenceId = message.sequenceId;
+  }
+  _disconnected() {
+    this._reconnectInProgress = true;
+    this._waitForSequenceMessage = true;
+  }
+  async _resend() {
+    const sequenceId = this._messages.length !== 0 ? this._messages[0]._id : this._totalMessageCount + 1;
+    await this._connection.send(this._protocol.writeMessage({ type: MessageType.Sequence, sequenceId }));
+    const messages = this._messages;
+    for (const element of messages) {
+      await this._connection.send(element._message);
+    }
+    this._reconnectInProgress = false;
+  }
+  _dispose(error) {
+    error !== null && error !== void 0 ? error : error = new Error("Unable to reconnect to server.");
+    for (const element of this._messages) {
+      element._rejector(error);
+    }
+  }
+  _isInvocationMessage(message) {
+    switch (message.type) {
+      case MessageType.Invocation:
+      case MessageType.StreamItem:
+      case MessageType.Completion:
+      case MessageType.StreamInvocation:
+      case MessageType.CancelInvocation:
+        return true;
+      case MessageType.Close:
+      case MessageType.Sequence:
+      case MessageType.Ping:
+      case MessageType.Ack:
+        return false;
+    }
+  }
+  _ackTimer() {
+    if (this._ackTimerHandle === void 0) {
+      this._ackTimerHandle = setTimeout(async () => {
+        try {
+          if (!this._reconnectInProgress) {
+            await this._connection.send(this._protocol.writeMessage({ type: MessageType.Ack, sequenceId: this._latestReceivedSequenceId }));
+          }
+        } catch {
+        }
+        clearTimeout(this._ackTimerHandle);
+        this._ackTimerHandle = void 0;
+      }, 1e3);
+    }
+  }
 }
-
-export { MessageBuffer };
+class BufferedItem {
+  constructor(message, id, resolver, rejector) {
+    this._message = message;
+    this._id = id;
+    this._resolver = resolver;
+    this._rejector = rejector;
+  }
+}
+export {
+  MessageBuffer
+};

package/dist/esm/node_modules/@microsoft/signalr/dist/esm/ServerSentEventsTransport.js

@@ -1,105 +1,92 @@
-import { LogLevel } from './ILogger.js';
-import { TransferFormat } from './ITransport.js';
-import { Arg, Platform, getUserAgentHeader, getDataDetail, sendMessage } from './Utils.js';
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-/** @private */
-class ServerSentEventsTransport {
-    constructor(httpClient, accessToken, logger, options) {
-        this._httpClient = httpClient;
-        this._accessToken = accessToken;
-        this._logger = logger;
-        this._options = options;
-        this.onreceive = null;
-        this.onclose = null;
-    }
-    async connect(url, transferFormat) {
-        Arg.isRequired(url, "url");
-        Arg.isRequired(transferFormat, "transferFormat");
-        Arg.isIn(transferFormat, TransferFormat, "transferFormat");
-        this._logger.log(LogLevel.Trace, "(SSE transport) Connecting.");
-        // set url before accessTokenFactory because this._url is only for send and we set the auth header instead of the query string for send
-        this._url = url;
-        if (this._accessToken) {
-            url += (url.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(this._accessToken)}`;
-        }
-        return new Promise((resolve, reject) => {
-            let opened = false;
-            if (transferFormat !== TransferFormat.Text) {
-                reject(new Error("The Server-Sent Events transport only supports the 'Text' transfer format"));
-                return;
-            }
-            let eventSource;
-            if (Platform.isBrowser || Platform.isWebWorker) {
-                eventSource = new this._options.EventSource(url, { withCredentials: this._options.withCredentials });
-            }
-            else {
-                // Non-browser passes cookies via the dictionary
-                const cookies = this._httpClient.getCookieString(url);
-                const headers = {};
-                headers.Cookie = cookies;
-                const [name, value] = getUserAgentHeader();
-                headers[name] = value;
-                eventSource = new this._options.EventSource(url, { withCredentials: this._options.withCredentials, headers: { ...headers, ...this._options.headers } });
-            }
-            try {
-                eventSource.onmessage = (e) => {
-                    if (this.onreceive) {
-                        try {
-                            this._logger.log(LogLevel.Trace, `(SSE transport) data received. ${getDataDetail(e.data, this._options.logMessageContent)}.`);
-                            this.onreceive(e.data);
-                        }
-                        catch (error) {
-                            this._close(error);
-                            return;
-                        }
-                    }
-                };
-                // @ts-ignore: not using event on purpose
-                eventSource.onerror = (e) => {
-                    // EventSource doesn't give any useful information about server side closes.
-                    if (opened) {
-                        this._close();
-                    }
-                    else {
-                        reject(new Error("EventSource failed to connect. The connection could not be found on the server,"
-                            + " either the connection ID is not present on the server, or a proxy is refusing/buffering the connection."
-                            + " If you have multiple servers check that sticky sessions are enabled."));
-                    }
-                };
-                eventSource.onopen = () => {
-                    this._logger.log(LogLevel.Information, `SSE connected to ${this._url}`);
-                    this._eventSource = eventSource;
-                    opened = true;
-                    resolve();
-                };
-            }
-            catch (e) {
-                reject(e);
-                return;
-            }
-        });
-    }
-    async send(data) {
-        if (!this._eventSource) {
-            return Promise.reject(new Error("Cannot send until the transport is connected"));
-        }
-        return sendMessage(this._logger, "SSE", this._httpClient, this._url, data, this._options);
-    }
-    stop() {
-        this._close();
-        return Promise.resolve();
-    }
-    _close(e) {
-        if (this._eventSource) {
-            this._eventSource.close();
-            this._eventSource = undefined;
-            if (this.onclose) {
-                this.onclose(e);
-            }
-        }
-    }
+import { LogLevel } from "./ILogger.js";
+import { TransferFormat } from "./ITransport.js";
+import { Arg, Platform, getUserAgentHeader, getDataDetail, sendMessage } from "./Utils.js";
+class ServerSentEventsTransport {
+  constructor(httpClient, accessToken, logger, options) {
+    this._httpClient = httpClient;
+    this._accessToken = accessToken;
+    this._logger = logger;
+    this._options = options;
+    this.onreceive = null;
+    this.onclose = null;
+  }
+  async connect(url, transferFormat) {
+    Arg.isRequired(url, "url");
+    Arg.isRequired(transferFormat, "transferFormat");
+    Arg.isIn(transferFormat, TransferFormat, "transferFormat");
+    this._logger.log(LogLevel.Trace, "(SSE transport) Connecting.");
+    this._url = url;
+    if (this._accessToken) {
+      url += (url.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(this._accessToken)}`;
+    }
+    return new Promise((resolve, reject) => {
+      let opened = false;
+      if (transferFormat !== TransferFormat.Text) {
+        reject(new Error("The Server-Sent Events transport only supports the 'Text' transfer format"));
+        return;
+      }
+      let eventSource;
+      if (Platform.isBrowser || Platform.isWebWorker) {
+        eventSource = new this._options.EventSource(url, { withCredentials: this._options.withCredentials });
+      } else {
+        const cookies = this._httpClient.getCookieString(url);
+        const headers = {};
+        headers.Cookie = cookies;
+        const [name, value] = getUserAgentHeader();
+        headers[name] = value;
+        eventSource = new this._options.EventSource(url, { withCredentials: this._options.withCredentials, headers: { ...headers, ...this._options.headers } });
+      }
+      try {
+        eventSource.onmessage = (e) => {
+          if (this.onreceive) {
+            try {
+              this._logger.log(LogLevel.Trace, `(SSE transport) data received. ${getDataDetail(e.data, this._options.logMessageContent)}.`);
+              this.onreceive(e.data);
+            } catch (error) {
+              this._close(error);
+              return;
+            }
+          }
+        };
+        eventSource.onerror = (e) => {
+          if (opened) {
+            this._close();
+          } else {
+            reject(new Error("EventSource failed to connect. The connection could not be found on the server, either the connection ID is not present on the server, or a proxy is refusing/buffering the connection. If you have multiple servers check that sticky sessions are enabled."));
+          }
+        };
+        eventSource.onopen = () => {
+          this._logger.log(LogLevel.Information, `SSE connected to ${this._url}`);
+          this._eventSource = eventSource;
+          opened = true;
+          resolve();
+        };
+      } catch (e) {
+        reject(e);
+        return;
+      }
+    });
+  }
+  async send(data) {
+    if (!this._eventSource) {
+      return Promise.reject(new Error("Cannot send until the transport is connected"));
+    }
+    return sendMessage(this._logger, "SSE", this._httpClient, this._url, data, this._options);
+  }
+  stop() {
+    this._close();
+    return Promise.resolve();
+  }
+  _close(e) {
+    if (this._eventSource) {
+      this._eventSource.close();
+      this._eventSource = void 0;
+      if (this.onclose) {
+        this.onclose(e);
+      }
+    }
+  }
 }
-
-export { ServerSentEventsTransport };
+export {
+  ServerSentEventsTransport
+};

package/dist/esm/node_modules/@microsoft/signalr/dist/esm/Subject.js

@@ -1,35 +1,32 @@
-import { SubjectSubscription } from './Utils.js';
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-/** Stream implementation to stream items to the server. */
-class Subject {
-    constructor() {
-        this.observers = [];
-    }
-    next(item) {
-        for (const observer of this.observers) {
-            observer.next(item);
-        }
-    }
-    error(err) {
-        for (const observer of this.observers) {
-            if (observer.error) {
-                observer.error(err);
-            }
-        }
-    }
-    complete() {
-        for (const observer of this.observers) {
-            if (observer.complete) {
-                observer.complete();
-            }
-        }
-    }
-    subscribe(observer) {
-        this.observers.push(observer);
-        return new SubjectSubscription(this, observer);
-    }
+import { SubjectSubscription } from "./Utils.js";
+class Subject {
+  constructor() {
+    this.observers = [];
+  }
+  next(item) {
+    for (const observer of this.observers) {
+      observer.next(item);
+    }
+  }
+  error(err) {
+    for (const observer of this.observers) {
+      if (observer.error) {
+        observer.error(err);
+      }
+    }
+  }
+  complete() {
+    for (const observer of this.observers) {
+      if (observer.complete) {
+        observer.complete();
+      }
+    }
+  }
+  subscribe(observer) {
+    this.observers.push(observer);
+    return new SubjectSubscription(this, observer);
+  }
 }
-
-export { Subject };
+export {
+  Subject
+};