lightclaw2 0.0.1

package/node_modules/socket.io-client/build/cjs/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebTransport = exports.WebSocket = exports.NodeWebSocket = exports.XHR = exports.NodeXHR = exports.Fetch = exports.Socket = exports.Manager = exports.protocol = void 0;
+exports.io = lookup;
+exports.connect = lookup;
+exports.default = lookup;
+const url_js_1 = require("./url.js");
+const manager_js_1 = require("./manager.js");
+Object.defineProperty(exports, "Manager", { enumerable: true, get: function () { return manager_js_1.Manager; } });
+const socket_js_1 = require("./socket.js");
+Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_js_1.Socket; } });
+const debug_1 = __importDefault(require("debug")); // debug()
+const debug = (0, debug_1.default)("socket.io-client"); // debug()
+/**
+ * Managers cache.
+ */
+const cache = {};
+function lookup(uri, opts) {
+    if (typeof uri === "object") {
+        opts = uri;
+        uri = undefined;
+    }
+    opts = opts || {};
+    const parsed = (0, url_js_1.url)(uri, opts.path || "/socket.io");
+    const source = parsed.source;
+    const id = parsed.id;
+    const path = parsed.path;
+    const sameNamespace = cache[id] && path in cache[id]["nsps"];
+    const newConnection = opts.forceNew ||
+        opts["force new connection"] ||
+        false === opts.multiplex ||
+        sameNamespace;
+    let io;
+    if (newConnection) {
+        debug("ignoring socket cache for %s", source);
+        io = new manager_js_1.Manager(source, opts);
+    }
+    else {
+        if (!cache[id]) {
+            debug("new io instance for %s", source);
+            cache[id] = new manager_js_1.Manager(source, opts);
+        }
+        io = cache[id];
+    }
+    if (parsed.query && !opts.query) {
+        opts.query = parsed.queryKey;
+    }
+    return io.socket(parsed.path, opts);
+}
+// so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
+// namespace (e.g. `io.connect(...)`), for backward compatibility
+Object.assign(lookup, {
+    Manager: manager_js_1.Manager,
+    Socket: socket_js_1.Socket,
+    io: lookup,
+    connect: lookup,
+});
+/**
+ * Protocol version.
+ *
+ * @public
+ */
+var socket_io_parser_1 = require("socket.io-parser");
+Object.defineProperty(exports, "protocol", { enumerable: true, get: function () { return socket_io_parser_1.protocol; } });
+var engine_io_client_1 = require("engine.io-client");
+Object.defineProperty(exports, "Fetch", { enumerable: true, get: function () { return engine_io_client_1.Fetch; } });
+Object.defineProperty(exports, "NodeXHR", { enumerable: true, get: function () { return engine_io_client_1.NodeXHR; } });
+Object.defineProperty(exports, "XHR", { enumerable: true, get: function () { return engine_io_client_1.XHR; } });
+Object.defineProperty(exports, "NodeWebSocket", { enumerable: true, get: function () { return engine_io_client_1.NodeWebSocket; } });
+Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function () { return engine_io_client_1.WebSocket; } });
+Object.defineProperty(exports, "WebTransport", { enumerable: true, get: function () { return engine_io_client_1.WebTransport; } });
+
+module.exports = lookup;

package/node_modules/socket.io-client/build/cjs/manager.d.ts

