lightclaw2 0.0.1

package/node_modules/engine.io-client/build/cjs/transport.d.ts

@@ -0,0 +1,106 @@
+import type { Packet, RawData } from "engine.io-parser";
+import { Emitter } from "@socket.io/component-emitter";
+import type { Socket, SocketOptions } from "./socket.js";
+export declare class TransportError extends Error {
+    readonly description: any;
+    readonly context: any;
+    readonly type = "TransportError";
+    constructor(reason: string, description: any, context: any);
+}
+export interface CloseDetails {
+    description: string;
+    context?: unknown;
+}
+interface TransportReservedEvents {
+    open: () => void;
+    error: (err: TransportError) => void;
+    packet: (packet: Packet) => void;
+    close: (details?: CloseDetails) => void;
+    poll: () => void;
+    pollComplete: () => void;
+    drain: () => void;
+}
+type TransportState = "opening" | "open" | "closed" | "pausing" | "paused";
+export declare abstract class Transport extends Emitter<Record<never, never>, Record<never, never>, TransportReservedEvents> {
+    query: Record<string, string>;
+    writable: boolean;
+    protected opts: SocketOptions;
+    protected supportsBinary: boolean;
+    protected readyState: TransportState;
+    protected socket: Socket;
+    protected setTimeoutFn: typeof setTimeout;
+    /**
+     * Transport abstract constructor.
+     *
+     * @param {Object} opts - options
+     * @protected
+     */
+    constructor(opts: any);
+    /**
+     * Emits an error.
+     *
+     * @param {String} reason
+     * @param description
+     * @param context - the error context
+     * @return {Transport} for chaining
+     * @protected
+     */
+    protected onError(reason: string, description: any, context?: any): this;
+    /**
+     * Opens the transport.
+     */
+    open(): this;
+    /**
+     * Closes the transport.
+     */
+    close(): this;
+    /**
+     * Sends multiple packets.
+     *
+     * @param {Array} packets
+     */
+    send(packets: any): void;
+    /**
+     * Called upon open
+     *
+     * @protected
+     */
+    protected onOpen(): void;
+    /**
+     * Called with data.
+     *
+     * @param {String} data
+     * @protected
+     */
+    protected onData(data: RawData): void;
+    /**
+     * Called with a decoded packet.
+     *
+     * @protected
+     */
+    protected onPacket(packet: Packet): void;
+    /**
+     * Called upon close.
+     *
+     * @protected
+     */
+    protected onClose(details?: CloseDetails): void;
+    /**
+     * The name of the transport
+     */
+    abstract get name(): string;
+    /**
+     * Pauses the transport, in order not to lose packets during an upgrade.
+     *
+     * @param onPause
+     */
+    pause(onPause: () => void): void;
+    protected createUri(schema: string, query?: Record<string, unknown>): string;
+    private _hostname;
+    private _port;
+    private _query;
+    protected abstract doOpen(): any;
+    protected abstract doClose(): any;
+    protected abstract write(packets: Packet[]): any;
+}
+export {};

