@glodon-aiot/agent-cli-ui 2.4.7

package/dist/es/node_modules/socket.io-client/build/esm/manager.mjs

@@ -0,0 +1,242 @@
+import { Socket as a } from "../../../engine.io-client/build/esm/socket.mjs";
+import "../../../engine.io-parser/build/esm/encodePacket.browser.mjs";
+import "../../../engine.io-parser/build/esm/commons.mjs";
+import "../../../engine.io-parser/build/esm/contrib/base64-arraybuffer.mjs";
+import { Emitter as d } from "../../../@socket.io/component-emitter/lib/esm/index.mjs";
+import { installTimerFunctions as f } from "../../../engine.io-client/build/esm/util.mjs";
+import "../../../engine.io-client/build/esm/transports/polling.mjs";
+import "../../../engine.io-client/build/esm/transports/websocket.mjs";
+import { nextTick as u } from "../../../engine.io-client/build/esm/transports/websocket-constructor.browser.mjs";
+import { Socket as m } from "./socket.mjs";
+import * as l from "../../../socket.io-parser/build/esm/index.mjs";
+import { on as s } from "./on.mjs";
+import { Backoff as p } from "./contrib/backo2.mjs";
+class T extends d {
+  constructor(e, t) {
+    var n;
+    super(), this.nsps = {}, this.subs = [], e && typeof e == "object" && (t = e, e = void 0), t = t || {}, t.path = t.path || "/socket.io", this.opts = t, f(this, t), this.reconnection(t.reconnection !== !1), this.reconnectionAttempts(t.reconnectionAttempts || 1 / 0), this.reconnectionDelay(t.reconnectionDelay || 1e3), this.reconnectionDelayMax(t.reconnectionDelayMax || 5e3), this.randomizationFactor((n = t.randomizationFactor) !== null && n !== void 0 ? n : 0.5), this.backoff = new p({
+      min: this.reconnectionDelay(),
+      max: this.reconnectionDelayMax(),
+      jitter: this.randomizationFactor()
+    }), this.timeout(t.timeout == null ? 2e4 : t.timeout), this._readyState = "closed", this.uri = e;
+    const i = t.parser || l;
+    this.encoder = new i.Encoder(), this.decoder = new i.Decoder(), this._autoConnect = t.autoConnect !== !1, this._autoConnect && this.open();
+  }
+  reconnection(e) {
+    return arguments.length ? (this._reconnection = !!e, this) : this._reconnection;
+  }
+  reconnectionAttempts(e) {
+    return e === void 0 ? this._reconnectionAttempts : (this._reconnectionAttempts = e, this);
+  }
+  reconnectionDelay(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelay : (this._reconnectionDelay = e, (t = this.backoff) === null || t === void 0 || t.setMin(e), this);
+  }
+  randomizationFactor(e) {
+    var t;
+    return e === void 0 ? this._randomizationFactor : (this._randomizationFactor = e, (t = this.backoff) === null || t === void 0 || t.setJitter(e), this);
+  }
+  reconnectionDelayMax(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelayMax : (this._reconnectionDelayMax = e, (t = this.backoff) === null || t === void 0 || t.setMax(e), this);
+  }
+  timeout(e) {
+    return arguments.length ? (this._timeout = e, this) : this._timeout;
+  }
+  /**
+   * Starts trying to reconnect if reconnection is enabled and we have not
+   * started reconnecting yet
+   *
+   * @private
+   */
+  maybeReconnectOnOpen() {
+    !this._reconnecting && this._reconnection && this.backoff.attempts === 0 && this.reconnect();
+  }
+  /**
+   * Sets the current transport `socket`.
+   *
+   * @param {Function} fn - optional, callback
+   * @return self
+   * @public
+   */
+  open(e) {
+    if (~this._readyState.indexOf("open"))
+      return this;
+    this.engine = new a(this.uri, this.opts);
+    const t = this.engine, n = this;
+    this._readyState = "opening", this.skipReconnect = !1;
+    const i = s(t, "open", function() {
+      n.onopen(), e && e();
+    }), r = (o) => {
+      this.cleanup(), this._readyState = "closed", this.emitReserved("error", o), e ? e(o) : this.maybeReconnectOnOpen();
+    }, h = s(t, "error", r);
+    if (this._timeout !== !1) {
+      const o = this._timeout, c = this.setTimeoutFn(() => {
+        i(), r(new Error("timeout")), t.close();
+      }, o);
+      this.opts.autoUnref && c.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(c);
+      });
+    }
+    return this.subs.push(i), this.subs.push(h), this;
+  }
+  /**
+   * Alias for open()
+   *
+   * @return self
+   * @public
+   */
+  connect(e) {
+    return this.open(e);
+  }
+  /**
+   * Called upon transport open.
+   *
+   * @private
+   */
+  onopen() {
+    this.cleanup(), this._readyState = "open", this.emitReserved("open");
+    const e = this.engine;
+    this.subs.push(s(e, "ping", this.onping.bind(this)), s(e, "data", this.ondata.bind(this)), s(e, "error", this.onerror.bind(this)), s(e, "close", this.onclose.bind(this)), s(this.decoder, "decoded", this.ondecoded.bind(this)));
+  }
+  /**
+   * Called upon a ping.
+   *
+   * @private
+   */
+  onping() {
+    this.emitReserved("ping");
+  }
+  /**
+   * Called with data.
+   *
+   * @private
+   */
+  ondata(e) {
+    try {
+      this.decoder.add(e);
+    } catch (t) {
+      this.onclose("parse error", t);
+    }
+  }
+  /**
+   * Called when parser fully decodes a packet.
+   *
+   * @private
+   */
+  ondecoded(e) {
+    u(() => {
+      this.emitReserved("packet", e);
+    }, this.setTimeoutFn);
+  }
+  /**
+   * Called upon socket error.
+   *
+   * @private
+   */
+  onerror(e) {
+    this.emitReserved("error", e);
+  }
+  /**
+   * Creates a new socket for the given `nsp`.
+   *
+   * @return {Socket}
+   * @public
+   */
+  socket(e, t) {
+    let n = this.nsps[e];
+    return n ? this._autoConnect && !n.active && n.connect() : (n = new m(this, e, t), this.nsps[e] = n), n;
+  }
+  /**
+   * Called upon a socket close.
+   *
+   * @param socket
+   * @private
+   */
+  _destroy(e) {
+    const t = Object.keys(this.nsps);
+    for (const n of t)
+      if (this.nsps[n].active)
+        return;
+    this._close();
+  }
+  /**
+   * Writes a packet.
+   *
+   * @param packet
+   * @private
+   */
+  _packet(e) {
+    const t = this.encoder.encode(e);
+    for (let n = 0; n < t.length; n++)
+      this.engine.write(t[n], e.options);
+  }
+  /**
+   * Clean up transport subscriptions and packet buffer.
+   *
+   * @private
+   */
+  cleanup() {
+    this.subs.forEach((e) => e()), this.subs.length = 0, this.decoder.destroy();
+  }
+  /**
+   * Close the current socket.
+   *
+   * @private
+   */
+  _close() {
+    this.skipReconnect = !0, this._reconnecting = !1, this.onclose("forced close"), this.engine && this.engine.close();
+  }
+  /**
+   * Alias for close()
+   *
+   * @private
+   */
+  disconnect() {
+    return this._close();
+  }
+  /**
+   * Called upon engine close.
+   *
+   * @private
+   */
+  onclose(e, t) {
+    this.cleanup(), this.backoff.reset(), this._readyState = "closed", this.emitReserved("close", e, t), this._reconnection && !this.skipReconnect && this.reconnect();
+  }
+  /**
+   * Attempt a reconnection.
+   *
+   * @private
+   */
+  reconnect() {
+    if (this._reconnecting || this.skipReconnect)
+      return this;
+    const e = this;
+    if (this.backoff.attempts >= this._reconnectionAttempts)
+      this.backoff.reset(), this.emitReserved("reconnect_failed"), this._reconnecting = !1;
+    else {
+      const t = this.backoff.duration();
+      this._reconnecting = !0;
+      const n = this.setTimeoutFn(() => {
+        e.skipReconnect || (this.emitReserved("reconnect_attempt", e.backoff.attempts), !e.skipReconnect && e.open((i) => {
+          i ? (e._reconnecting = !1, e.reconnect(), this.emitReserved("reconnect_error", i)) : e.onreconnect();
+        }));
+      }, t);
+      this.opts.autoUnref && n.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(n);
+      });
+    }
+  }
+  /**
+   * Called upon successful reconnect.
+   *
+   * @private
+   */
+  onreconnect() {
+    const e = this.backoff.attempts;
+    this._reconnecting = !1, this.backoff.reset(), this.emitReserved("reconnect", e);
+  }
+}
+export {
+  T as Manager
+};

package/dist/es/node_modules/socket.io-client/build/esm/on.mjs

@@ -0,0 +1,8 @@
+function u(n, o, t) {
+  return n.on(o, t), function() {
+    n.off(o, t);
+  };
+}
+export {
+  u as on
+};