@@ -0,0 +1,295 @@
+import { Socket as Engine, SocketOptions as EngineOptions } from "engine.io-client";
+import { Socket, SocketOptions, DisconnectDescription } from "./socket.js";
+import { Packet } from "socket.io-parser";
+import { DefaultEventsMap, EventsMap, Emitter } from "@socket.io/component-emitter";
+export interface ManagerOptions extends EngineOptions {
+    /**
+     * Should we force a new Manager for this connection?
+     * @default false
+     */
+    forceNew: boolean;
+    /**
+     * Should we multiplex our connection (reuse existing Manager) ?
+     * @default true
+     */
+    multiplex: boolean;
+    /**
+     * The path to get our client file from, in the case of the server
+     * serving it
+     * @default '/socket.io'
+     */
+    path: string;
+    /**
+     * Should we allow reconnections?
+     * @default true
+     */
+    reconnection: boolean;
+    /**
+     * How many reconnection attempts should we try?
+     * @default Infinity
+     */
+    reconnectionAttempts: number;
+    /**
+     * The time delay in milliseconds between reconnection attempts
+     * @default 1000
+     */
+    reconnectionDelay: number;
+    /**
+     * The max time delay in milliseconds between reconnection attempts
+     * @default 5000
+     */
+    reconnectionDelayMax: number;
+    /**
+     * Used in the exponential backoff jitter when reconnecting
+     * @default 0.5
+     */
+    randomizationFactor: number;
+    /**
+     * The timeout in milliseconds for our connection attempt
+     * @default 20000
+     */
+    timeout: number;
+    /**
+     * Should we automatically connect?
+     * @default true
+     */
+    autoConnect: boolean;
+    /**
+     * the parser to use. Defaults to an instance of the Parser that ships with socket.io.
+     */
+    parser: any;
+}
+interface ManagerReservedEvents {
+    open: () => void;
+    error: (err: Error) => void;
+    ping: () => void;
+    packet: (packet: Packet) => void;
+    close: (reason: string, description?: DisconnectDescription) => void;
+    reconnect_failed: () => void;
+    reconnect_attempt: (attempt: number) => void;
+    reconnect_error: (err: Error) => void;
+    reconnect: (attempt: number) => void;
+}
+export declare class Manager<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents> extends Emitter<{}, {}, ManagerReservedEvents> {
+    /**
+     * The Engine.IO client instance
+     *
+     * @public
+     */
+    engine: Engine;
+    /**
+     * @private
+     */
+    _autoConnect: boolean;
+    /**
+     * @private
+     */
+    _readyState: "opening" | "open" | "closed";
+    /**
+     * @private
+     */
+    _reconnecting: boolean;
+    private readonly uri;
+    opts: Partial<ManagerOptions>;
+    private nsps;
+    private subs;
+    private backoff;
+    private setTimeoutFn;
+    private clearTimeoutFn;
+    private _reconnection;
+    private _reconnectionAttempts;
+    private _reconnectionDelay;
+    private _randomizationFactor;
+    private _reconnectionDelayMax;
+    private _timeout;
+    private encoder;
+    private decoder;
+    private skipReconnect;
+    /**
+     * `Manager` constructor.
+     *
+     * @param uri - engine instance or engine uri/opts
+     * @param opts - options
+     * @public
+     */
+    constructor(opts: Partial<ManagerOptions>);
+    constructor(uri?: string, opts?: Partial<ManagerOptions>);
+    constructor(uri?: string | Partial<ManagerOptions>, opts?: Partial<ManagerOptions>);
+    /**
+     * Sets the `reconnection` config.
+     *
+     * @param {Boolean} v - true/false if it should automatically reconnect
+     * @return {Manager} self or value
+     * @public
+     */
+    reconnection(v: boolean): this;
+    reconnection(): boolean;
+    reconnection(v?: boolean): this | boolean;
+    /**
+     * Sets the reconnection attempts config.
+     *
+     * @param {Number} v - max reconnection attempts before giving up
+     * @return {Manager} self or value
+     * @public
+     */
+    reconnectionAttempts(v: number): this;
+    reconnectionAttempts(): number;
+    reconnectionAttempts(v?: number): this | number;
+    /**
+     * Sets the delay between reconnections.
+     *
+     * @param {Number} v - delay
+     * @return {Manager} self or value
+     * @public
+     */
+    reconnectionDelay(v: number): this;
+    reconnectionDelay(): number;
+    reconnectionDelay(v?: number): this | number;
+    /**
+     * Sets the randomization factor
+     *
+     * @param v - the randomization factor
+     * @return self or value
+     * @public
+     */
+    randomizationFactor(v: number): this;
+    randomizationFactor(): number;
+    randomizationFactor(v?: number): this | number;
+    /**
+     * Sets the maximum delay between reconnections.
+     *
+     * @param v - delay
+     * @return self or value
+     * @public
+     */
+    reconnectionDelayMax(v: number): this;
+    reconnectionDelayMax(): number;
+    reconnectionDelayMax(v?: number): this | number;
+    /**
+     * Sets the connection timeout. `false` to disable
+     *
+     * @param v - connection timeout
+     * @return self or value
+     * @public
+     */
+    timeout(v: number | boolean): this;
+    timeout(): number | boolean;
+    timeout(v?: number | boolean): this | number | boolean;
+    /**
+     * Starts trying to reconnect if reconnection is enabled and we have not
+     * started reconnecting yet
+     *
+     * @private
+     */
+    private maybeReconnectOnOpen;
+    /**
+     * Sets the current transport `socket`.
+     *
+     * @param {Function} fn - optional, callback
+     * @return self
+     * @public
+     */
+    open(fn?: (err?: Error) => void): this;
+    /**
+     * Alias for open()
+     *
+     * @return self
+     * @public
+     */
+    connect(fn?: (err?: Error) => void): this;
+    /**
+     * Called upon transport open.
+     *
+     * @private
+     */
+    private onopen;
+    /**
+     * Called upon a ping.
+     *
+     * @private
+     */
+    private onping;
+    /**
+     * Called with data.
+     *
+     * @private
+     */
+    private ondata;
+    /**
+     * Called when parser fully decodes a packet.
+     *
+     * @private
+     */
+    private ondecoded;
+    /**
+     * Called upon socket error.
+     *
+     * @private
+     */
+    private onerror;
+    /**
+     * Creates a new socket for the given `nsp`.
+     *
+     * @return {Socket}
+     * @public
+     */
+    socket(nsp: string, opts?: Partial<SocketOptions>): Socket;
+    /**
+     * Called upon a socket close.
+     *
+     * @param socket
+     * @private
+     */
+    _destroy(socket: Socket): void;
+    /**
+     * Writes a packet.
+     *
+     * @param packet
+     * @private
+     */
+    _packet(packet: Partial<Packet & {
+        query: string;
+        options: any;
+    }>): void;
+    /**
+     * Clean up transport subscriptions and packet buffer.
+     *
+     * @private
+     */
+    private cleanup;
+    /**
+     * Close the current socket.
+     *
+     * @private
+     */
+    _close(): void;
+    /**
+     * Alias for close()
+     *
+     * @private
+     */
+    private disconnect;
+    /**
+     * Called when:
+     *
+     * - the low-level engine is closed
+     * - the parser encountered a badly formatted packet
+     * - all sockets are disconnected
+     *
+     * @private
+     */
+    private onclose;
+    /**
+     * Attempt a reconnection.
+     *
+     * @private
+     */
+    private reconnect;
+    /**
+     * Called upon successful reconnect.
+     *
+     * @private
+     */
+    private onreconnect;
+}
+export {};