package/node_modules/engine.io-client/build/cjs/transport.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = exports.TransportError = void 0;
+const engine_io_parser_1 = require("engine.io-parser");
+const component_emitter_1 = require("@socket.io/component-emitter");
+const util_js_1 = require("./util.js");
+const parseqs_js_1 = require("./contrib/parseqs.js");
+const debug_1 = __importDefault(require("debug")); // debug()
+const debug = (0, debug_1.default)("engine.io-client:transport"); // debug()
+class TransportError extends Error {
+    constructor(reason, description, context) {
+        super(reason);
+        this.description = description;
+        this.context = context;
+        this.type = "TransportError";
+    }
+}
+exports.TransportError = TransportError;
+class Transport extends component_emitter_1.Emitter {
+    /**
+     * Transport abstract constructor.
+     *
+     * @param {Object} opts - options
+     * @protected
+     */
+    constructor(opts) {
+        super();
+        this.writable = false;
+        (0, util_js_1.installTimerFunctions)(this, opts);
+        this.opts = opts;
+        this.query = opts.query;
+        this.socket = opts.socket;
+        this.supportsBinary = !opts.forceBase64;
+    }
+    /**
+     * Emits an error.
+     *
+     * @param {String} reason
+     * @param description
+     * @param context - the error context
+     * @return {Transport} for chaining
+     * @protected
+     */
+    onError(reason, description, context) {
+        super.emitReserved("error", new TransportError(reason, description, context));
+        return this;
+    }
+    /**
+     * Opens the transport.
+     */
+    open() {
+        this.readyState = "opening";
+        this.doOpen();
+        return this;
+    }
+    /**
+     * Closes the transport.
+     */
+    close() {
+        if (this.readyState === "opening" || this.readyState === "open") {
+            this.doClose();
+            this.onClose();
+        }
+        return this;
+    }
+    /**
+     * Sends multiple packets.
+     *
+     * @param {Array} packets
+     */
+    send(packets) {
+        if (this.readyState === "open") {
+            this.write(packets);
+        }
+        else {
+            // this might happen if the transport was silently closed in the beforeunload event handler
+            debug("transport is not open, discarding packets");
+        }
+    }
+    /**
+     * Called upon open
+     *
+     * @protected
+     */
+    onOpen() {
+        this.readyState = "open";
+        this.writable = true;
+        super.emitReserved("open");
+    }
+    /**
+     * Called with data.
+     *
+     * @param {String} data
+     * @protected
+     */
+    onData(data) {
+        const packet = (0, engine_io_parser_1.decodePacket)(data, this.socket.binaryType);
+        this.onPacket(packet);
+    }
+    /**
+     * Called with a decoded packet.
+     *
+     * @protected
+     */
+    onPacket(packet) {
+        super.emitReserved("packet", packet);
+    }
+    /**
+     * Called upon close.
+     *
+     * @protected
+     */
+    onClose(details) {
+        this.readyState = "closed";
+        super.emitReserved("close", details);
+    }
+    /**
+     * Pauses the transport, in order not to lose packets during an upgrade.
+     *
+     * @param onPause
+     */
+    pause(onPause) { }
+    createUri(schema, query = {}) {
+        return (schema +
+            "://" +
+            this._hostname() +
+            this._port() +
+            this.opts.path +
+            this._query(query));
+    }
+    _hostname() {
+        const hostname = this.opts.hostname;
+        return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
+    }
+    _port() {
+        if (this.opts.port &&
+            ((this.opts.secure && Number(this.opts.port) !== 443) ||
+                (!this.opts.secure && Number(this.opts.port) !== 80))) {
+            return ":" + this.opts.port;
+        }
+        else {
+            return "";
+        }
+    }
+    _query(query) {
+        const encodedQuery = (0, parseqs_js_1.encode)(query);
+        return encodedQuery.length ? "?" + encodedQuery : "";
+    }
+}
+exports.Transport = Transport;

package/node_modules/engine.io-client/build/cjs/transports/index.d.ts

@@ -0,0 +1,8 @@
+import { XHR } from "./polling-xhr.node.js";
+import { WS } from "./websocket.node.js";
+import { WT } from "./webtransport.js";
+export declare const transports: {
+    websocket: typeof WS;
+    webtransport: typeof WT;
+    polling: typeof XHR;
+};

package/node_modules/engine.io-client/build/cjs/transports/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transports = void 0;
+const polling_xhr_node_js_1 = require("./polling-xhr.node.js");
+const websocket_node_js_1 = require("./websocket.node.js");
+const webtransport_js_1 = require("./webtransport.js");
+exports.transports = {
+    websocket: websocket_node_js_1.WS,
+    webtransport: webtransport_js_1.WT,
+    polling: polling_xhr_node_js_1.XHR,
+};

package/node_modules/engine.io-client/build/cjs/transports/polling-fetch.d.ts

@@ -0,0 +1,15 @@
+import { Polling } from "./polling.js";
+/**
+ * HTTP long-polling based on the built-in `fetch()` method.
+ *
+ * Usage: browser, Node.js (since v18), Deno, Bun
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/fetch
+ * @see https://caniuse.com/fetch
+ * @see https://nodejs.org/api/globals.html#fetch
+ */
+export declare class Fetch extends Polling {
+    doPoll(): void;
+    doWrite(data: string, callback: () => void): void;
+    private _fetch;
+}

