iosignal 3.0.0 → 3.0.1

package/dist/types/client/IOCore.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Core class for handling WebSocket communication.
+ * @augments {EventEmitter}
+ */
+export class IOCore extends EventEmitter<string | symbol, any> {
+    /**
+     * @param {string} url - The WebSocket URL to connect to.
+     */
+    constructor(url: string);
+    /**
+     * Client ID received from the server.
+     * @type {string}
+     */
+    cid: string;
+    /**
+     * IP address received from the server.
+     * @type {string}
+     */
+    ip: string;
+    /**
+     * The WebSocket instance.
+     * @type {WebSocket | null}
+     */
+    socket: WebSocket | null;
+    /**
+     * The default server URL.
+     * @type {string}
+     */
+    url: string;
+    /**
+     * Current connection state (number).
+     * @type {number}
+     */
+    state: number;
+    /**
+     * Current connection state (string).
+     * @type {string}
+     */
+    stateName: string;
+    /**
+     * Transmitted message counter.
+     * @type {number}
+     */
+    txCounter: number;
+    /**
+     * Received message counter.
+     * @type {number}
+     */
+    rxCounter: number;
+    /**
+     * Transmitted bytes counter.
+     * @type {number}
+     */
+    txBytes: number;
+    /**
+     * Received bytes counter.
+     * @type {number}
+     */
+    rxBytes: number;
+    /**
+     * Last transmit/receive time.
+     * @type {number}
+     */
+    lastTxRxTime: number;
+    /**
+     * Period for connection checker.
+     * @type {number}
+     */
+    connectionCheckerPeriod: number;
+    /**
+     * Interval ID for connection checker.
+     * @type {NodeJS.Timeout | null}
+     */
+    connectionCheckerIntervalID: NodeJS.Timeout | null;
+    /**
+     * Boho instance for encryption/decryption.
+     * @type {Boho}
+     */
+    boho: Boho;
+    /**
+     * Indicates if the connection is TLS (wss).
+     * @type {boolean}
+     */
+    TLS: boolean;
+    /**
+     * Encryption mode.
+     * @type {number}
+     */
+    encMode: number;
+    /**
+     * Indicates if authentication is used.
+     * @type {boolean}
+     */
+    useAuth: boolean;
+    /**
+     * Nickname.
+     * @type {string}
+     */
+    nick: string;
+    /**
+     * Set of subscribed channels.
+     * @type {Set<string>}
+     */
+    channels: Set<string>;
+    /**
+     * Map of promises for message responses.
+     * @type {Map<number, Array<Function>>}
+     */
+    promiseMap: Map<number, Array<Function>>;
+    /**
+     * Timeout for message promises.
+     * @type {number}
+     */
+    promiseTimeOut: number;
+    /**
+     * Message ID for promises.
+     * @type {number}
+     */
+    mid: number;
+    /**
+     * Quota level.
+     * @type {number}
+     */
+    level: number;
+    /**
+     * Quota table for current level.
+     * @type {object}
+     */
+    quota: object;
+    /**
+     * Server settings.
+     * @type {object}
+     */
+    serverSet: object;
+    /**
+     * Map of linked channels.
+     * @type {Map<string, Set<string>>}
+     */
+    linkMap: Map<string, Set<string>>;
+    /**
+     * Indicates if auto-reconnect is enabled.
+     * @type {boolean}
+     * @default true
+     * */
+    autoReconnect: boolean;
+    /**
+   * A flag to prevent duplicate close operations.
+   * @type {boolean}
+   * @private
+   */
+    private _closed;
+    /**
+     * Performs common cleanup for the connection. It clears pending promises,
+     * resets the socket reference, and sets the state to closed.
+     * This method is guarded to only run once.
+     * If autoReconnect is false, it also clears the keep-alive timer.
+     */
+    close(): void;
+    /**
+     * Disables auto-reconnect and closes the current connection.
+     * The instance can be re-opened manually later. For complete cleanup, use destroy().
+     */
+    stop(): void;
+    /**
+     * Permanently destroys the instance, cleaning up all resources.
+     * The instance will not be usable after this.
+     */
+    destroy(): void;
+    /**
+     * The core keep-alive logic. It checks if auto-reconnect is enabled.
+     * The actual check for the socket's state is implemented in the child classes.
+     */
+    keepAlive(): void;
+    /**
+     * Redirects the connection to a new URL.
+     * @param {string} url2 - The new URL to redirect to.
+     */
+    redirect(url2: string): void;
+    /**
+     * Opens the WebSocket connection.
+     * @param {string} [url] - Optional URL to connect to. If not provided, uses the instance's URL.
+     */
+    open(url?: string): void;
+    /**
+     * Handles the 'open' event of the WebSocket. Resets the closed flag and sets the state to open.
+     */
+    onOpen(): void;
+    /**
+     * Handles the 'close' event of the WebSocket.
+     */
+    onClose(): void;
+    /**
+     * Manually logs in with provided ID and key.
+     * @param {string} id - The user ID.
+     * @param {string} key - The user key.
+     * @returns {boolean}
+     */
+    login(id: string, key: string): boolean;
+    /**
+     * Sets up authentication for auto-login.
+     * @param {string} id - The user ID.
+     * @param {string} key - The user key.
+     * @returns {boolean}
+     */
+    auth(id: string, key: string): boolean;
+    /**
+     * Handles incoming data from the WebSocket.
+     * @param {Buffer} buffer - The incoming data buffer.
+     */
+    onData(buffer: Buffer): void;
+    /**
+     * Sends an IAM (I Am) message to the server.
+     * @param {string} [title] - Optional title for the IAM message.
+     */
+    iam(title?: string): void;
+    /**
+     * Sends a PING message to the server.
+     */
+    ping(): void;
+    /**
+     * Sends a PONG message to the server.
+     */
+    pong(): void;
+    /**
+     * Sends an ECHO message to the server.
+     * @param {*} [args] - Optional arguments to echo.
+     */
+    echo(args?: any): void;
+    /**
+     * Sends binary data.
+     * @param {...any} data - Data to send.
+     */
+    bin(...data: any[]): void;
+    /**
+     * Sends data over the WebSocket.
+     * @param {Buffer} data - The data buffer to send.
+     */
+    send(data: Buffer): void;
+    /**
+     * Determines if encryption should be used based on current mode and TLS status.
+     * @returns {boolean}
+     */
+    getEncryptionMode(): boolean;
+    /**
+     * Sends data with encryption based on the encryption mode.
+     * @param {Buffer} data - The data buffer to send.
+     * @param {boolean} [useEncryption] - Optional. Force encryption or not. If undefined, uses default policy.
+     */
+    send_enc_mode(data: Buffer, useEncryption?: boolean): void;
+    /**
+     * Sets a message promise for a given message ID.
+     * @param {number} mid - The message ID.
+     * @returns {Promise<any>}
+     */
+    setMsgPromise(mid: number): Promise<any>;
+    /**
+     * Tests and resolves/rejects a promise based on the incoming buffer.
+     * @param {Buffer} buffer - The incoming data buffer.
+     */
+    testPromise(buffer: Buffer): void;
+    /**
+     * Publishes a signal.
+     * @param {...any} args - Arguments for the signal.
+     */
+    publish(...args: any[]): void;
+    /**
+     * Sends a signal with a tag and arguments.
+     * @param {string} tag - The signal tag.
+     * @param {...any} args - Arguments for the signal.
+     * @throws {TypeError} If tag is not a string.
+     */
+    signal(tag: string, ...args: any[]): void;
+    /**
+     * Decrypts E2E data.
+     * @param {Buffer} data - The encrypted data.
+     * @param {string} key - The decryption key.
+     * @returns {Buffer}
+     */
+    decrypt_e2e(data: Buffer, key: string): Buffer;
+    /**
+     * Sends an E2E (End-to-End) encrypted signal.
+     * @param {string} tag - The signal tag.
+     * @param {Buffer} data - The data to encrypt and send.
+     * @param {string} key - The encryption key.
+     * @throws {TypeError} If tag is not a string.
+     */
+    signal_e2e(tag: string, data: Buffer, key: string): void;
+    /**
+     * Sets a value in the store.
+     * @param {string} storeName - The name of the store.
+     * @param {...any} args - Arguments to set.
+     * @returns {Promise<any>}
+     */
+    set(storeName: string, ...args: any[]): Promise<any>;
+    /**
+     * Gets a value from the store.
+     * @param {string} storeName - The name of the store.
+     * @returns {Promise<any>}
+     */
+    get(storeName: string): Promise<any>;
+    /**
+     * Sends a request to a target and topic.
+     * @param {string} target - The target of the request.
+     * @param {string} topic - The topic of the request.
+     * @param {...any} args - Optional arguments for the request.
+     * @returns {Promise<any>}
+     */
+    req(target: string, topic: string, ...args: any[]): Promise<any>;
+    /**
+     * Subscribes to a channel or channels.
+     * @param {string} tag - The tag(s) of the channel(s) to subscribe to (comma-separated).
+     * @throws {TypeError} If tag is not a string or exceeds length limit.
+     */
+    subscribe(tag: string): void;
+    /**
+     * Subscribes to a channel or channels with a promise.
+     * @param {string} tag - The tag(s) of the channel(s) to subscribe to (comma-separated).
+     * @returns {Promise<any>}
+     * @throws {TypeError} If tag is not a string or exceeds length limit.
+     */
+    subscribe_promise(tag: string): Promise<any>;
+    /**
+     * Subscribes to channels stored in memory (local cache).
+     */
+    subscribe_memory_channels(): void;
+    /**
+     * Unsubscribes from a channel or channels.
+     * @param {string} [tag=""] - The tag(s) of the channel(s) to unsubscribe from (comma-separated). If empty, unsubscribes from all.
+     * @throws {TypeError} If tag is not a string or exceeds length limit.
+     */
+    unsubscribe(tag?: string): void;
+    /**
+     * Listens for signals on a specific tag.
+     * @param {string} tag - The tag to listen on.
+     * @param {Function} handler - The callback function to handle the signal.
+     * @throws {TypeError} If tag is not a string, handler is not a function, or tag length is invalid.
+     */
+    listen(tag: string, handler: Function): void;
+    /**
+     * Links a local target to a remote tag and sets up a handler.
+     * @param {string} to - The local link target.
+     * @param {string} tag - The remote tag.
+     * @param {Function} handler - The callback function to handle the signal.
+     * @throws {TypeError} If 'to' or 'tag' are not strings, handler is not a function, or tag length is invalid.
+     */
+    link(to: string, tag: string, handler: Function): void;
+    /**
+     * Unlinks a specific tag from a local target.
+     * @param {string} to - The local link target.
+     * @param {string} tag - The tag to unlink.
+     * @throws {TypeError} If 'to' or 'tag' are not strings or tag length is invalid.
+     */
+    unlink(to: string, tag: string): void;
+    /**
+     * Unlinks all tags from a local target.
+     * @param {string} to - The local link target.
+     * @throws {TypeError} If 'to' is not a string.
+     */
+    unlinkAll(to: string): void;
+    /**
+     * Gets connection metrics.
+     * @returns {{tx: number, rx: number, txb: number, rxb: number, last: number}}
+     */
+    getMetric(): {
+        tx: number;
+        rx: number;
+        txb: number;
+        rxb: number;
+        last: number;
+    };
+    /**
+     * Gets the current connection state.
+     * @returns {number}
+     */
+    getState(): number;
+    /**
+     * Gets the current connection state name.
+     * @returns {string}
+     */
+    getStateName(): string;
+    /**
+     * Gets security-related information.
+     * @returns {{useAuth: boolean, isTLS: boolean, isAuthorized: boolean, encMode: number, usingEncryption: boolean}}
+     */
+    getSecurity(): {
+        useAuth: boolean;
+        isTLS: boolean;
+        isAuthorized: boolean;
+        encMode: number;
+        usingEncryption: boolean;
+    };
+    /**
+     * Changes the connection state and emits events.
+     * @param {string} state - The new state name (e.g., 'ready', 'closed').
+     * @param {string} [emitEventAndMessage] - Optional message to emit with the state change event.
+     */
+    stateChange(state: string, emitEventAndMessage?: string): void;
+}
+export type MBP = import("meta-buffer-pack").MBP;
+export type IOMsg = import("../common/constants.js").IOMsg;
+export type PAYLOAD_TYPE = import("../common/constants.js").PAYLOAD_TYPE;
+export type SIZE_LIMIT = import("../common/constants.js").SIZE_LIMIT;
+export type ENC_MODE = import("../common/constants.js").ENC_MODE;
+export type STATES = import("../common/constants.js").STATES;
+export type quotaTable = any;
+export type Boho = import("boho").Boho;
+export type Buffer = import("boho").Buffer;
+import EventEmitter from "eventemitter3";

