oorja 1.5.0 → 1.6.2

package/lib/lib/surya/vendor/phoenix/socket.js

@@ -0,0 +1,544 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const ajax_1 = require("./ajax");
+const channel_1 = require("./channel");
+const longpoll_1 = require("./longpoll");
+const serializer_1 = require("./serializer");
+const timer_1 = require("./timer");
+const ws_1 = require("ws");
+/** Initializes the Socket *
+ *
+ * For IE8 support use an ES5-shim (https://github.com/es-shims/es5-shim)
+ *
+ * @param {string} endPoint - The string WebSocket endpoint, ie, `"ws://example.com/socket"`,
+ *                                               `"wss://example.com"`
+ *                                               `"/socket"` (inherited host & protocol)
+ * @param {Object} [opts] - Optional configuration
+ * @param {Function} [opts.transport] - The Websocket Transport, for example WebSocket or Phoenix.LongPoll.
+ *
+ * Defaults to WebSocket with automatic LongPoll fallback.
+ * @param {Function} [opts.encode] - The function to encode outgoing messages.
+ *
+ * Defaults to JSON encoder.
+ *
+ * @param {Function} [opts.decode] - The function to decode incoming messages.
+ *
+ * Defaults to JSON:
+ *
+ * ```javascript
+ * (payload, callback) => callback(JSON.parse(payload))
+ * ```
+ *
+ * @param {number} [opts.timeout] - The default timeout in milliseconds to trigger push timeouts.
+ *
+ * Defaults `DEFAULT_TIMEOUT`
+ * @param {number} [opts.heartbeatIntervalMs] - The millisec interval to send a heartbeat message
+ * @param {number} [opts.reconnectAfterMs] - The optional function that returns the millisec
+ * socket reconnect interval.
+ *
+ * Defaults to stepped backoff of:
+ *
+ * ```javascript
+ * function(tries){
+ *   return [10, 50, 100, 150, 200, 250, 500, 1000, 2000][tries - 1] || 5000
+ * }
+ * ````
+ *
+ * @param {number} [opts.rejoinAfterMs] - The optional function that returns the millisec
+ * rejoin interval for individual channels.
+ *
+ * ```javascript
+ * function(tries){
+ *   return [1000, 2000, 5000][tries - 1] || 10000
+ * }
+ * ````
+ *
+ * @param {Function} [opts.logger] - The optional function for specialized logging, ie:
+ *
+ * ```javascript
+ * function(kind, msg, data) {
+ *   console.log(`${kind}: ${msg}`, data)
+ * }
+ * ```
+ *
+ * @param {number} [opts.longpollerTimeout] - The maximum timeout of a long poll AJAX request.
+ *
+ * Defaults to 20s (double the server long poll timer).
+ *
+ * @param {(Object|function)} [opts.params] - The optional params to pass when connecting
+ * @param {string} [opts.binaryType] - The binary type to use for binary WebSocket frames.
+ *
+ * Defaults to "arraybuffer"
+ *
+ * @param {vsn} [opts.vsn] - The serializer's protocol version to send on connect.
+ *
+ * Defaults to DEFAULT_VSN.
+*/
+class Socket {
+    constructor(endPoint, opts = {}) {
+        this.stateChangeCallbacks = { open: [], close: [], error: [], message: [] };
+        this.channels = [];
+        this.sendBuffer = [];
+        this.ref = 0;
+        this.timeout = opts.timeout || constants_1.DEFAULT_TIMEOUT;
+        this.transport = ws_1.WebSocket;
+        this.establishedConnections = 0;
+        this.defaultEncoder = serializer_1.default.encode.bind(serializer_1.default);
+        this.defaultDecoder = serializer_1.default.decode.bind(serializer_1.default);
+        this.closeWasClean = false;
+        this.binaryType = opts.binaryType || "arraybuffer";
+        this.connectClock = 1;
+        if (this.transport !== longpoll_1.default) {
+            this.encode = opts.encode || this.defaultEncoder;
+            this.decode = opts.decode || this.defaultDecoder;
+        }
+        else {
+            this.encode = this.defaultEncoder;
+            this.decode = this.defaultDecoder;
+        }
+        let awaitingConnectionOnPageShow = null;
+        if (constants_1.phxWindow && constants_1.phxWindow.addEventListener) {
+            constants_1.phxWindow.addEventListener("pagehide", _e => {
+                if (this.conn) {
+                    this.disconnect();
+                    awaitingConnectionOnPageShow = this.connectClock;
+                }
+            });
+            constants_1.phxWindow.addEventListener("pageshow", _e => {
+                if (awaitingConnectionOnPageShow === this.connectClock) {
+                    awaitingConnectionOnPageShow = null;
+                    this.connect();
+                }
+            });
+        }
+        this.heartbeatIntervalMs = opts.heartbeatIntervalMs || 30000;
+        this.rejoinAfterMs = (tries) => {
+            if (opts.rejoinAfterMs) {
+                return opts.rejoinAfterMs(tries);
+            }
+            else {
+                return [1000, 2000, 5000][tries - 1] || 10000;
+            }
+        };
+        this.reconnectAfterMs = (tries) => {
+            if (opts.reconnectAfterMs) {
+                return opts.reconnectAfterMs(tries);
+            }
+            else {
+                return [10, 50, 100, 150, 200, 250, 500, 1000, 2000][tries - 1] || 5000;
+            }
+        };
+        this.logger = opts.logger || null;
+        this.longpollerTimeout = opts.longpollerTimeout || 20000;
+        this.params = (0, utils_1.closure)(opts.params || {});
+        this.endPoint = `${endPoint}/${constants_1.TRANSPORTS.websocket}`;
+        this.vsn = opts.vsn || constants_1.DEFAULT_VSN;
+        this.heartbeatTimeoutTimer = null;
+        this.heartbeatTimer = null;
+        this.pendingHeartbeatRef = null;
+        this.reconnectTimer = new timer_1.default(() => {
+            this.teardown(() => this.connect());
+        }, this.reconnectAfterMs);
+    }
+    /**
+     * Returns the LongPoll transport reference
+     */
+    getLongPollTransport() { return longpoll_1.default; }
+    /**
+     * Disconnects and replaces the active transport
+     *
+     * @param {Function} newTransport - The new transport class to instantiate
+     *
+     */
+    replaceTransport(newTransport) {
+        this.connectClock++;
+        this.closeWasClean = true;
+        this.reconnectTimer.reset();
+        this.sendBuffer = [];
+        if (this.conn) {
+            this.conn.close();
+            this.conn = null;
+        }
+        this.transport = newTransport;
+    }
+    /**
+     * Returns the socket protocol
+     *
+     * @returns {string}
+     */
+    protocol() { return location.protocol.match(/^https/) ? "wss" : "ws"; }
+    /**
+     * The fully qualified socket url
+     *
+     * @returns {string}
+     */
+    endPointURL() {
+        let uri = ajax_1.default.appendParams(ajax_1.default.appendParams(this.endPoint, this.params()), { vsn: this.vsn });
+        if (uri.charAt(0) !== "/") {
+            return uri;
+        }
+        if (uri.charAt(1) === "/") {
+            return `${this.protocol()}:${uri}`;
+        }
+        return `${this.protocol()}://${location.host}${uri}`;
+    }
+    /**
+     * Disconnects the socket
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes.
+     *
+     * @param {Function} callback - Optional callback which is called after socket is disconnected.
+     * @param {integer} code - A status code for disconnection (Optional).
+     * @param {string} reason - A textual description of the reason to disconnect. (Optional)
+     */
+    disconnect(callback, code, reason) {
+        this.connectClock++;
+        this.closeWasClean = true;
+        this.reconnectTimer.reset();
+        this.teardown(callback, code, reason);
+    }
+    /**
+     *
+     * @param {Object} params - The params to send when connecting, for example `{user_id: userToken}`
+     *
+     * Passing params to connect is deprecated; pass them in the Socket constructor instead:
+     * `new Socket("/socket", {params: {user_id: userToken}})`.
+     */
+    connect(params) {
+        if (params) {
+            console && console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor");
+            this.params = (0, utils_1.closure)(params);
+        }
+        if (this.conn) {
+            return;
+        }
+        this.connectClock++;
+        this.closeWasClean = false;
+        this.conn = new ws_1.WebSocket(this.endPointURL());
+        this.conn.binaryType = this.binaryType;
+        this.conn.timeout = this.longpollerTimeout;
+        this.conn.onopen = () => this.onConnOpen();
+        this.conn.onerror = error => this.onConnError(error);
+        this.conn.onmessage = event => this.onConnMessage(event);
+        this.conn.onclose = event => this.onConnClose(event);
+    }
+    /**
+     * Logs the message. Override `this.logger` for specialized logging. noops by default
+     * @param {string} kind
+     * @param {string} msg
+     * @param {Object} data
+     */
+    log(kind, msg, data) { this.logger(kind, msg, data); }
+    /**
+     * Returns true if a logger has been set on this socket.
+     */
+    hasLogger() { return this.logger !== null; }
+    /**
+     * Registers callbacks for connection open events
+     *
+     * @example socket.onOpen(function(){ console.info("the socket was opened") })
+     *
+     * @param {Function} callback
+     */
+    onOpen(callback) {
+        let ref = this.makeRef();
+        this.stateChangeCallbacks.open.push([ref, callback]);
+        return ref;
+    }
+    /**
+     * Registers callbacks for connection close events
+     * @param {Function} callback
+     */
+    onClose(callback) {
+        let ref = this.makeRef();
+        this.stateChangeCallbacks.close.push([ref, callback]);
+        return ref;
+    }
+    /**
+     * Registers callbacks for connection error events
+     *
+     * @example socket.onError(function(error){ alert("An error occurred") })
+     *
+     * @param {Function} callback
+     */
+    onError(callback) {
+        let ref = this.makeRef();
+        this.stateChangeCallbacks.error.push([ref, callback]);
+        return ref;
+    }
+    /**
+     * Registers callbacks for connection message events
+     * @param {Function} callback
+     */
+    onMessage(callback) {
+        let ref = this.makeRef();
+        this.stateChangeCallbacks.message.push([ref, callback]);
+        return ref;
+    }
+    /**
+     * Pings the server and invokes the callback with the RTT in milliseconds
+     * @param {Function} callback
+     *
+     * Returns true if the ping was pushed or false if unable to be pushed.
+     */
+    ping(callback) {
+        if (!this.isConnected()) {
+            return false;
+        }
+        let ref = this.makeRef();
+        let startTime = Date.now();
+        this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref: ref });
+        let onMsgRef = this.onMessage(msg => {
+            if (msg.ref === ref) {
+                this.off([onMsgRef]);
+                callback(Date.now() - startTime);
+            }
+        });
+        return true;
+    }
+    /**
+     * @private
+     */
+    clearHeartbeats() {
+        clearTimeout(this.heartbeatTimer);
+        clearTimeout(this.heartbeatTimeoutTimer);
+    }
+    onConnOpen() {
+        if (this.hasLogger())
+            this.log("transport", `connected to ${this.endPointURL()}`);
+        this.closeWasClean = false;
+        this.establishedConnections++;
+        this.flushSendBuffer();
+        this.reconnectTimer.reset();
+        this.resetHeartbeat();
+        this.stateChangeCallbacks.open.forEach(([, callback]) => callback());
+    }
+    /**
+     * @private
+     */
+    heartbeatTimeout() {
+        if (this.pendingHeartbeatRef) {
+            this.pendingHeartbeatRef = null;
+            if (this.hasLogger()) {
+                this.log("transport", "heartbeat timeout. Attempting to re-establish connection");
+            }
+            this.triggerChanError();
+            this.closeWasClean = false;
+            this.teardown(() => this.reconnectTimer.scheduleTimeout(), constants_1.WS_CLOSE_NORMAL, "heartbeat timeout");
+        }
+    }
+    resetHeartbeat() {
+        if (this.conn && this.conn.skipHeartbeat) {
+            return;
+        }
+        this.pendingHeartbeatRef = null;
+        this.clearHeartbeats();
+        this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+    }
+    teardown(callback, code, reason) {
+        if (!this.conn) {
+            return callback && callback();
+        }
+        this.waitForBufferDone(() => {
+            if (this.conn) {
+                if (code) {
+                    this.conn.close(code, reason || "");
+                }
+                else {
+                    this.conn.close();
+                }
+            }
+            this.waitForSocketClosed(() => {
+                if (this.conn) {
+                    this.conn.onopen = function () { }; // noop
+                    this.conn.onerror = function () { }; // noop
+                    this.conn.onmessage = function () { }; // noop
+                    this.conn.onclose = function () { }; // noop
+                    this.conn = null;
+                }
+                callback && callback();
+            });
+        });
+    }
+    waitForBufferDone(callback, tries = 1) {
+        if (tries === 5 || !this.conn || !this.conn.bufferedAmount) {
+            callback();
+            return;
+        }
+        setTimeout(() => {
+            this.waitForBufferDone(callback, tries + 1);
+        }, 150 * tries);
+    }
+    waitForSocketClosed(callback, tries = 1) {
+        if (tries === 5 || !this.conn || this.conn.readyState === constants_1.SOCKET_STATES.closed) {
+            callback();
+            return;
+        }
+        setTimeout(() => {
+            this.waitForSocketClosed(callback, tries + 1);
+        }, 150 * tries);
+    }
+    onConnClose(event) {
+        let closeCode = event && event.code;
+        if (this.hasLogger())
+            this.log("transport", "close", event);
+        this.triggerChanError();
+        this.clearHeartbeats();
+        if (!this.closeWasClean && closeCode !== 1000) {
+            this.reconnectTimer.scheduleTimeout();
+        }
+        this.stateChangeCallbacks.close.forEach(([, callback]) => callback(event));
+    }
+    /**
+     * @private
+     */
+    onConnError(error) {
+        if (this.hasLogger())
+            this.log("transport", error);
+        let transportBefore = this.transport;
+        let establishedBefore = this.establishedConnections;
+        this.stateChangeCallbacks.error.forEach(([, callback]) => {
+            callback(error, transportBefore, establishedBefore);
+        });
+        if (transportBefore === this.transport || establishedBefore > 0) {
+            this.triggerChanError();
+        }
+    }
+    /**
+     * @private
+     */
+    triggerChanError() {
+        this.channels.forEach(channel => {
+            if (!(channel.isErrored() || channel.isLeaving() || channel.isClosed())) {
+                channel.trigger(constants_1.CHANNEL_EVENTS.error);
+            }
+        });
+    }
+    /**
+     * @returns {string}
+     */
+    connectionState() {
+        switch (this.conn && this.conn.readyState) {
+            case constants_1.SOCKET_STATES.connecting: return "connecting";
+            case constants_1.SOCKET_STATES.open: return "open";
+            case constants_1.SOCKET_STATES.closing: return "closing";
+            default: return "closed";
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isConnected() { return this.connectionState() === "open"; }
+    /**
+     * @private
+     *
+     * @param {Channel}
+     */
+    remove(channel) {
+        this.off(channel.stateChangeRefs);
+        this.channels = this.channels.filter(c => c.joinRef() !== channel.joinRef());
+    }
+    /**
+     * Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations.
+     *
+     * @param {refs} - list of refs returned by calls to
+     *                 `onOpen`, `onClose`, `onError,` and `onMessage`
+     */
+    off(refs) {
+        for (let key in this.stateChangeCallbacks) {
+            this.stateChangeCallbacks[key] = this.stateChangeCallbacks[key].filter(([ref]) => {
+                return refs.indexOf(ref) === -1;
+            });
+        }
+    }
+    /**
+     * Initiates a new channel for the given topic
+     *
+     * @param {string} topic
+     * @param {Object} chanParams - Parameters for the channel
+     * @returns {Channel}
+     */
+    channel(topic, chanParams = {}) {
+        let chan = new channel_1.default(topic, chanParams, this);
+        this.channels.push(chan);
+        return chan;
+    }
+    /**
+     * @param {Object} data
+     */
+    push(data) {
+        if (this.hasLogger()) {
+            let { topic, event, payload, ref, join_ref } = data;
+            this.log("push", `${topic} ${event} (${join_ref}, ${ref})`, payload);
+        }
+        if (this.isConnected()) {
+            this.encode(data, result => this.conn.send(result));
+        }
+        else {
+            this.sendBuffer.push(() => this.encode(data, result => this.conn.send(result)));
+        }
+    }
+    /**
+     * Return the next message ref, accounting for overflows
+     * @returns {string}
+     */
+    makeRef() {
+        let newRef = this.ref + 1;
+        if (newRef === this.ref) {
+            this.ref = 0;
+        }
+        else {
+            this.ref = newRef;
+        }
+        return this.ref.toString();
+    }
+    sendHeartbeat() {
+        if (this.pendingHeartbeatRef && !this.isConnected()) {
+            return;
+        }
+        this.pendingHeartbeatRef = this.makeRef();
+        this.push({ topic: "phoenix", event: "heartbeat", payload: {}, ref: this.pendingHeartbeatRef });
+        this.heartbeatTimeoutTimer = setTimeout(() => this.heartbeatTimeout(), this.heartbeatIntervalMs);
+    }
+    flushSendBuffer() {
+        if (this.isConnected() && this.sendBuffer.length > 0) {
+            this.sendBuffer.forEach(callback => callback());
+            this.sendBuffer = [];
+        }
+    }
+    onConnMessage(rawMessage) {
+        this.decode(rawMessage.data, msg => {
+            let { topic, event, payload, ref, join_ref } = msg;
+            if (ref && ref === this.pendingHeartbeatRef) {
+                this.clearHeartbeats();
+                this.pendingHeartbeatRef = null;
+                this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+            }
+            if (this.hasLogger())
+                this.log("receive", `${payload.status || ""} ${topic} ${event} ${ref && "(" + ref + ")" || ""}`, payload);
+            for (let i = 0; i < this.channels.length; i++) {
+                const channel = this.channels[i];
+                if (!channel.isMember(topic, event, payload, join_ref)) {
+                    continue;
+                }
+                channel.trigger(event, payload, ref, join_ref);
+            }
+            for (let i = 0; i < this.stateChangeCallbacks.message.length; i++) {
+                let [, callback] = this.stateChangeCallbacks.message[i];
+                callback(msg);
+            }
+        });
+    }
+    leaveOpenTopic(topic) {
+        let dupChannel = this.channels.find(c => c.topic === topic && (c.isJoined() || c.isJoining()));
+        if (dupChannel) {
+            if (this.hasLogger())
+                this.log("transport", `leaving duplicate topic "${topic}"`);
+            dupChannel.leave();
+        }
+    }
+}
+exports.default = Socket;

package/lib/lib/surya/vendor/phoenix/timer.d.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ * Creates a timer that accepts a `timerCalc` function to perform
+ * calculated timeout retries, such as exponential backoff.
+ *
+ * @example
+ * let reconnectTimer = new Timer(() => this.connect(), function(tries){
+ *   return [1000, 5000, 10000][tries - 1] || 10000
+ * })
+ * reconnectTimer.scheduleTimeout() // fires after 1000
+ * reconnectTimer.scheduleTimeout() // fires after 5000
+ * reconnectTimer.reset()
+ * reconnectTimer.scheduleTimeout() // fires after 1000
+ *
+ * @param {Function} callback
+ * @param {Function} timerCalc
+ */
+export default class Timer {
+    constructor(callback: any, timerCalc: any);
+    reset(): void;
+    /**
+     * Cancels any previous scheduleTimeout and schedules callback
+     */
+    scheduleTimeout(): void;
+}

package/lib/lib/surya/vendor/phoenix/timer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+/**
+ *
+ * Creates a timer that accepts a `timerCalc` function to perform
+ * calculated timeout retries, such as exponential backoff.
+ *
+ * @example
+ * let reconnectTimer = new Timer(() => this.connect(), function(tries){
+ *   return [1000, 5000, 10000][tries - 1] || 10000
+ * })
+ * reconnectTimer.scheduleTimeout() // fires after 1000
+ * reconnectTimer.scheduleTimeout() // fires after 5000
+ * reconnectTimer.reset()
+ * reconnectTimer.scheduleTimeout() // fires after 1000
+ *
+ * @param {Function} callback
+ * @param {Function} timerCalc
+ */
+class Timer {
+    constructor(callback, timerCalc) {
+        this.callback = callback;
+        this.timerCalc = timerCalc;
+        this.timer = null;
+        this.tries = 0;
+    }
+    reset() {
+        this.tries = 0;
+        clearTimeout(this.timer);
+    }
+    /**
+     * Cancels any previous scheduleTimeout and schedules callback
+     */
+    scheduleTimeout() {
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.tries = this.tries + 1;
+            this.callback();
+        }, this.timerCalc(this.tries + 1));
+    }
+}
+exports.default = Timer;

