KI

KJ

unified-ai-platform/node_modules/socket.io-adapter/dist/cluster-adapter.d.ts

@@ -0,0 +1,201 @@
+import { Adapter } from "./in-memory-adapter";
+import type { BroadcastFlags, BroadcastOptions, Room } from "./in-memory-adapter";
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+/**
+ * The unique ID of a server
+ */
+export type ServerId = string;
+/**
+ * The unique ID of a message (for the connection state recovery feature)
+ */
+export type Offset = string;
+export interface ClusterAdapterOptions {
+    /**
+     * The number of ms between two heartbeats.
+     * @default 5_000
+     */
+    heartbeatInterval?: number;
+    /**
+     * The number of ms without heartbeat before we consider a node down.
+     * @default 10_000
+     */
+    heartbeatTimeout?: number;
+}
+export declare enum MessageType {
+    INITIAL_HEARTBEAT = 1,
+    HEARTBEAT = 2,
+    BROADCAST = 3,
+    SOCKETS_JOIN = 4,
+    SOCKETS_LEAVE = 5,
+    DISCONNECT_SOCKETS = 6,
+    FETCH_SOCKETS = 7,
+    FETCH_SOCKETS_RESPONSE = 8,
+    SERVER_SIDE_EMIT = 9,
+    SERVER_SIDE_EMIT_RESPONSE = 10,
+    BROADCAST_CLIENT_COUNT = 11,
+    BROADCAST_ACK = 12,
+    ADAPTER_CLOSE = 13
+}
+export type ClusterMessage = {
+    uid: ServerId;
+    nsp: string;
+} & ({
+    type: MessageType.INITIAL_HEARTBEAT | MessageType.HEARTBEAT | MessageType.ADAPTER_CLOSE;
+} | {
+    type: MessageType.BROADCAST;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        packet: unknown;
+        requestId?: string;
+    };
+} | {
+    type: MessageType.SOCKETS_JOIN | MessageType.SOCKETS_LEAVE;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        rooms: string[];
+    };
+} | {
+    type: MessageType.DISCONNECT_SOCKETS;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        close?: boolean;
+    };
+} | {
+    type: MessageType.FETCH_SOCKETS;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        requestId: string;
+    };
+} | {
+    type: MessageType.SERVER_SIDE_EMIT;
+    data: {
+        requestId?: string;
+        packet: any[];
+    };
+});
+export type ClusterResponse = {
+    uid: ServerId;
+    nsp: string;
+} & ({
+    type: MessageType.FETCH_SOCKETS_RESPONSE;
+    data: {
+        requestId: string;
+        sockets: unknown[];
+    };
+} | {
+    type: MessageType.SERVER_SIDE_EMIT_RESPONSE;
+    data: {
+        requestId: string;
+        packet: unknown;
+    };
+} | {
+    type: MessageType.BROADCAST_CLIENT_COUNT;
+    data: {
+        requestId: string;
+        clientCount: number;
+    };
+} | {
+    type: MessageType.BROADCAST_ACK;
+    data: {
+        requestId: string;
+        packet: unknown;
+    };
+});
+/**
+ * A cluster-ready adapter. Any extending class must:
+ *
+ * - implement {@link ClusterAdapter#doPublish} and {@link ClusterAdapter#doPublishResponse}
+ * - call {@link ClusterAdapter#onMessage} and {@link ClusterAdapter#onResponse}
+ */
+export declare abstract class ClusterAdapter extends Adapter {
+    protected readonly uid: ServerId;
+    private requests;
+    private ackRequests;
+    protected constructor(nsp: any);
+    /**
+     * Called when receiving a message from another member of the cluster.
+     *
+     * @param message
+     * @param offset
+     * @protected
+     */
+    protected onMessage(message: ClusterMessage, offset?: string): void;
+    /**
+     * Called when receiving a response from another member of the cluster.
+     *
+     * @param response
+     * @protected
+     */
+    protected onResponse(response: ClusterResponse): void;
+    broadcast(packet: any, opts: BroadcastOptions): Promise<void>;
+    /**
+     * Adds an offset at the end of the data array in order to allow the client to receive any missed packets when it
+     * reconnects after a temporary disconnection.
+     *
+     * @param packet
+     * @param opts
+     * @param offset
+     * @private
+     */
+    private addOffsetIfNecessary;
+    broadcastWithAck(packet: any, opts: BroadcastOptions, clientCountCallback: (clientCount: number) => void, ack: (...args: any[]) => void): void;
+    addSockets(opts: BroadcastOptions, rooms: Room[]): Promise<void>;
+    delSockets(opts: BroadcastOptions, rooms: Room[]): Promise<void>;
+    disconnectSockets(opts: BroadcastOptions, close: boolean): Promise<void>;
+    fetchSockets(opts: BroadcastOptions): Promise<any[]>;
+    serverSideEmit(packet: any[]): Promise<any>;
+    protected publish(message: DistributiveOmit<ClusterMessage, "nsp" | "uid">): void;
+    protected publishAndReturnOffset(message: DistributiveOmit<ClusterMessage, "nsp" | "uid">): Promise<string>;
+    /**
+     * Send a message to the other members of the cluster.
+     *
+     * @param message
+     * @protected
+     * @return an offset, if applicable
+     */
+    protected abstract doPublish(message: ClusterMessage): Promise<Offset>;
+    protected publishResponse(requesterUid: ServerId, response: Omit<ClusterResponse, "nsp" | "uid">): void;
+    /**
+     * Send a response to the given member of the cluster.
+     *
+     * @param requesterUid
+     * @param response
+     * @protected
+     */
+    protected abstract doPublishResponse(requesterUid: ServerId, response: ClusterResponse): Promise<void>;
+}
+export declare abstract class ClusterAdapterWithHeartbeat extends ClusterAdapter {
+    private readonly _opts;
+    private heartbeatTimer;
+    private nodesMap;
+    private readonly cleanupTimer;
+    private customRequests;
+    protected constructor(nsp: any, opts: ClusterAdapterOptions);
+    init(): void;
+    private scheduleHeartbeat;
+    close(): void;
+    onMessage(message: ClusterMessage, offset?: string): void;
+    serverCount(): Promise<number>;
+    publish(message: DistributiveOmit<ClusterMessage, "nsp" | "uid">): void;
+    serverSideEmit(packet: any[]): Promise<any>;
+    fetchSockets(opts: BroadcastOptions): Promise<any[]>;
+    onResponse(response: ClusterResponse): void;
+    private removeNode;
+}
+export {};