package/dist/types/client/browser/IOWebSocket.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Browser WebSocket client extending IOCore.
+ * @augments {IOCore}
+ */
+export default class IO extends IOCore {
+    /**
+     * The version of the client.
+     * @type {string}
+     */
+    static version: string;
+    /**
+     * The binary type for WebSocket messages.
+     * @type {string}
+     */
+    static binaryType: string;
+    /**
+     * The Boho library instance.
+     * @type {Boho}
+     */
+    static Boho: Boho;
+    /**
+     * The MBP (MessagePack-Boho) instance.
+     * @type {MBP}
+     */
+    static MBP: MBP;
+    /**
+     * The Buffer class from Boho.
+     * @type {Buffer}
+     */
+    static Buffer: Buffer;
+    /**
+     * Constants used by the client.
+     * @type {object}
+     */
+    static constants: object;
+    /**
+     * Tracks the number of IO instances created.
+     * @type {number}
+     */
+    static instanceCount: number;
+    /**
+     * Tracks the number of WebSocket objects created.
+     * @type {number}
+     */
+    static webSocketCount: number;
+    boundBrowserVisiblePing: any;
+    /**
+     * Pings the server when the browser tab becomes visible.
+     */
+    browserVisiblePing(): void;
+    /**
+     * Creates a new WebSocket connection.
+     * @param {string} url - The WebSocket URL to connect to.
+     */
+    createConnection(url: string): void;
+    /**
+     * Handles incoming WebSocket messages (arraybuffer type).
+     * @param {MessageEvent} event - The WebSocket message event.
+     */
+    onWebSocketMessage(event: MessageEvent): void;
+    /**
+     * Handles incoming WebSocket messages (blob type).
+     * @param {MessageEvent} event - The WebSocket message event.
+     */
+    onWebSocketMessageBlob(event: MessageEvent): Promise<void>;
+    /**
+     * Sends data over the WebSocket.
+     * @param {BufferSource} data - The data to send.
+     */
+    socket_send(data: BufferSource): void;
+}
+export type Boho = import("boho").Boho;
+export type MBP = any;
+export type Buffer = import("boho").Buffer;
+import { IOCore } from "../IOCore.js";

