phonic 0.30.2 → 0.30.3

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

@@ -1,21 +0,0 @@
-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

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

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

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

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

@@ -1,147 +0,0 @@
-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, string>;
-        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

@@ -1,423 +0,0 @@
-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);
-    }
-}

package/dist/esm/environments.d.mts

@@ -1,14 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-export interface PhonicEnvironmentUrls {
-    base: string;
-    production: string;
-}
-export declare const PhonicEnvironment: {
-    readonly Default: {
-        readonly base: "https://api.phonic.co/v1";
-        readonly production: "wss://api.phonic.co";
-    };
-};
-export type PhonicEnvironment = typeof PhonicEnvironment.Default;

package/dist/esm/environments.mjs

@@ -1,9 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-export const PhonicEnvironment = {
-    Default: {
-        base: "https://api.phonic.co/v1",
-        production: "wss://api.phonic.co",
-    },
-};

package/dist/esm/errors/PhonicError.d.mts

@@ -1,15 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-import * as core from "../core/index.mjs";
-export declare class PhonicError extends Error {
-    readonly statusCode?: number;
-    readonly body?: unknown;
-    readonly rawResponse?: core.RawResponse;
-    constructor({ message, statusCode, body, rawResponse, }: {
-        message?: string;
-        statusCode?: number;
-        body?: unknown;
-        rawResponse?: core.RawResponse;
-    });
-}

package/dist/esm/errors/PhonicError.mjs

@@ -1,26 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-import { toJson } from "../core/json.mjs";
-export class PhonicError extends Error {
-    constructor({ message, statusCode, body, rawResponse, }) {
-        super(buildMessage({ message, statusCode, body }));
-        Object.setPrototypeOf(this, PhonicError.prototype);
-        this.statusCode = statusCode;
-        this.body = body;
-        this.rawResponse = rawResponse;
-    }
-}
-function buildMessage({ message, statusCode, body, }) {
-    let lines = [];
-    if (message != null) {
-        lines.push(message);
-    }
-    if (statusCode != null) {
-        lines.push(`Status code: ${statusCode.toString()}`);
-    }
-    if (body != null) {
-        lines.push(`Body: ${toJson(body, undefined, 2)}`);
-    }
-    return lines.join("\n");
-}

package/dist/esm/errors/PhonicTimeoutError.d.mts

@@ -1,6 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-export declare class PhonicTimeoutError extends Error {
-    constructor(message: string);
-}

package/dist/esm/errors/PhonicTimeoutError.mjs

@@ -1,9 +0,0 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-export class PhonicTimeoutError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, PhonicTimeoutError.prototype);
-    }
-}

package/dist/esm/errors/index.d.mts

@@ -1,2 +0,0 @@
-export { PhonicError } from "./PhonicError.mjs";
-export { PhonicTimeoutError } from "./PhonicTimeoutError.mjs";

package/dist/esm/errors/index.mjs

@@ -1,2 +0,0 @@
-export { PhonicError } from "./PhonicError.mjs";
-export { PhonicTimeoutError } from "./PhonicTimeoutError.mjs";