unified-ai-platform/node_modules/socket.io-adapter/dist/contrib/yeast.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Return a string representing the specified number.
+ *
+ * @param {Number} num The number to convert.
+ * @returns {String} The string representation of the number.
+ * @api public
+ */
+export declare function encode(num: any): string;
+/**
+ * Return the integer value specified by the given string.
+ *
+ * @param {String} str The string to convert.
+ * @returns {Number} The integer value represented by the string.
+ * @api public
+ */
+export declare function decode(str: any): number;
+/**
+ * Yeast: A tiny growing id generator.
+ *
+ * @returns {String} A unique id.
+ * @api public
+ */
+export declare function yeast(): string;

unified-ai-platform/node_modules/socket.io-adapter/dist/contrib/yeast.js

@@ -0,0 +1,55 @@
+// imported from https://github.com/unshiftio/yeast
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yeast = exports.decode = exports.encode = void 0;
+const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split(""), length = 64, map = {};
+let seed = 0, i = 0, prev;
+/**
+ * Return a string representing the specified number.
+ *
+ * @param {Number} num The number to convert.
+ * @returns {String} The string representation of the number.
+ * @api public
+ */
+function encode(num) {
+    let encoded = "";
+    do {
+        encoded = alphabet[num % length] + encoded;
+        num = Math.floor(num / length);
+    } while (num > 0);
+    return encoded;
+}
+exports.encode = encode;
+/**
+ * Return the integer value specified by the given string.
+ *
+ * @param {String} str The string to convert.
+ * @returns {Number} The integer value represented by the string.
+ * @api public
+ */
+function decode(str) {
+    let decoded = 0;
+    for (i = 0; i < str.length; i++) {
+        decoded = decoded * length + map[str.charAt(i)];
+    }
+    return decoded;
+}
+exports.decode = decode;
+/**
+ * Yeast: A tiny growing id generator.
+ *
+ * @returns {String} A unique id.
+ * @api public
+ */
+function yeast() {
+    const now = encode(+new Date());
+    if (now !== prev)
+        return (seed = 0), (prev = now);
+    return now + "." + encode(seed++);
+}
+exports.yeast = yeast;
+//
+// Map each character to its index.
+//
+for (; i < length; i++)
+    map[alphabet[i]] = i;