package/lib/lib/surya/vendor/phoenix/utils.d.ts

@@ -0,0 +1 @@
+export declare let closure: (value: any) => any;

package/lib/lib/surya/vendor/phoenix/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closure = void 0;
+// @ts-nocheck
+// wraps value in closure or returns closure
+let closure = (value) => {
+    if (typeof value === "function") {
+        return value;
+    }
+    else {
+        let closure = function () { return value; };
+        return closure;
+    }
+};
+exports.closure = closure;

package/lib/lib/teletype/auxiliary.d.ts

@@ -1,7 +1,7 @@
 import { IPty } from "node-pty";
 import { Hash } from "../surya/types";
 export declare const initScreen: (username: string, hostname: string, shell: string, multiplexed: boolean) => void;
-export declare type dimensions = {
+export type dimensions = {
     rows: number;
     cols: number;
 };

package/lib/lib/teletype/auxiliary.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resizeBestFit = exports.areDimensionEqual = exports.getDimensions = exports.initScreen = void 0;
 const chalk = require("chalk");
 const termSize = require("term-size");
-exports.initScreen = (username, hostname, shell, multiplexed) => {
+const initScreen = (username, hostname, shell, multiplexed) => {
     console.log(chalk.bold(chalk.blueBright("TeleType")));
     if (multiplexed) {
         console.log(chalk.yellowBright("You have allowed room participants to write to your shell"));
@@ -13,16 +13,20 @@ exports.initScreen = (username, hostname, shell, multiplexed) => {
 This session is end-to-end encrypted.
 To terminate stream run ${chalk.yellowBright("exit")} or press ${chalk.yellowBright("ctrl-d")} \n`);
 };
-exports.getDimensions = () => {
+exports.initScreen = initScreen;
+const getDimensions = () => {
     const { rows, columns } = termSize();
     return { rows, cols: columns };
 };
-exports.areDimensionEqual = (a, b) => {
+exports.getDimensions = getDimensions;
+const areDimensionEqual = (a, b) => {
     return a.rows === b.rows && a.cols === b.cols;
 };
-exports.resizeBestFit = (term, userDimensions) => {
+exports.areDimensionEqual = areDimensionEqual;
+const resizeBestFit = (term, userDimensions) => {
     const allViewports = Object.values(userDimensions);
     const minrows = Math.min(...allViewports.map((d) => d.rows));
     const mincols = Math.min(...allViewports.map((d) => d.cols));
     term.resize(mincols, minrows);
 };
+exports.resizeBestFit = resizeBestFit;

package/lib/lib/teletype/index.d.ts

@@ -2,7 +2,7 @@
 import { RoomKey } from "../surya/types";
 import { JoinChannelOptions } from "../surya";
 import { Channel } from "../surya/vendor/phoenix";
-export declare type TeletypeOptions = {
+export type TeletypeOptions = {
     userId: string;
     roomKey: RoomKey;
     shell: string;