package/dist/types/common/constants.d.ts

@@ -0,0 +1,169 @@
+export type STATES = {
+    OPENING: number;
+    OPEN: number;
+    CLOSING: number;
+    CLOSED: number;
+    SERVER_READY: number;
+    AUTH_FAIL: number;
+    AUTH_READY: number;
+    READY: number;
+    REDIRECTING: number;
+};
+export namespace STATES {
+    let OPENING: number;
+    let OPEN: number;
+    let CLOSING: number;
+    let CLOSED: number;
+    let SERVER_READY: number;
+    let AUTH_FAIL: number;
+    let AUTH_READY: number;
+    let READY: number;
+    let REDIRECTING: number;
+}
+export type CLIENT_STATE = {
+    INIT: number;
+    SENT_SERVER_READY: number;
+    RECV_AUTH_REQ: number;
+    SENT_SERVER_NONCE: number;
+    RECV_AUTH_HMAC: number;
+    AUTH_FAIL: number;
+    AUTH_READY: number;
+    CID_READY: number;
+};
+export namespace CLIENT_STATE {
+    export let INIT: number;
+    export let SENT_SERVER_READY: number;
+    export let RECV_AUTH_REQ: number;
+    export let SENT_SERVER_NONCE: number;
+    export let RECV_AUTH_HMAC: number;
+    let AUTH_FAIL_1: number;
+    export { AUTH_FAIL_1 as AUTH_FAIL };
+    let AUTH_READY_1: number;
+    export { AUTH_READY_1 as AUTH_READY };
+    export let CID_READY: number;
+}
+export type ENC_MODE = {
+    NO: number;
+    YES: number;
+    AUTO: number;
+};
+export namespace ENC_MODE {
+    let NO: number;
+    let YES: number;
+    let AUTO: number;
+}
+export type SIZE_LIMIT = {
+    TAG_LEN1: number;
+    TAG_LEN2: number;
+    CONNECTION_CHECKER_PERIOD: number;
+    PROMISE_TIMEOUT: number;
+    DID: number;
+    CID: number;
+};
+export namespace SIZE_LIMIT {
+    let TAG_LEN1: number;
+    let TAG_LEN2: number;
+    let CONNECTION_CHECKER_PERIOD: number;
+    let PROMISE_TIMEOUT: number;
+    let DID: number;
+    let CID: number;
+}
+export type PAYLOAD_TYPE = {
+    EMPTY: number;
+    TEXT: number;
+    BINARY: number;
+    OBJECT: number;
+    MJSON: number;
+    MBA: number;
+};
+export namespace PAYLOAD_TYPE {
+    let EMPTY: number;
+    let TEXT: number;
+    let BINARY: number;
+    let OBJECT: number;
+    let MJSON: number;
+    let MBA: number;
+}
+export type IOMsg = {
+    SERVER_READY: number;
+    CID_REQ: number;
+    CID_RES: number;
+    QUOTA_LEVEL: number;
+    SERVER_CLEAR_AUTH: number;
+    SERVER_REDIRECT: number;
+    LOOP: number;
+    ECHO: number;
+    PING: number;
+    PONG: number;
+    CLOSE: number;
+    SIGNAL: number;
+    SIGNAL_REQ: number;
+    SIGNAL_E2E: number;
+    SUBSCRIBE: number;
+    SUBSCRIBE_REQ: number;
+    UNSUBSCRIBE: number;
+    SERVER_SIGNAL: number;
+    IAM: number;
+    IAM_RES: number;
+    SET: number;
+    RESPONSE_CODE: number;
+    RESPONSE_MBP: number;
+    REQUEST: number;
+    RESPONSE: number;
+    FLOW_MODE: number;
+    WAIT: number;
+    RESUME: number;
+    TIME_OUT: number;
+    OVER_SIZE: number;
+    OVER_FLOW: number;
+};
+export namespace IOMsg {
+    let SERVER_READY_1: number;
+    export { SERVER_READY_1 as SERVER_READY };
+    export let CID_REQ: number;
+    export let CID_RES: number;
+    export let QUOTA_LEVEL: number;
+    export let SERVER_CLEAR_AUTH: number;
+    export let SERVER_REDIRECT: number;
+    export let LOOP: number;
+    export let ECHO: number;
+    export let PING: number;
+    export let PONG: number;
+    export let CLOSE: number;
+    export let SIGNAL: number;
+    export let SIGNAL_REQ: number;
+    export let SIGNAL_E2E: number;
+    export let SUBSCRIBE: number;
+    export let SUBSCRIBE_REQ: number;
+    export let UNSUBSCRIBE: number;
+    export let SERVER_SIGNAL: number;
+    export let IAM: number;
+    export let IAM_RES: number;
+    export let SET: number;
+    export let RESPONSE_CODE: number;
+    export let RESPONSE_MBP: number;
+    export let REQUEST: number;
+    export let RESPONSE: number;
+    export let FLOW_MODE: number;
+    export let WAIT: number;
+    export let RESUME: number;
+    export let TIME_OUT: number;
+    export let OVER_SIZE: number;
+    export let OVER_FLOW: number;
+}
+export type API_TYPE = {
+    REQUEST_RESPONSE: string;
+    ONE_WAY: string;
+};
+export namespace API_TYPE {
+    let REQUEST_RESPONSE: string;
+    let ONE_WAY: string;
+}
+export type STATUS = {
+    OK: number;
+    ERROR: number;
+};
+export namespace STATUS {
+    let OK: number;
+    let ERROR: number;
+}

package/dist/types/common/payload.d.ts

@@ -0,0 +1,6 @@
+export function getSignalPack(tag: any, ...args: any[]): Buffer<ArrayBufferLike>;
+export function parsePayload(args: any): {
+    type: number;
+    buffer: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
+};
+export function getPayloadFromSignalPack(signalPack: any): any;

package/dist/types/common/quotaTable.d.ts

@@ -0,0 +1,47 @@
+export let quotaTable: {
+    0: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    1: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    2: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    3: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    10: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    11: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    12: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    200: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+    255: {
+        signalSize: number;
+        publishCounter: number;
+        trafficRate: number;
+    };
+};