unified-ai-platform/node_modules/socket.io-adapter/dist/in-memory-adapter.d.ts

@@ -0,0 +1,179 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+/**
+ * A public ID, sent by the server at the beginning of the Socket.IO session and which can be used for private messaging
+ */
+export type SocketId = string;
+/**
+ * A private ID, sent by the server at the beginning of the Socket.IO session and used for connection state recovery
+ * upon reconnection
+ */
+export type PrivateSessionId = string;
+export type Room = string;
+export interface BroadcastFlags {
+    volatile?: boolean;
+    compress?: boolean;
+    local?: boolean;
+    broadcast?: boolean;
+    binary?: boolean;
+    timeout?: number;
+}
+export interface BroadcastOptions {
+    rooms: Set<Room>;
+    except?: Set<Room>;
+    flags?: BroadcastFlags;
+}
+interface SessionToPersist {
+    sid: SocketId;
+    pid: PrivateSessionId;
+    rooms: Room[];
+    data: unknown;
+}
+export type Session = SessionToPersist & {
+    missedPackets: unknown[][];
+};
+export declare class Adapter extends EventEmitter {
+    readonly nsp: any;
+    rooms: Map<Room, Set<SocketId>>;
+    sids: Map<SocketId, Set<Room>>;
+    private readonly encoder;
+    /**
+     * In-memory adapter constructor.
+     *
+     * @param {Namespace} nsp
+     */
+    constructor(nsp: any);
+    /**
+     * To be overridden
+     */
+    init(): Promise<void> | void;
+    /**
+     * To be overridden
+     */
+    close(): Promise<void> | void;
+    /**
+     * Returns the number of Socket.IO servers in the cluster
+     *
+     * @public
+     */
+    serverCount(): Promise<number>;
+    /**
+     * Adds a socket to a list of room.
+     *
+     * @param {SocketId}  id      the socket id
+     * @param {Set<Room>} rooms   a set of rooms
+     * @public
+     */
+    addAll(id: SocketId, rooms: Set<Room>): Promise<void> | void;
+    /**
+     * Removes a socket from a room.
+     *
+     * @param {SocketId} id     the socket id
+     * @param {Room}     room   the room name
+     */
+    del(id: SocketId, room: Room): Promise<void> | void;
+    private _del;
+    /**
+     * Removes a socket from all rooms it's joined.
+     *
+     * @param {SocketId} id   the socket id
+     */
+    delAll(id: SocketId): void;
+    /**
+     * Broadcasts a packet.
+     *
+     * Options:
+     *  - `flags` {Object} flags for this packet
+     *  - `except` {Array} sids that should be excluded
+     *  - `rooms` {Array} list of rooms to broadcast to
+     *
+     * @param {Object} packet   the packet object
+     * @param {Object} opts     the options
+     * @public
+     */
+    broadcast(packet: any, opts: BroadcastOptions): void;
+    /**
+     * Broadcasts a packet and expects multiple acknowledgements.
+     *
+     * Options:
+     *  - `flags` {Object} flags for this packet
+     *  - `except` {Array} sids that should be excluded
+     *  - `rooms` {Array} list of rooms to broadcast to
+     *
+     * @param {Object} packet   the packet object
+     * @param {Object} opts     the options
+     * @param clientCountCallback - the number of clients that received the packet
+     * @param ack                 - the callback that will be called for each client response
+     *
+     * @public
+     */
+    broadcastWithAck(packet: any, opts: BroadcastOptions, clientCountCallback: (clientCount: number) => void, ack: (...args: any[]) => void): void;
+    private _encode;
+    /**
+     * Gets a list of sockets by sid.
+     *
+     * @param {Set<Room>} rooms   the explicit set of rooms to check.
+     */
+    sockets(rooms: Set<Room>): Promise<Set<SocketId>>;
+    /**
+     * Gets the list of rooms a given socket has joined.
+     *
+     * @param {SocketId} id   the socket id
+     */
+    socketRooms(id: SocketId): Set<Room> | undefined;
+    /**
+     * Returns the matching socket instances
+     *
+     * @param opts - the filters to apply
+     */
+    fetchSockets(opts: BroadcastOptions): Promise<any[]>;
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param opts - the filters to apply
+     * @param rooms - the rooms to join
+     */
+    addSockets(opts: BroadcastOptions, rooms: Room[]): void;
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param opts - the filters to apply
+     * @param rooms - the rooms to leave
+     */
+    delSockets(opts: BroadcastOptions, rooms: Room[]): void;
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param opts - the filters to apply
+     * @param close - whether to close the underlying connection
+     */
+    disconnectSockets(opts: BroadcastOptions, close: boolean): void;
+    private apply;
+    private computeExceptSids;
+    /**
+     * Send a packet to the other Socket.IO servers in the cluster
+     * @param packet - an array of arguments, which may include an acknowledgement callback at the end
+     */
+    serverSideEmit(packet: any[]): void;
+    /**
+     * Save the client session in order to restore it upon reconnection.
+     */
+    persistSession(session: SessionToPersist): void;
+    /**
+     * Restore the session and find the packets that were missed by the client.
+     * @param pid
+     * @param offset
+     */
+    restoreSession(pid: PrivateSessionId, offset: string): Promise<Session>;
+}
+export declare class SessionAwareAdapter extends Adapter {
+    readonly nsp: any;
+    private readonly maxDisconnectionDuration;
+    private sessions;
+    private packets;
+    constructor(nsp: any);
+    persistSession(session: SessionToPersist): void;
+    restoreSession(pid: PrivateSessionId, offset: string): Promise<Session>;
+    broadcast(packet: any, opts: BroadcastOptions): void;
+}
+export {};

