@glodon-aiot/agent-cli-sdk 2.4.7

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

@@ -0,0 +1,608 @@
+import { PacketType as n } from "../../../socket.io-parser/build/esm/index.mjs";
+import { on as c } from "./on.mjs";
+import { Emitter as u } from "../../../@socket.io/component-emitter/lib/esm/index.mjs";
+const a = Object.freeze({
+  connect: 1,
+  connect_error: 1,
+  disconnect: 1,
+  disconnecting: 1,
+  // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
+  newListener: 1,
+  removeListener: 1
+});
+class g extends u {
+  /**
+   * `Socket` constructor.
+   */
+  constructor(t, e, s) {
+    super(), this.connected = !1, this.recovered = !1, this.receiveBuffer = [], this.sendBuffer = [], this._queue = [], this._queueSeq = 0, this.ids = 0, this.acks = {}, this.flags = {}, this.io = t, this.nsp = e, s && s.auth && (this.auth = s.auth), this._opts = Object.assign({}, s), this.io._autoConnect && this.open();
+  }
+  /**
+   * Whether the socket is currently disconnected
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("connect", () => {
+   *   console.log(socket.disconnected); // false
+   * });
+   *
+   * socket.on("disconnect", () => {
+   *   console.log(socket.disconnected); // true
+   * });
+   */
+  get disconnected() {
+    return !this.connected;
+  }
+  /**
+   * Subscribe to open, close and packet events
+   *
+   * @private
+   */
+  subEvents() {
+    if (this.subs)
+      return;
+    const t = this.io;
+    this.subs = [c(t, "open", this.onopen.bind(this)), c(t, "packet", this.onpacket.bind(this)), c(t, "error", this.onerror.bind(this)), c(t, "close", this.onclose.bind(this))];
+  }
+  /**
+   * Whether the Socket will try to reconnect when its Manager connects or reconnects.
+   *
+   * @example
+   * const socket = io();
+   *
+   * console.log(socket.active); // true
+   *
+   * socket.on("disconnect", (reason) => {
+   *   if (reason === "io server disconnect") {
+   *     // the disconnection was initiated by the server, you need to manually reconnect
+   *     console.log(socket.active); // false
+   *   }
+   *   // else the socket will automatically try to reconnect
+   *   console.log(socket.active); // true
+   * });
+   */
+  get active() {
+    return !!this.subs;
+  }
+  /**
+   * "Opens" the socket.
+   *
+   * @example
+   * const socket = io({
+   *   autoConnect: false
+   * });
+   *
+   * socket.connect();
+   */
+  connect() {
+    return this.connected ? this : (this.subEvents(), this.io._reconnecting || this.io.open(), this.io._readyState === "open" && this.onopen(), this);
+  }
+  /**
+   * Alias for {@link connect()}.
+   */
+  open() {
+    return this.connect();
+  }
+  /**
+   * Sends a `message` event.
+   *
+   * This method mimics the WebSocket.send() method.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+   *
+   * @example
+   * socket.send("hello");
+   *
+   * // this is equivalent to
+   * socket.emit("message", "hello");
+   *
+   * @return self
+   */
+  send(...t) {
+    return t.unshift("message"), this.emit.apply(this, t), this;
+  }
+  /**
+   * Override `emit`.
+   * If the event is in `events`, it's emitted normally.
+   *
+   * @example
+   * socket.emit("hello", "world");
+   *
+   * // all serializable datastructures are supported (no need to call JSON.stringify)
+   * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+   *
+   * // with an acknowledgement from the server
+   * socket.emit("hello", "world", (val) => {
+   *   // ...
+   * });
+   *
+   * @return self
+   */
+  emit(t, ...e) {
+    if (a.hasOwnProperty(t))
+      throw new Error('"' + t.toString() + '" is a reserved event name');
+    if (e.unshift(t), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile)
+      return this._addToQueue(e), this;
+    const s = {
+      type: n.EVENT,
+      data: e
+    };
+    if (s.options = {}, s.options.compress = this.flags.compress !== !1, typeof e[e.length - 1] == "function") {
+      const o = this.ids++, r = e.pop();
+      this._registerAckCallback(o, r), s.id = o;
+    }
+    const i = this.io.engine && this.io.engine.transport && this.io.engine.transport.writable;
+    return this.flags.volatile && (!i || !this.connected) || (this.connected ? (this.notifyOutgoingListeners(s), this.packet(s)) : this.sendBuffer.push(s)), this.flags = {}, this;
+  }
+  /**
+   * @private
+   */
+  _registerAckCallback(t, e) {
+    var s;
+    const i = (s = this.flags.timeout) !== null && s !== void 0 ? s : this._opts.ackTimeout;
+    if (i === void 0) {
+      this.acks[t] = e;
+      return;
+    }
+    const h = this.io.setTimeoutFn(() => {
+      delete this.acks[t];
+      for (let r = 0; r < this.sendBuffer.length; r++)
+        this.sendBuffer[r].id === t && this.sendBuffer.splice(r, 1);
+      e.call(this, new Error("operation has timed out"));
+    }, i), o = (...r) => {
+      this.io.clearTimeoutFn(h), e.apply(this, r);
+    };
+    o.withError = !0, this.acks[t] = o;
+  }
+  /**
+   * Emits an event and waits for an acknowledgement
+   *
+   * @example
+   * // without timeout
+   * const response = await socket.emitWithAck("hello", "world");
+   *
+   * // with a specific timeout
+   * try {
+   *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+   * } catch (err) {
+   *   // the server did not acknowledge the event in the given delay
+   * }
+   *
+   * @return a Promise that will be fulfilled when the server acknowledges the event
+   */
+  emitWithAck(t, ...e) {
+    return new Promise((s, i) => {
+      const h = (o, r) => o ? i(o) : s(r);
+      h.withError = !0, e.push(h), this.emit(t, ...e);
+    });
+  }
+  /**
+   * Add the packet to the queue.
+   * @param args
+   * @private
+   */
+  _addToQueue(t) {
+    let e;
+    typeof t[t.length - 1] == "function" && (e = t.pop());
+    const s = {
+      id: this._queueSeq++,
+      tryCount: 0,
+      pending: !1,
+      args: t,
+      flags: Object.assign({
+        fromQueue: !0
+      }, this.flags)
+    };
+    t.push((i, ...h) => s !== this._queue[0] ? void 0 : (i !== null ? s.tryCount > this._opts.retries && (this._queue.shift(), e && e(i)) : (this._queue.shift(), e && e(null, ...h)), s.pending = !1, this._drainQueue())), this._queue.push(s), this._drainQueue();
+  }
+  /**
+   * Send the first packet of the queue, and wait for an acknowledgement from the server.
+   * @param force - whether to resend a packet that has not been acknowledged yet
+   *
+   * @private
+   */
+  _drainQueue(t = !1) {
+    if (!this.connected || this._queue.length === 0)
+      return;
+    const e = this._queue[0];
+    e.pending && !t || (e.pending = !0, e.tryCount++, this.flags = e.flags, this.emit.apply(this, e.args));
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param packet
+   * @private
+   */
+  packet(t) {
+    t.nsp = this.nsp, this.io._packet(t);
+  }
+  /**
+   * Called upon engine `open`.
+   *
+   * @private
+   */
+  onopen() {
+    typeof this.auth == "function" ? this.auth((t) => {
+      this._sendConnectPacket(t);
+    }) : this._sendConnectPacket(this.auth);
+  }
+  /**
+   * Sends a CONNECT packet to initiate the Socket.IO session.
+   *
+   * @param data
+   * @private
+   */
+  _sendConnectPacket(t) {
+    this.packet({
+      type: n.CONNECT,
+      data: this._pid ? Object.assign({
+        pid: this._pid,
+        offset: this._lastOffset
+      }, t) : t
+    });
+  }
+  /**
+   * Called upon engine or manager `error`.
+   *
+   * @param err
+   * @private
+   */
+  onerror(t) {
+    this.connected || this.emitReserved("connect_error", t);
+  }
+  /**
+   * Called upon engine `close`.
+   *
+   * @param reason
+   * @param description
+   * @private
+   */
+  onclose(t, e) {
+    this.connected = !1, delete this.id, this.emitReserved("disconnect", t, e), this._clearAcks();
+  }
+  /**
+   * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+   * the server.
+   *
+   * @private
+   */
+  _clearAcks() {
+    Object.keys(this.acks).forEach((t) => {
+      if (!this.sendBuffer.some((s) => String(s.id) === t)) {
+        const s = this.acks[t];
+        delete this.acks[t], s.withError && s.call(this, new Error("socket has been disconnected"));
+      }
+    });
+  }
+  /**
+   * Called with socket packet.
+   *
+   * @param packet
+   * @private
+   */
+  onpacket(t) {
+    if (t.nsp === this.nsp)
+      switch (t.type) {
+        case n.CONNECT:
+          t.data && t.data.sid ? this.onconnect(t.data.sid, t.data.pid) : this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+          break;
+        case n.EVENT:
+        case n.BINARY_EVENT:
+          this.onevent(t);
+          break;
+        case n.ACK:
+        case n.BINARY_ACK:
+          this.onack(t);
+          break;
+        case n.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case n.CONNECT_ERROR:
+          this.destroy();
+          const s = new Error(t.data.message);
+          s.data = t.data.data, this.emitReserved("connect_error", s);
+          break;
+      }
+  }
+  /**
+   * Called upon a server event.
+   *
+   * @param packet
+   * @private
+   */
+  onevent(t) {
+    const e = t.data || [];
+    t.id != null && e.push(this.ack(t.id)), this.connected ? this.emitEvent(e) : this.receiveBuffer.push(Object.freeze(e));
+  }
+  emitEvent(t) {
+    if (this._anyListeners && this._anyListeners.length) {
+      const e = this._anyListeners.slice();
+      for (const s of e)
+        s.apply(this, t);
+    }
+    super.emit.apply(this, t), this._pid && t.length && typeof t[t.length - 1] == "string" && (this._lastOffset = t[t.length - 1]);
+  }
+  /**
+   * Produces an ack callback to emit with an event.
+   *
+   * @private
+   */
+  ack(t) {
+    const e = this;
+    let s = !1;
+    return function(...i) {
+      s || (s = !0, e.packet({
+        type: n.ACK,
+        id: t,
+        data: i
+      }));
+    };
+  }
+  /**
+   * Called upon a server acknowledgement.
+   *
+   * @param packet
+   * @private
+   */
+  onack(t) {
+    const e = this.acks[t.id];
+    typeof e == "function" && (delete this.acks[t.id], e.withError && t.data.unshift(null), e.apply(this, t.data));
+  }
+  /**
+   * Called upon server connect.
+   *
+   * @private
+   */
+  onconnect(t, e) {
+    this.id = t, this.recovered = e && this._pid === e, this._pid = e, this.connected = !0, this.emitBuffered(), this.emitReserved("connect"), this._drainQueue(!0);
+  }
+  /**
+   * Emit buffered events (received and emitted).
+   *
+   * @private
+   */
+  emitBuffered() {
+    this.receiveBuffer.forEach((t) => this.emitEvent(t)), this.receiveBuffer = [], this.sendBuffer.forEach((t) => {
+      this.notifyOutgoingListeners(t), this.packet(t);
+    }), this.sendBuffer = [];
+  }
+  /**
+   * Called upon server disconnect.
+   *
+   * @private
+   */
+  ondisconnect() {
+    this.destroy(), this.onclose("io server disconnect");
+  }
+  /**
+   * Called upon forced client/server side disconnections,
+   * this method ensures the manager stops tracking us and
+   * that reconnections don't get triggered for this.
+   *
+   * @private
+   */
+  destroy() {
+    this.subs && (this.subs.forEach((t) => t()), this.subs = void 0), this.io._destroy(this);
+  }
+  /**
+   * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+   *
+   * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("disconnect", (reason) => {
+   *   // console.log(reason); prints "io client disconnect"
+   * });
+   *
+   * socket.disconnect();
+   *
+   * @return self
+   */
+  disconnect() {
+    return this.connected && this.packet({
+      type: n.DISCONNECT
+    }), this.destroy(), this.connected && this.onclose("io client disconnect"), this;
+  }
+  /**
+   * Alias for {@link disconnect()}.
+   *
+   * @return self
+   */
+  close() {
+    return this.disconnect();
+  }
+  /**
+   * Sets the compress flag.
+   *
+   * @example
+   * socket.compress(false).emit("hello");
+   *
+   * @param compress - if `true`, compresses the sending data
+   * @return self
+   */
+  compress(t) {
+    return this.flags.compress = t, this;
+  }
+  /**
+   * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
+   * ready to send messages.
+   *
+   * @example
+   * socket.volatile.emit("hello"); // the server may or may not receive it
+   *
+   * @returns self
+   */
+  get volatile() {
+    return this.flags.volatile = !0, this;
+  }
+  /**
+   * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+   * given number of milliseconds have elapsed without an acknowledgement from the server:
+   *
+   * @example
+   * socket.timeout(5000).emit("my-event", (err) => {
+   *   if (err) {
+   *     // the server did not acknowledge the event in the given delay
+   *   }
+   * });
+   *
+   * @returns self
+   */
+  timeout(t) {
+    return this.flags.timeout = t, this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * @example
+   * socket.onAny((event, ...args) => {
+   *   console.log(`got ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAny(t) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.push(t), this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * @example
+   * socket.prependAny((event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAny(t) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.unshift(t), this;
+  }
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * }
+   *
+   * socket.onAny(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAny(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAny();
+   *
+   * @param listener
+   */
+  offAny(t) {
+    if (!this._anyListeners)
+      return this;
+    if (t) {
+      const e = this._anyListeners;
+      for (let s = 0; s < e.length; s++)
+        if (t === e[s])
+          return e.splice(s, 1), this;
+    } else
+      this._anyListeners = [];
+    return this;
+  }
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAny() {
+    return this._anyListeners || [];
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.onAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAnyOutgoing(t) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.push(t), this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.prependAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAnyOutgoing(t) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.unshift(t), this;
+  }
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * }
+   *
+   * socket.onAnyOutgoing(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAnyOutgoing(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAnyOutgoing();
+   *
+   * @param [listener] - the catch-all listener (optional)
+   */
+  offAnyOutgoing(t) {
+    if (!this._anyOutgoingListeners)
+      return this;
+    if (t) {
+      const e = this._anyOutgoingListeners;
+      for (let s = 0; s < e.length; s++)
+        if (t === e[s])
+          return e.splice(s, 1), this;
+    } else
+      this._anyOutgoingListeners = [];
+    return this;
+  }
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAnyOutgoing() {
+    return this._anyOutgoingListeners || [];
+  }
+  /**
+   * Notify the listeners for each packet sent
+   *
+   * @param packet
+   *
+   * @private
+   */
+  notifyOutgoingListeners(t) {
+    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+      const e = this._anyOutgoingListeners.slice();
+      for (const s of e)
+        s.apply(this, t.data);
+    }
+  }
+}
+export {
+  g as Socket
+};

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

@@ -0,0 +1,19 @@
+import "../../../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 "../../../@socket.io/component-emitter/lib/esm/index.mjs";
+import "../../../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 "../../../engine.io-client/build/esm/transports/websocket-constructor.browser.mjs";
+import { parse as r } from "../../../engine.io-client/build/esm/contrib/parseuri.mjs";
+function v(o, e = "", p) {
+  let t = o;
+  p = p || typeof location != "undefined" && location, o == null && (o = p.protocol + "//" + p.host), typeof o == "string" && (o.charAt(0) === "/" && (o.charAt(1) === "/" ? o = p.protocol + o : o = p.host + o), /^(https?|wss?):\/\//.test(o) || (typeof p != "undefined" ? o = p.protocol + "//" + o : o = "https://" + o), t = r(o)), t.port || (/^(http|ws)$/.test(t.protocol) ? t.port = "80" : /^(http|ws)s$/.test(t.protocol) && (t.port = "443")), t.path = t.path || "/";
+  const s = t.host.indexOf(":") !== -1 ? "[" + t.host + "]" : t.host;
+  return t.id = t.protocol + "://" + s + ":" + t.port + e, t.href = t.protocol + "://" + s + (p && p.port === t.port ? "" : ":" + t.port), t;
+}
+export {
+  v as url
+};

package/dist/es/node_modules/socket.io-parser/build/esm/binary.mjs

@@ -0,0 +1,52 @@
+import { isBinary as i } from "./is-binary.mjs";
+function s(e) {
+  const r = [], n = e.data, t = e;
+  return t.data = o(n, r), t.attachments = r.length, {
+    packet: t,
+    buffers: r
+  };
+}
+function o(e, r) {
+  if (!e)
+    return e;
+  if (i(e)) {
+    const n = {
+      _placeholder: !0,
+      num: r.length
+    };
+    return r.push(e), n;
+  } else if (Array.isArray(e)) {
+    const n = new Array(e.length);
+    for (let t = 0; t < e.length; t++)
+      n[t] = o(e[t], r);
+    return n;
+  } else if (typeof e == "object" && !(e instanceof Date)) {
+    const n = {};
+    for (const t in e)
+      Object.prototype.hasOwnProperty.call(e, t) && (n[t] = o(e[t], r));
+    return n;
+  }
+  return e;
+}
+function u(e, r) {
+  return e.data = c(e.data, r), delete e.attachments, e;
+}
+function c(e, r) {
+  if (!e)
+    return e;
+  if (e && e._placeholder === !0) {
+    if (typeof e.num == "number" && e.num >= 0 && e.num < r.length)
+      return r[e.num];
+    throw new Error("illegal attachments");
+  } else if (Array.isArray(e))
+    for (let n = 0; n < e.length; n++)
+      e[n] = c(e[n], r);
+  else if (typeof e == "object")
+    for (const n in e)
+      Object.prototype.hasOwnProperty.call(e, n) && (e[n] = c(e[n], r));
+  return e;
+}
+export {
+  s as deconstructPacket,
+  u as reconstructPacket
+};