package/node_modules/engine.io-client/build/cjs/transports/polling-fetch.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fetch = void 0;
+const polling_js_1 = require("./polling.js");
+/**
+ * HTTP long-polling based on the built-in `fetch()` method.
+ *
+ * Usage: browser, Node.js (since v18), Deno, Bun
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/fetch
+ * @see https://caniuse.com/fetch
+ * @see https://nodejs.org/api/globals.html#fetch
+ */
+class Fetch extends polling_js_1.Polling {
+    doPoll() {
+        this._fetch()
+            .then((res) => {
+            if (!res.ok) {
+                return this.onError("fetch read error", res.status, res);
+            }
+            res.text().then((data) => this.onData(data));
+        })
+            .catch((err) => {
+            this.onError("fetch read error", err);
+        });
+    }
+    doWrite(data, callback) {
+        this._fetch(data)
+            .then((res) => {
+            if (!res.ok) {
+                return this.onError("fetch write error", res.status, res);
+            }
+            callback();
+        })
+            .catch((err) => {
+            this.onError("fetch write error", err);
+        });
+    }
+    _fetch(data) {
+        var _a;
+        const isPost = data !== undefined;
+        const headers = new Headers(this.opts.extraHeaders);
+        if (isPost) {
+            headers.set("content-type", "text/plain;charset=UTF-8");
+        }
+        (_a = this.socket._cookieJar) === null || _a === void 0 ? void 0 : _a.appendCookies(headers);
+        return fetch(this.uri(), {
+            method: isPost ? "POST" : "GET",
+            body: isPost ? data : null,
+            headers,
+            credentials: this.opts.withCredentials ? "include" : "omit",
+        }).then((res) => {
+            var _a;
+            // @ts-ignore getSetCookie() was added in Node.js v19.7.0
+            (_a = this.socket._cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(res.headers.getSetCookie());
+            return res;
+        });
+    }
+}
+exports.Fetch = Fetch;

package/node_modules/engine.io-client/build/cjs/transports/polling-xhr.d.ts

@@ -0,0 +1,108 @@
+import { Polling } from "./polling.js";
+import { Emitter } from "@socket.io/component-emitter";
+import type { SocketOptions } from "../socket.js";
+import type { CookieJar } from "../globals.node.js";
+import type { RawData } from "engine.io-parser";
+export declare abstract class BaseXHR extends Polling {
+    protected readonly xd: boolean;
+    private pollXhr;
+    /**
+     * XHR Polling constructor.
+     *
+     * @param {Object} opts
+     * @package
+     */
+    constructor(opts: any);
+    /**
+     * Creates a request.
+     *
+     * @private
+     */
+    abstract request(opts?: Record<string, any>): any;
+    /**
+     * Sends data.
+     *
+     * @param {String} data to send.
+     * @param {Function} called upon flush.
+     * @private
+     */
+    doWrite(data: any, fn: any): void;
+    /**
+     * Starts a poll cycle.
+     *
+     * @private
+     */
+    doPoll(): void;
+}
+interface RequestReservedEvents {
+    success: () => void;
+    data: (data: RawData) => void;
+    error: (err: number | Error, context: unknown) => void;
+}
+export type RequestOptions = SocketOptions & {
+    method?: string;
+    data?: RawData;
+    xd: boolean;
+    cookieJar: CookieJar;
+};
+export declare class Request extends Emitter<Record<never, never>, Record<never, never>, RequestReservedEvents> {
+    private readonly createRequest;
+    private readonly _opts;
+    private readonly _method;
+    private readonly _uri;
+    private readonly _data;
+    private _xhr;
+    private setTimeoutFn;
+    private _index;
+    static requestsCount: number;
+    static requests: {};
+    /**
+     * Request constructor
+     *
+     * @param {Object} options
+     * @package
+     */
+    constructor(createRequest: (opts: RequestOptions) => XMLHttpRequest, uri: string, opts: RequestOptions);
+    /**
+     * Creates the XHR object and sends the request.
+     *
+     * @private
+     */
+    private _create;
+    /**
+     * Called upon error.
+     *
+     * @private
+     */
+    private _onError;
+    /**
+     * Cleans up house.
+     *
+     * @private
+     */
+    private _cleanup;
+    /**
+     * Called upon load.
+     *
+     * @private
+     */
+    private _onLoad;
+    /**
+     * Aborts the request.
+     *
+     * @package
+     */
+    abort(): void;
+}
+/**
+ * HTTP long-polling based on the built-in `XMLHttpRequest` object.
+ *
+ * Usage: browser
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
+ */
+export declare class XHR extends BaseXHR {
+    constructor(opts: any);
+    request(opts?: Record<string, any>): Request;
+}
+export {};