unified-ai-platform/node_modules/socket.io-adapter/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { SocketId, PrivateSessionId, Room, BroadcastFlags, BroadcastOptions, Session, Adapter, SessionAwareAdapter, } from "./in-memory-adapter";
+export { ClusterAdapter, ClusterAdapterWithHeartbeat, ClusterAdapterOptions, ClusterMessage, ClusterResponse, MessageType, ServerId, Offset, } from "./cluster-adapter";

unified-ai-platform/node_modules/socket.io-adapter/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageType = exports.ClusterAdapterWithHeartbeat = exports.ClusterAdapter = exports.SessionAwareAdapter = exports.Adapter = void 0;
+var in_memory_adapter_1 = require("./in-memory-adapter");
+Object.defineProperty(exports, "Adapter", { enumerable: true, get: function () { return in_memory_adapter_1.Adapter; } });
+Object.defineProperty(exports, "SessionAwareAdapter", { enumerable: true, get: function () { return in_memory_adapter_1.SessionAwareAdapter; } });
+var cluster_adapter_1 = require("./cluster-adapter");
+Object.defineProperty(exports, "ClusterAdapter", { enumerable: true, get: function () { return cluster_adapter_1.ClusterAdapter; } });
+Object.defineProperty(exports, "ClusterAdapterWithHeartbeat", { enumerable: true, get: function () { return cluster_adapter_1.ClusterAdapterWithHeartbeat; } });
+Object.defineProperty(exports, "MessageType", { enumerable: true, get: function () { return cluster_adapter_1.MessageType; } });