phonic 0.30.5 → 0.30.6

package/dist/esm/core/url/qs.mjs

@@ -0,0 +1,61 @@
+const defaultQsOptions = {
+    arrayFormat: "indices",
+    encode: true,
+};
+function encodeValue(value, shouldEncode) {
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "";
+    }
+    const stringValue = String(value);
+    return shouldEncode ? encodeURIComponent(stringValue) : stringValue;
+}
+function stringifyObject(obj, prefix = "", options) {
+    const parts = [];
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}[${key}]` : key;
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                continue;
+            }
+            for (let i = 0; i < value.length; i++) {
+                const item = value[i];
+                if (item === undefined) {
+                    continue;
+                }
+                if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                    parts.push(...stringifyObject(item, arrayKey, options));
+                }
+                else {
+                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                    const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
+                    parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+                }
+            }
+        }
+        else if (typeof value === "object" && value !== null) {
+            if (Object.keys(value).length === 0) {
+                continue;
+            }
+            parts.push(...stringifyObject(value, fullKey, options));
+        }
+        else {
+            const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+            parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`);
+        }
+    }
+    return parts;
+}
+export function toQueryString(obj, options) {
+    if (obj == null || typeof obj !== "object") {
+        return "";
+    }
+    const parts = stringifyObject(obj, "", Object.assign(Object.assign({}, defaultQsOptions), options));
+    return parts.join("&");
+}

package/dist/esm/core/websocket/events.d.mts

@@ -0,0 +1,36 @@
+export declare class Event {
+    target: any;
+    type: string;
+    constructor(type: string, target: any);
+}
+export declare class ErrorEvent extends Event {
+    message: string;
+    error: Error;
+    constructor(error: Error, target: any);
+}
+export declare class CloseEvent extends Event {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+    constructor(code: number | undefined, reason: string | undefined, target: any);
+}
+export interface WebSocketEventMap {
+    close: CloseEvent;
+    error: ErrorEvent;
+    message: MessageEvent;
+    open: Event;
+}
+export interface WebSocketEventListenerMap {
+    close: (event: CloseEvent) => void | {
+        handleEvent: (event: CloseEvent) => void;
+    };
+    error: (event: ErrorEvent) => void | {
+        handleEvent: (event: ErrorEvent) => void;
+    };
+    message: (event: MessageEvent) => void | {
+        handleEvent: (event: MessageEvent) => void;
+    };
+    open: (event: Event) => void | {
+        handleEvent: (event: Event) => void;
+    };
+}

package/dist/esm/core/websocket/events.mjs

@@ -0,0 +1,21 @@
+export class Event {
+    constructor(type, target) {
+        this.target = target;
+        this.type = type;
+    }
+}
+export class ErrorEvent extends Event {
+    constructor(error, target) {
+        super("error", target);
+        this.message = error.message;
+        this.error = error;
+    }
+}
+export class CloseEvent extends Event {
+    constructor(code = 1000, reason = "", target) {
+        super("close", target);
+        this.wasClean = true;
+        this.code = code;
+        this.reason = reason;
+    }
+}

package/dist/esm/core/websocket/index.d.mts

@@ -0,0 +1 @@
+export * from "./ws.mjs";

package/dist/esm/core/websocket/index.mjs

@@ -0,0 +1 @@
+export * from "./ws.mjs";

package/dist/esm/core/websocket/ws.d.mts

