@corti/sdk 0.0.0-alpha.10

package/dist/cjs/core/utils/setObjectProperty.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setObjectProperty = setObjectProperty;
+/**
+ * Sets the value at path of object. If a portion of path doesn’t exist it’s created. This is
+ * inspired by Lodash's set function, but is simplified to accommodate our use case.
+ * For more details, see https://lodash.com/docs/4.17.15#set.
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @return Returns object.
+ */
+function setObjectProperty(object, path, value) {
+    if (object == null) {
+        return object;
+    }
+    const keys = path.split(".");
+    if (keys.length === 0) {
+        // Invalid path; do nothing.
+        return object;
+    }
+    let current = object;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (key == null) {
+            // Unreachable.
+            continue;
+        }
+        if (!current[key] || typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey == null) {
+        // Unreachable.
+        return object;
+    }
+    current[lastKey] = value;
+    return object;
+}

package/dist/cjs/core/websocket/events.d.ts

@@ -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/cjs/core/websocket/events.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloseEvent = exports.ErrorEvent = exports.Event = void 0;
+class Event {
+    constructor(type, target) {
+        this.target = target;
+        this.type = type;
+    }
+}
+exports.Event = Event;
+class ErrorEvent extends Event {
+    constructor(error, target) {
+        super("error", target);
+        this.message = error.message;
+        this.error = error;
+    }
+}
+exports.ErrorEvent = ErrorEvent;
+class CloseEvent extends Event {
+    constructor(code = 1000, reason = "", target) {
+        super("close", target);
+        this.wasClean = true;
+        this.code = code;
+        this.reason = reason;
+    }
+}
+exports.CloseEvent = CloseEvent;

package/dist/cjs/core/websocket/index.d.ts

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

package/dist/cjs/core/websocket/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ws.js"), exports);

package/dist/cjs/core/websocket/ws.d.ts

@@ -0,0 +1,137 @@
+import * as Events from "./events.js";
+export type Event = Events.Event;
+export type ErrorEvent = Events.ErrorEvent;
+export type CloseEvent = Events.CloseEvent;
+export type Options = {
+    WebSocket?: any;
+    maxReconnectionDelay?: number;
+    minReconnectionDelay?: number;
+    reconnectionDelayGrowFactor?: number;
+    minUptime?: number;
+    connectionTimeout?: number;
+    maxRetries?: number;
+    maxEnqueuedMessages?: number;
+    startClosed?: boolean;
+    debug?: boolean;
+};
+export type UrlProvider = string | (() => string) | (() => Promise<string>);
+export type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+export 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?;
+    constructor(url: UrlProvider, protocols?: string | string[], options?: Options, headers?: Record<string, any>);
+    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: 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;
+}