@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/node_modules/@microsoft/signalr/dist/esm/JsonHubProtocol.js

@@ -1,123 +1,110 @@
-'use strict';
-
-var IHubProtocol = require('./IHubProtocol.js');
-var ILogger = require('./ILogger.js');
-var ITransport = require('./ITransport.js');
-var Loggers = require('./Loggers.js');
-var TextMessageFormat = require('./TextMessageFormat.js');
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-const JSON_HUB_PROTOCOL_NAME = "json";
-/** Implements the JSON Hub Protocol. */
-class JsonHubProtocol {
-    constructor() {
-        /** @inheritDoc */
-        this.name = JSON_HUB_PROTOCOL_NAME;
-        /** @inheritDoc */
-        this.version = 2;
-        /** @inheritDoc */
-        this.transferFormat = ITransport.TransferFormat.Text;
-    }
-    /** Creates an array of {@link @microsoft/signalr.HubMessage} objects from the specified serialized representation.
-     *
-     * @param {string} input A string containing the serialized representation.
-     * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.
-     */
-    parseMessages(input, logger) {
-        // The interface does allow "ArrayBuffer" to be passed in, but this implementation does not. So let's throw a useful error.
-        if (typeof input !== "string") {
-            throw new Error("Invalid input for JSON hub protocol. Expected a string.");
-        }
-        if (!input) {
-            return [];
-        }
-        if (logger === null) {
-            logger = Loggers.NullLogger.instance;
-        }
-        // Parse the messages
-        const messages = TextMessageFormat.TextMessageFormat.parse(input);
-        const hubMessages = [];
-        for (const message of messages) {
-            const parsedMessage = JSON.parse(message);
-            if (typeof parsedMessage.type !== "number") {
-                throw new Error("Invalid payload.");
-            }
-            switch (parsedMessage.type) {
-                case IHubProtocol.MessageType.Invocation:
-                    this._isInvocationMessage(parsedMessage);
-                    break;
-                case IHubProtocol.MessageType.StreamItem:
-                    this._isStreamItemMessage(parsedMessage);
-                    break;
-                case IHubProtocol.MessageType.Completion:
-                    this._isCompletionMessage(parsedMessage);
-                    break;
-                case IHubProtocol.MessageType.Ping:
-                    // Single value, no need to validate
-                    break;
-                case IHubProtocol.MessageType.Close:
-                    // All optional values, no need to validate
-                    break;
-                case IHubProtocol.MessageType.Ack:
-                    this._isAckMessage(parsedMessage);
-                    break;
-                case IHubProtocol.MessageType.Sequence:
-                    this._isSequenceMessage(parsedMessage);
-                    break;
-                default:
-                    // Future protocol changes can add message types, old clients can ignore them
-                    logger.log(ILogger.LogLevel.Information, "Unknown message type '" + parsedMessage.type + "' ignored.");
-                    continue;
-            }
-            hubMessages.push(parsedMessage);
-        }
-        return hubMessages;
-    }
-    /** Writes the specified {@link @microsoft/signalr.HubMessage} to a string and returns it.
-     *
-     * @param {HubMessage} message The message to write.
-     * @returns {string} A string containing the serialized representation of the message.
-     */
-    writeMessage(message) {
-        return TextMessageFormat.TextMessageFormat.write(JSON.stringify(message));
-    }
-    _isInvocationMessage(message) {
-        this._assertNotEmptyString(message.target, "Invalid payload for Invocation message.");
-        if (message.invocationId !== undefined) {
-            this._assertNotEmptyString(message.invocationId, "Invalid payload for Invocation message.");
-        }
-    }
-    _isStreamItemMessage(message) {
-        this._assertNotEmptyString(message.invocationId, "Invalid payload for StreamItem message.");
-        if (message.item === undefined) {
-            throw new Error("Invalid payload for StreamItem message.");
-        }
-    }
-    _isCompletionMessage(message) {
-        if (message.result && message.error) {
-            throw new Error("Invalid payload for Completion message.");
-        }
-        if (!message.result && message.error) {
-            this._assertNotEmptyString(message.error, "Invalid payload for Completion message.");
-        }
-        this._assertNotEmptyString(message.invocationId, "Invalid payload for Completion message.");
-    }
-    _isAckMessage(message) {
-        if (typeof message.sequenceId !== 'number') {
-            throw new Error("Invalid SequenceId for Ack message.");
-        }
-    }
-    _isSequenceMessage(message) {
-        if (typeof message.sequenceId !== 'number') {
-            throw new Error("Invalid SequenceId for Sequence message.");
-        }
-    }
-    _assertNotEmptyString(value, errorMessage) {
-        if (typeof value !== "string" || value === "") {
-            throw new Error(errorMessage);
-        }
-    }
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const IHubProtocol = require("./IHubProtocol.js");
+const ILogger = require("./ILogger.js");
+const ITransport = require("./ITransport.js");
+const Loggers = require("./Loggers.js");
+const TextMessageFormat = require("./TextMessageFormat.js");
+const JSON_HUB_PROTOCOL_NAME = "json";
+class JsonHubProtocol {
+  constructor() {
+    this.name = JSON_HUB_PROTOCOL_NAME;
+    this.version = 2;
+    this.transferFormat = ITransport.TransferFormat.Text;
+  }
+  /** Creates an array of {@link @microsoft/signalr.HubMessage} objects from the specified serialized representation.
+   *
+   * @param {string} input A string containing the serialized representation.
+   * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.
+   */
+  parseMessages(input, logger) {
+    if (typeof input !== "string") {
+      throw new Error("Invalid input for JSON hub protocol. Expected a string.");
+    }
+    if (!input) {
+      return [];
+    }
+    if (logger === null) {
+      logger = Loggers.NullLogger.instance;
+    }
+    const messages = TextMessageFormat.TextMessageFormat.parse(input);
+    const hubMessages = [];
+    for (const message of messages) {
+      const parsedMessage = JSON.parse(message);
+      if (typeof parsedMessage.type !== "number") {
+        throw new Error("Invalid payload.");
+      }
+      switch (parsedMessage.type) {
+        case IHubProtocol.MessageType.Invocation:
+          this._isInvocationMessage(parsedMessage);
+          break;
+        case IHubProtocol.MessageType.StreamItem:
+          this._isStreamItemMessage(parsedMessage);
+          break;
+        case IHubProtocol.MessageType.Completion:
+          this._isCompletionMessage(parsedMessage);
+          break;
+        case IHubProtocol.MessageType.Ping:
+          break;
+        case IHubProtocol.MessageType.Close:
+          break;
+        case IHubProtocol.MessageType.Ack:
+          this._isAckMessage(parsedMessage);
+          break;
+        case IHubProtocol.MessageType.Sequence:
+          this._isSequenceMessage(parsedMessage);
+          break;
+        default:
+          logger.log(ILogger.LogLevel.Information, "Unknown message type '" + parsedMessage.type + "' ignored.");
+          continue;
+      }
+      hubMessages.push(parsedMessage);
+    }
+    return hubMessages;
+  }
+  /** Writes the specified {@link @microsoft/signalr.HubMessage} to a string and returns it.
+   *
+   * @param {HubMessage} message The message to write.
+   * @returns {string} A string containing the serialized representation of the message.
+   */
+  writeMessage(message) {
+    return TextMessageFormat.TextMessageFormat.write(JSON.stringify(message));
+  }
+  _isInvocationMessage(message) {
+    this._assertNotEmptyString(message.target, "Invalid payload for Invocation message.");
+    if (message.invocationId !== void 0) {
+      this._assertNotEmptyString(message.invocationId, "Invalid payload for Invocation message.");
+    }
+  }
+  _isStreamItemMessage(message) {
+    this._assertNotEmptyString(message.invocationId, "Invalid payload for StreamItem message.");
+    if (message.item === void 0) {
+      throw new Error("Invalid payload for StreamItem message.");
+    }
+  }
+  _isCompletionMessage(message) {
+    if (message.result && message.error) {
+      throw new Error("Invalid payload for Completion message.");
+    }
+    if (!message.result && message.error) {
+      this._assertNotEmptyString(message.error, "Invalid payload for Completion message.");
+    }
+    this._assertNotEmptyString(message.invocationId, "Invalid payload for Completion message.");
+  }
+  _isAckMessage(message) {
+    if (typeof message.sequenceId !== "number") {
+      throw new Error("Invalid SequenceId for Ack message.");
+    }
+  }
+  _isSequenceMessage(message) {
+    if (typeof message.sequenceId !== "number") {
+      throw new Error("Invalid SequenceId for Sequence message.");
+    }
+  }
+  _assertNotEmptyString(value, errorMessage) {
+    if (typeof value !== "string" || value === "") {
+      throw new Error(errorMessage);
+    }
+  }
 }
-
 exports.JsonHubProtocol = JsonHubProtocol;

package/dist/cjs/node_modules/@microsoft/signalr/dist/esm/Loggers.js

@@ -1,16 +1,12 @@
-'use strict';
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-/** A logger that does nothing when log messages are sent to it. */
-class NullLogger {
-    constructor() { }
-    /** @inheritDoc */
-    // eslint-disable-next-line
-    log(_logLevel, _message) {
-    }
-}
-/** The singleton instance of the {@link @microsoft/signalr.NullLogger}. */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class NullLogger {
+  constructor() {
+  }
+  /** @inheritDoc */
+  // eslint-disable-next-line
+  log(_logLevel, _message) {
+  }
+}
 NullLogger.instance = new NullLogger();
-
 exports.NullLogger = NullLogger;

package/dist/cjs/node_modules/@microsoft/signalr/dist/esm/LongPollingTransport.js

@@ -1,187 +1,152 @@
-'use strict';
-
-var AbortController = require('./AbortController.js');
-var Errors = require('./Errors.js');
-var ILogger = require('./ILogger.js');
-var ITransport = require('./ITransport.js');
-var Utils = require('./Utils.js');
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// Not exported from 'index', this type is internal.
-/** @private */
-class LongPollingTransport {
-    // This is an internal type, not exported from 'index' so this is really just internal.
-    get pollAborted() {
-        return this._pollAbort.aborted;
-    }
-    constructor(httpClient, logger, options) {
-        this._httpClient = httpClient;
-        this._logger = logger;
-        this._pollAbort = new AbortController.AbortController();
-        this._options = options;
-        this._running = false;
-        this.onreceive = null;
-        this.onclose = null;
-    }
-    async connect(url, transferFormat) {
-        Utils.Arg.isRequired(url, "url");
-        Utils.Arg.isRequired(transferFormat, "transferFormat");
-        Utils.Arg.isIn(transferFormat, ITransport.TransferFormat, "transferFormat");
-        this._url = url;
-        this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Connecting.");
-        // Allow binary format on Node and Browsers that support binary content (indicated by the presence of responseType property)
-        if (transferFormat === ITransport.TransferFormat.Binary &&
-            (typeof XMLHttpRequest !== "undefined" && typeof new XMLHttpRequest().responseType !== "string")) {
-            throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported.");
-        }
-        const [name, value] = Utils.getUserAgentHeader();
-        const headers = { [name]: value, ...this._options.headers };
-        const pollOptions = {
-            abortSignal: this._pollAbort.signal,
-            headers,
-            timeout: 100000,
-            withCredentials: this._options.withCredentials,
-        };
-        if (transferFormat === ITransport.TransferFormat.Binary) {
-            pollOptions.responseType = "arraybuffer";
-        }
-        // Make initial long polling request
-        // Server uses first long polling request to finish initializing connection and it returns without data
-        const pollUrl = `${url}&_=${Date.now()}`;
-        this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);
-        const response = await this._httpClient.get(pollUrl, pollOptions);
-        if (response.statusCode !== 200) {
-            this._logger.log(ILogger.LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response.statusCode}.`);
-            // Mark running as false so that the poll immediately ends and runs the close logic
-            this._closeError = new Errors.HttpError(response.statusText || "", response.statusCode);
-            this._running = false;
-        }
-        else {
-            this._running = true;
-        }
-        this._receiving = this._poll(this._url, pollOptions);
-    }
-    async _poll(url, pollOptions) {
-        try {
-            while (this._running) {
-                try {
-                    const pollUrl = `${url}&_=${Date.now()}`;
-                    this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);
-                    const response = await this._httpClient.get(pollUrl, pollOptions);
-                    if (response.statusCode === 204) {
-                        this._logger.log(ILogger.LogLevel.Information, "(LongPolling transport) Poll terminated by server.");
-                        this._running = false;
-                    }
-                    else if (response.statusCode !== 200) {
-                        this._logger.log(ILogger.LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response.statusCode}.`);
-                        // Unexpected status code
-                        this._closeError = new Errors.HttpError(response.statusText || "", response.statusCode);
-                        this._running = false;
-                    }
-                    else {
-                        // Process the response
-                        if (response.content) {
-                            this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) data received. ${Utils.getDataDetail(response.content, this._options.logMessageContent)}.`);
-                            if (this.onreceive) {
-                                this.onreceive(response.content);
-                            }
-                        }
-                        else {
-                            // This is another way timeout manifest.
-                            this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
-                        }
-                    }
-                }
-                catch (e) {
-                    if (!this._running) {
-                        // Log but disregard errors that occur after stopping
-                        this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) Poll errored after shutdown: ${e.message}`);
-                    }
-                    else {
-                        if (e instanceof Errors.TimeoutError) {
-                            // Ignore timeouts and reissue the poll.
-                            this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
-                        }
-                        else {
-                            // Close the connection with the error as the result.
-                            this._closeError = e;
-                            this._running = false;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Polling complete.");
-            // We will reach here with pollAborted==false when the server returned a response causing the transport to stop.
-            // If pollAborted==true then client initiated the stop and the stop method will raise the close event after DELETE is sent.
-            if (!this.pollAborted) {
-                this._raiseOnClose();
-            }
-        }
-    }
-    async send(data) {
-        if (!this._running) {
-            return Promise.reject(new Error("Cannot send until the transport is connected"));
-        }
-        return Utils.sendMessage(this._logger, "LongPolling", this._httpClient, this._url, data, this._options);
-    }
-    async stop() {
-        this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Stopping polling.");
-        // Tell receiving loop to stop, abort any current request, and then wait for it to finish
-        this._running = false;
-        this._pollAbort.abort();
-        try {
-            await this._receiving;
-            // Send DELETE to clean up long polling on the server
-            this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) sending DELETE request to ${this._url}.`);
-            const headers = {};
-            const [name, value] = Utils.getUserAgentHeader();
-            headers[name] = value;
-            const deleteOptions = {
-                headers: { ...headers, ...this._options.headers },
-                timeout: this._options.timeout,
-                withCredentials: this._options.withCredentials,
-            };
-            let error;
-            try {
-                await this._httpClient.delete(this._url, deleteOptions);
-            }
-            catch (err) {
-                error = err;
-            }
-            if (error) {
-                if (error instanceof Errors.HttpError) {
-                    if (error.statusCode === 404) {
-                        this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) A 404 response was returned from sending a DELETE request.");
-                    }
-                    else {
-                        this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) Error sending a DELETE request: ${error}`);
-                    }
-                }
-            }
-            else {
-                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) DELETE request accepted.");
-            }
-        }
-        finally {
-            this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Stop finished.");
-            // Raise close event here instead of in polling
-            // It needs to happen after the DELETE request is sent
-            this._raiseOnClose();
-        }
-    }
-    _raiseOnClose() {
-        if (this.onclose) {
-            let logMessage = "(LongPolling transport) Firing onclose event.";
-            if (this._closeError) {
-                logMessage += " Error: " + this._closeError;
-            }
-            this._logger.log(ILogger.LogLevel.Trace, logMessage);
-            this.onclose(this._closeError);
-        }
-    }
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const AbortController = require("./AbortController.js");
+const Errors = require("./Errors.js");
+const ILogger = require("./ILogger.js");
+const ITransport = require("./ITransport.js");
+const Utils = require("./Utils.js");
+class LongPollingTransport {
+  // This is an internal type, not exported from 'index' so this is really just internal.
+  get pollAborted() {
+    return this._pollAbort.aborted;
+  }
+  constructor(httpClient, logger, options) {
+    this._httpClient = httpClient;
+    this._logger = logger;
+    this._pollAbort = new AbortController.AbortController();
+    this._options = options;
+    this._running = false;
+    this.onreceive = null;
+    this.onclose = null;
+  }
+  async connect(url, transferFormat) {
+    Utils.Arg.isRequired(url, "url");
+    Utils.Arg.isRequired(transferFormat, "transferFormat");
+    Utils.Arg.isIn(transferFormat, ITransport.TransferFormat, "transferFormat");
+    this._url = url;
+    this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Connecting.");
+    if (transferFormat === ITransport.TransferFormat.Binary && (typeof XMLHttpRequest !== "undefined" && typeof new XMLHttpRequest().responseType !== "string")) {
+      throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported.");
+    }
+    const [name, value] = Utils.getUserAgentHeader();
+    const headers = { [name]: value, ...this._options.headers };
+    const pollOptions = {
+      abortSignal: this._pollAbort.signal,
+      headers,
+      timeout: 1e5,
+      withCredentials: this._options.withCredentials
+    };
+    if (transferFormat === ITransport.TransferFormat.Binary) {
+      pollOptions.responseType = "arraybuffer";
+    }
+    const pollUrl = `${url}&_=${Date.now()}`;
+    this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);
+    const response = await this._httpClient.get(pollUrl, pollOptions);
+    if (response.statusCode !== 200) {
+      this._logger.log(ILogger.LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response.statusCode}.`);
+      this._closeError = new Errors.HttpError(response.statusText || "", response.statusCode);
+      this._running = false;
+    } else {
+      this._running = true;
+    }
+    this._receiving = this._poll(this._url, pollOptions);
+  }
+  async _poll(url, pollOptions) {
+    try {
+      while (this._running) {
+        try {
+          const pollUrl = `${url}&_=${Date.now()}`;
+          this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);
+          const response = await this._httpClient.get(pollUrl, pollOptions);
+          if (response.statusCode === 204) {
+            this._logger.log(ILogger.LogLevel.Information, "(LongPolling transport) Poll terminated by server.");
+            this._running = false;
+          } else if (response.statusCode !== 200) {
+            this._logger.log(ILogger.LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response.statusCode}.`);
+            this._closeError = new Errors.HttpError(response.statusText || "", response.statusCode);
+            this._running = false;
+          } else {
+            if (response.content) {
+              this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) data received. ${Utils.getDataDetail(response.content, this._options.logMessageContent)}.`);
+              if (this.onreceive) {
+                this.onreceive(response.content);
+              }
+            } else {
+              this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+            }
+          }
+        } catch (e) {
+          if (!this._running) {
+            this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) Poll errored after shutdown: ${e.message}`);
+          } else {
+            if (e instanceof Errors.TimeoutError) {
+              this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+            } else {
+              this._closeError = e;
+              this._running = false;
+            }
+          }
+        }
+      }
+    } finally {
+      this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Polling complete.");
+      if (!this.pollAborted) {
+        this._raiseOnClose();
+      }
+    }
+  }
+  async send(data) {
+    if (!this._running) {
+      return Promise.reject(new Error("Cannot send until the transport is connected"));
+    }
+    return Utils.sendMessage(this._logger, "LongPolling", this._httpClient, this._url, data, this._options);
+  }
+  async stop() {
+    this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Stopping polling.");
+    this._running = false;
+    this._pollAbort.abort();
+    try {
+      await this._receiving;
+      this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) sending DELETE request to ${this._url}.`);
+      const headers = {};
+      const [name, value] = Utils.getUserAgentHeader();
+      headers[name] = value;
+      const deleteOptions = {
+        headers: { ...headers, ...this._options.headers },
+        timeout: this._options.timeout,
+        withCredentials: this._options.withCredentials
+      };
+      let error;
+      try {
+        await this._httpClient.delete(this._url, deleteOptions);
+      } catch (err) {
+        error = err;
+      }
+      if (error) {
+        if (error instanceof Errors.HttpError) {
+          if (error.statusCode === 404) {
+            this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) A 404 response was returned from sending a DELETE request.");
+          } else {
+            this._logger.log(ILogger.LogLevel.Trace, `(LongPolling transport) Error sending a DELETE request: ${error}`);
+          }
+        }
+      } else {
+        this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) DELETE request accepted.");
+      }
+    } finally {
+      this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Stop finished.");
+      this._raiseOnClose();
+    }
+  }
+  _raiseOnClose() {
+    if (this.onclose) {
+      let logMessage = "(LongPolling transport) Firing onclose event.";
+      if (this._closeError) {
+        logMessage += " Error: " + this._closeError;
+      }
+      this._logger.log(ILogger.LogLevel.Trace, logMessage);
+      this.onclose(this._closeError);
+    }
+  }
 }
-
 exports.LongPollingTransport = LongPollingTransport;