@@ -0,0 +1,147 @@
+import * as Events from "./events.mjs";
+export type Event = Events.Event;
+export type ErrorEvent = Events.ErrorEvent;
+export type CloseEvent = Events.CloseEvent;
+export declare namespace ReconnectingWebSocket {
+    interface Args {
+        url: string;
+        protocols?: string | string[];
+        options?: ReconnectingWebSocket.Options;
+        headers?: Record<string, any>;
+        queryParameters?: Record<string, string | string[] | object | object[] | null | undefined>;
+    }
+    type Options = {
+        WebSocket?: any;
+        maxReconnectionDelay?: number;
+        minReconnectionDelay?: number;
+        reconnectionDelayGrowFactor?: number;
+        minUptime?: number;
+        connectionTimeout?: number;
+        maxRetries?: number;
+        maxEnqueuedMessages?: number;
+        startClosed?: boolean;
+        debug?: boolean;
+    };
+    type UrlProvider = string | (() => string) | (() => Promise<string>);
+    type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+    type ListenersMap = {
+        error: Array<Events.WebSocketEventListenerMap["error"]>;
+        message: Array<Events.WebSocketEventListenerMap["message"]>;
+        open: Array<Events.WebSocketEventListenerMap["open"]>;
+        close: Array<Events.WebSocketEventListenerMap["close"]>;
+    };
+}
+export declare class ReconnectingWebSocket {
+    private _ws?;
+    private _listeners;
+    private _retryCount;
+    private _uptimeTimeout;
+    private _connectTimeout;
+    private _shouldReconnect;
+    private _connectLock;
+    private _binaryType;
+    private _closeCalled;
+    private _messageQueue;
+    private readonly _url;
+    private readonly _protocols?;
+    private readonly _options;
+    private readonly _headers?;
+    private readonly _queryParameters?;
+    constructor({ url, protocols, options, headers, queryParameters }: ReconnectingWebSocket.Args);
+    static get CONNECTING(): number;
+    static get OPEN(): number;
+    static get CLOSING(): number;
+    static get CLOSED(): number;
+    get CONNECTING(): number;
+    get OPEN(): number;
+    get CLOSING(): number;
+    get CLOSED(): number;
+    get binaryType(): BinaryType;
+    set binaryType(value: BinaryType);
+    /**
+     * Returns the number or connection retries
+     */
+    get retryCount(): number;
+    /**
+     * The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     */
+    get bufferedAmount(): number;
+    /**
+     * The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions(): string;
+    /**
+     * A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object
+     */
+    get protocol(): string;
+    /**
+     * The current state of the connection; this is one of the Ready state constants
+     */
+    get readyState(): number;
+    /**
+     * The URL as resolved by the constructor
+     */
+    get url(): string;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+     */
+    onclose: ((event: Events.CloseEvent) => void) | null;
+    /**
+     * An event listener to be called when an error occurs
+     */
+    onerror: ((event: Events.ErrorEvent) => void) | null;
+    /**
+     * An event listener to be called when a message is received from the server
+     */
+    onmessage: ((event: MessageEvent) => void) | null;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+     * this indicates that the connection is ready to send and receive data
+     */
+    onopen: ((event: Event) => void) | null;
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */
+    reconnect(code?: number, reason?: string): void;
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */
+    send(data: ReconnectingWebSocket.Message): void;
+    /**
+     * Register an event handler of a specific event type
+     */
+    addEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Removes an event listener
+     */
+    removeEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    private _debug;
+    private _getNextDelay;
+    private _wait;
+    private _getNextUrl;
+    private _connect;
+    private _handleTimeout;
+    private _disconnect;
+    private _acceptOpen;
+    private _callEventListener;
+    private _handleOpen;
+    private _handleMessage;
+    private _handleError;
+    private _handleClose;
+    private _removeListeners;
+    private _addListeners;
+    private _clearTimeouts;
+}

package/dist/esm/core/websocket/ws.mjs

@@ -0,0 +1,423 @@
+import { WebSocket as NodeWebSocket } from "ws";
+import { RUNTIME } from "../runtime/index.mjs";
+import { toQueryString } from "../url/qs.mjs";
+import * as Events from "./events.mjs";
+const getGlobalWebSocket = () => {
+    if (RUNTIME.type === "node") {
+        return NodeWebSocket;
+    }
+    else if (typeof WebSocket !== "undefined") {
+        // @ts-ignore
+        return WebSocket;
+    }
+    return undefined;
+};
+/**
+ * Returns true if given argument looks like a WebSocket class
+ */
+const isWebSocket = (w) => typeof w !== "undefined" && !!w && w.CLOSING === 2;
+const DEFAULT_OPTIONS = {
+    maxReconnectionDelay: 10000,
+    minReconnectionDelay: 1000 + Math.random() * 4000,
+    minUptime: 5000,
+    reconnectionDelayGrowFactor: 1.3,
+    connectionTimeout: 4000,
+    maxRetries: Infinity,
+    maxEnqueuedMessages: Infinity,
+    startClosed: false,
+    debug: false,
+};
+export class ReconnectingWebSocket {
+    constructor({ url, protocols, options, headers, queryParameters }) {
+        this._listeners = {
+            error: [],
+            message: [],
+            open: [],
+            close: [],
+        };
+        this._retryCount = -1;
+        this._shouldReconnect = true;
+        this._connectLock = false;
+        this._binaryType = "blob";
+        this._closeCalled = false;
+        this._messageQueue = [];
+        /**
+         * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+         */
+        this.onclose = null;
+        /**
+         * An event listener to be called when an error occurs
+         */
+        this.onerror = null;
+        /**
+         * An event listener to be called when a message is received from the server
+         */
+        this.onmessage = null;
+        /**
+         * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+         * this indicates that the connection is ready to send and receive data
+         */
+        this.onopen = null;
+        this._handleOpen = (event) => {
+            this._debug("open event");
+            const { minUptime = DEFAULT_OPTIONS.minUptime } = this._options;
+            clearTimeout(this._connectTimeout);
+            this._uptimeTimeout = setTimeout(() => this._acceptOpen(), minUptime);
+            this._ws.binaryType = this._binaryType;
+            // send enqueued messages (messages sent before websocket open event)
+            this._messageQueue.forEach((message) => { var _a; return (_a = this._ws) === null || _a === void 0 ? void 0 : _a.send(message); });
+            this._messageQueue = [];
+            if (this.onopen) {
+                this.onopen(event);
+            }
+            this._listeners.open.forEach((listener) => this._callEventListener(event, listener));
+        };
+        this._handleMessage = (event) => {
+            this._debug("message event");
+            if (this.onmessage) {
+                this.onmessage(event);
+            }
+            this._listeners.message.forEach((listener) => this._callEventListener(event, listener));
+        };
+        this._handleError = (event) => {
+            this._debug("error event", event.message);
+            this._disconnect(undefined, event.message === "TIMEOUT" ? "timeout" : undefined);
+            if (this.onerror) {
+                this.onerror(event);
+            }
+            this._debug("exec error listeners");
+            this._listeners.error.forEach((listener) => this._callEventListener(event, listener));
+            this._connect();
+        };
+        this._handleClose = (event) => {
+            this._debug("close event");
+            this._clearTimeouts();
+            if (event.code === 1000) {
+                this._shouldReconnect = false;
+            }
+            if (this._shouldReconnect) {
+                this._connect();
+            }
+            if (this.onclose) {
+                this.onclose(event);
+            }
+            this._listeners.close.forEach((listener) => this._callEventListener(event, listener));
+        };
+        this._url = url;
+        this._protocols = protocols;
+        this._options = options !== null && options !== void 0 ? options : DEFAULT_OPTIONS;
+        this._headers = headers;
+        this._queryParameters = queryParameters;
+        if (this._options.startClosed) {
+            this._shouldReconnect = false;
+        }
+        this._connect();
+    }
+    static get CONNECTING() {
+        return 0;
+    }
+    static get OPEN() {
+        return 1;
+    }
+    static get CLOSING() {
+        return 2;
+    }
+    static get CLOSED() {
+        return 3;
+    }
+    get CONNECTING() {
+        return ReconnectingWebSocket.CONNECTING;
+    }
+    get OPEN() {
+        return ReconnectingWebSocket.OPEN;
+    }
+    get CLOSING() {
+        return ReconnectingWebSocket.CLOSING;
+    }
+    get CLOSED() {
+        return ReconnectingWebSocket.CLOSED;
+    }
+    get binaryType() {
+        return this._ws ? this._ws.binaryType : this._binaryType;
+    }
+    set binaryType(value) {
+        this._binaryType = value;
+        if (this._ws) {
+            this._ws.binaryType = value;
+        }
+    }
+    /**
+     * Returns the number or connection retries
+     */
+    get retryCount() {
+        return Math.max(this._retryCount, 0);
+    }
+    /**
+     * The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     */
+    get bufferedAmount() {
+        const bytes = this._messageQueue.reduce((acc, message) => {
+            if (typeof message === "string") {
+                acc += message.length; // not byte size
+            }
+            else if (message instanceof Blob) {
+                acc += message.size;
+            }
+            else {
+                acc += message.byteLength;
+            }
+            return acc;
+        }, 0);
+        return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+    }
+    /**
+     * The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions() {
+        return this._ws ? this._ws.extensions : "";
+    }
+    /**
+     * A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object
+     */
+    get protocol() {
+        return this._ws ? this._ws.protocol : "";
+    }
+    /**
+     * The current state of the connection; this is one of the Ready state constants
+     */
+    get readyState() {
+        if (this._ws) {
+            return this._ws.readyState;
+        }
+        return this._options.startClosed ? ReconnectingWebSocket.CLOSED : ReconnectingWebSocket.CONNECTING;
+    }
+    /**
+     * The URL as resolved by the constructor
+     */
+    get url() {
+        return this._ws ? this._ws.url : "";
+    }
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */
+    close(code = 1000, reason) {
+        this._closeCalled = true;
+        this._shouldReconnect = false;
+        this._clearTimeouts();
+        if (!this._ws) {
+            this._debug("close enqueued: no ws instance");
+            return;
+        }
+        if (this._ws.readyState === this.CLOSED) {
+            this._debug("close: already closed");
+            return;
+        }
+        this._ws.close(code, reason);
+    }
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */
+    reconnect(code, reason) {
+        this._shouldReconnect = true;
+        this._closeCalled = false;
+        this._retryCount = -1;
+        if (!this._ws || this._ws.readyState === this.CLOSED) {
+            this._connect();
+        }
+        else {
+            this._disconnect(code, reason);
+            this._connect();
+        }
+    }
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */
+    send(data) {
+        if (this._ws && this._ws.readyState === this.OPEN) {
+            this._debug("send", data);
+            this._ws.send(data);
+        }
+        else {
+            const { maxEnqueuedMessages = DEFAULT_OPTIONS.maxEnqueuedMessages } = this._options;
+            if (this._messageQueue.length < maxEnqueuedMessages) {
+                this._debug("enqueue", data);
+                this._messageQueue.push(data);
+            }
+        }
+    }
+    /**
+     * Register an event handler of a specific event type
+     */
+    addEventListener(type, listener) {
+        if (this._listeners[type]) {
+            // @ts-ignore
+            this._listeners[type].push(listener);
+        }
+    }
+    dispatchEvent(event) {
+        const listeners = this._listeners[event.type];
+        if (listeners) {
+            for (const listener of listeners) {
+                this._callEventListener(event, listener);
+            }
+        }
+        return true;
+    }
+    /**
+     * Removes an event listener
+     */
+    removeEventListener(type, listener) {
+        if (this._listeners[type]) {
+            // @ts-ignore
+            this._listeners[type] = this._listeners[type].filter(
+            // @ts-ignore
+            (l) => l !== listener);
+        }
+    }
+    _debug(...args) {
+        if (this._options.debug) {
+            // not using spread because compiled version uses Symbols
+            // tslint:disable-next-line
+            // biome-ignore lint/suspicious/noConsole: allow console
+            console.log.apply(console, ["RWS>", ...args]);
+        }
+    }
+    _getNextDelay() {
+        const { reconnectionDelayGrowFactor = DEFAULT_OPTIONS.reconnectionDelayGrowFactor, minReconnectionDelay = DEFAULT_OPTIONS.minReconnectionDelay, maxReconnectionDelay = DEFAULT_OPTIONS.maxReconnectionDelay, } = this._options;
+        let delay = 0;
+        if (this._retryCount > 0) {
+            delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+            if (delay > maxReconnectionDelay) {
+                delay = maxReconnectionDelay;
+            }
+        }
+        this._debug("next delay", delay);
+        return delay;
+    }
+    _wait() {
+        return new Promise((resolve) => {
+            setTimeout(resolve, this._getNextDelay());
+        });
+    }
+    _getNextUrl(urlProvider) {
+        if (typeof urlProvider === "string") {
+            return Promise.resolve(urlProvider);
+        }
+        if (typeof urlProvider === "function") {
+            const url = urlProvider();
+            if (typeof url === "string") {
+                return Promise.resolve(url);
+            }
+            // @ts-ignore redundant check
+            if (url.then) {
+                return url;
+            }
+        }
+        throw Error("Invalid URL");
+    }
+    _connect() {
+        if (this._connectLock || !this._shouldReconnect) {
+            return;
+        }
+        this._connectLock = true;
+        const { maxRetries = DEFAULT_OPTIONS.maxRetries, connectionTimeout = DEFAULT_OPTIONS.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
+        if (this._retryCount >= maxRetries) {
+            this._debug("max retries reached", this._retryCount, ">=", maxRetries);
+            return;
+        }
+        this._retryCount++;
+        this._debug("connect", this._retryCount);
+        this._removeListeners();
+        if (!isWebSocket(WebSocket)) {
+            throw Error("No valid WebSocket class provided");
+        }
+        this._wait()
+            .then(() => this._getNextUrl(this._url))
+            .then((url) => {
+            if (this._closeCalled) {
+                return;
+            }
+            const options = {};
+            if (this._headers) {
+                options.headers = this._headers;
+            }
+            if (this._queryParameters && Object.keys(this._queryParameters).length > 0) {
+                const queryString = toQueryString(this._queryParameters, { arrayFormat: "repeat" });
+                if (queryString) {
+                    url = `${url}?${queryString}`;
+                }
+            }
+            this._ws = new WebSocket(url, this._protocols, options);
+            this._ws.binaryType = this._binaryType;
+            this._connectLock = false;
+            this._addListeners();
+            this._connectTimeout = setTimeout(() => this._handleTimeout(), connectionTimeout);
+        });
+    }
+    _handleTimeout() {
+        this._debug("timeout event");
+        this._handleError(new Events.ErrorEvent(Error("TIMEOUT"), this));
+    }
+    _disconnect(code = 1000, reason) {
+        this._clearTimeouts();
+        if (!this._ws) {
+            return;
+        }
+        this._removeListeners();
+        try {
+            this._ws.close(code, reason);
+            this._handleClose(new Events.CloseEvent(code, reason, this));
+        }
+        catch (error) {
+            // ignore
+        }
+    }
+    _acceptOpen() {
+        this._debug("accept open");
+        this._retryCount = 0;
+    }
+    _callEventListener(event, listener) {
+        if ("handleEvent" in listener) {
+            // @ts-ignore
+            listener.handleEvent(event);
+        }
+        else {
+            // @ts-ignore
+            listener(event);
+        }
+    }
+    _removeListeners() {
+        if (!this._ws) {
+            return;
+        }
+        this._debug("removeListeners");
+        this._ws.removeEventListener("open", this._handleOpen);
+        this._ws.removeEventListener("close", this._handleClose);
+        this._ws.removeEventListener("message", this._handleMessage);
+        // @ts-ignore
+        this._ws.removeEventListener("error", this._handleError);
+    }
+    _addListeners() {
+        if (!this._ws) {
+            return;
+        }
+        this._debug("addListeners");
+        this._ws.addEventListener("open", this._handleOpen);
+        this._ws.addEventListener("close", this._handleClose);
+        this._ws.addEventListener("message", this._handleMessage);
+        // @ts-ignore
+        this._ws.addEventListener("error", this._handleError);
+    }
+    _clearTimeouts() {
+        clearTimeout(this._connectTimeout);
+        clearTimeout(this._uptimeTimeout);
+    }
+}