oorja 1.5.1 → 1.6.2

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

@@ -0,0 +1,154 @@
+import Push from "./push";
+/**
+ *
+ * @param {string} topic
+ * @param {(Object|function)} params
+ * @param {Socket} socket
+ */
+export default class Channel {
+    constructor(topic: any, params: any, socket: any);
+    /**
+     * Join the channel
+     * @param {integer} timeout
+     * @returns {Push}
+     */
+    join(timeout?: any): any;
+    /**
+     * Hook into channel close
+     * @param {Function} callback
+     */
+    onClose(callback: any): void;
+    /**
+     * Hook into channel errors
+     * @param {Function} callback
+     */
+    onError(callback: any): number;
+    /**
+     * Subscribes on channel events
+     *
+     * Subscription returns a ref counter, which can be used later to
+     * unsubscribe the exact event listener
+     *
+     * @example
+     * const ref1 = channel.on("event", do_stuff)
+     * const ref2 = channel.on("event", do_other_stuff)
+     * channel.off("event", ref1)
+     * // Since unsubscription, do_stuff won't fire,
+     * // while do_other_stuff will keep firing on the "event"
+     *
+     * @param {string} event
+     * @param {Function} callback
+     * @returns {integer} ref
+     */
+    on(event: any, callback: any): number;
+    /**
+     * Unsubscribes off of channel events
+     *
+     * Use the ref returned from a channel.on() to unsubscribe one
+     * handler, or pass nothing for the ref to unsubscribe all
+     * handlers for the given event.
+     *
+     * @example
+     * // Unsubscribe the do_stuff handler
+     * const ref1 = channel.on("event", do_stuff)
+     * channel.off("event", ref1)
+     *
+     * // Unsubscribe all handlers from event
+     * channel.off("event")
+     *
+     * @param {string} event
+     * @param {integer} ref
+     */
+    off(event: any, ref: any): void;
+    /**
+     * @private
+     */
+    canPush(): any;
+    /**
+     * Sends a message `event` to phoenix with the payload `payload`.
+     * Phoenix receives this in the `handle_in(event, payload, socket)`
+     * function. if phoenix replies or it times out (default 10000ms),
+     * then optionally the reply can be received.
+     *
+     * @example
+     * channel.push("event")
+     *   .receive("ok", payload => console.log("phoenix replied:", payload))
+     *   .receive("error", err => console.log("phoenix errored", err))
+     *   .receive("timeout", () => console.log("timed out pushing"))
+     * @param {string} event
+     * @param {Object} payload
+     * @param {number} [timeout]
+     * @returns {Push}
+     */
+    push(event: any, payload: any, timeout?: any): Push;
+    /** Leaves the channel
+     *
+     * Unsubscribes from server events, and
+     * instructs channel to terminate on server
+     *
+     * Triggers onClose() hooks
+     *
+     * To receive leave acknowledgements, use the `receive`
+     * hook to bind to the server ack, ie:
+     *
+     * @example
+     * channel.leave().receive("ok", () => alert("left!") )
+     *
+     * @param {integer} timeout
+     * @returns {Push}
+     */
+    leave(timeout?: any): Push;
+    /**
+     * Overridable message hook
+     *
+     * Receives all events for specialized message handling
+     * before dispatching to the channel callbacks.
+     *
+     * Must return the payload, modified or unmodified
+     * @param {string} event
+     * @param {Object} payload
+     * @param {integer} ref
+     * @returns {Object}
+     */
+    onMessage(_event: any, payload: any, _ref: any): any;
+    /**
+     * @private
+     */
+    isMember(topic: any, event: any, payload: any, joinRef: any): boolean;
+    /**
+     * @private
+     */
+    joinRef(): any;
+    /**
+     * @private
+     */
+    rejoin(timeout?: any): void;
+    /**
+     * @private
+     */
+    trigger(event: any, payload: any, ref: any, joinRef: any): void;
+    /**
+     * @private
+     */
+    replyEventName(ref: any): string;
+    /**
+     * @private
+     */
+    isClosed(): boolean;
+    /**
+     * @private
+     */
+    isErrored(): boolean;
+    /**
+     * @private
+     */
+    isJoined(): boolean;
+    /**
+     * @private
+     */
+    isJoining(): boolean;
+    /**
+     * @private
+     */
+    isLeaving(): boolean;
+}

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

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const push_1 = require("./push");
+const timer_1 = require("./timer");
+/**
+ *
+ * @param {string} topic
+ * @param {(Object|function)} params
+ * @param {Socket} socket
+ */
+class Channel {
+    constructor(topic, params, socket) {
+        this.state = constants_1.CHANNEL_STATES.closed;
+        this.topic = topic;
+        this.params = (0, utils_1.closure)(params || {});
+        this.socket = socket;
+        this.bindings = [];
+        this.bindingRef = 0;
+        this.timeout = this.socket.timeout;
+        this.joinedOnce = false;
+        this.joinPush = new push_1.default(this, constants_1.CHANNEL_EVENTS.join, this.params, this.timeout);
+        this.pushBuffer = [];
+        this.stateChangeRefs = [];
+        this.rejoinTimer = new timer_1.default(() => {
+            if (this.socket.isConnected()) {
+                this.rejoin();
+            }
+        }, this.socket.rejoinAfterMs);
+        this.stateChangeRefs.push(this.socket.onError(() => this.rejoinTimer.reset()));
+        this.stateChangeRefs.push(this.socket.onOpen(() => {
+            this.rejoinTimer.reset();
+            if (this.isErrored()) {
+                this.rejoin();
+            }
+        }));
+        this.joinPush.receive("ok", () => {
+            this.state = constants_1.CHANNEL_STATES.joined;
+            this.rejoinTimer.reset();
+            this.pushBuffer.forEach(pushEvent => pushEvent.send());
+            this.pushBuffer = [];
+        });
+        this.joinPush.receive("error", () => {
+            this.state = constants_1.CHANNEL_STATES.errored;
+            if (this.socket.isConnected()) {
+                this.rejoinTimer.scheduleTimeout();
+            }
+        });
+        this.onClose(() => {
+            this.rejoinTimer.reset();
+            if (this.socket.hasLogger())
+                this.socket.log("channel", `close ${this.topic} ${this.joinRef()}`);
+            this.state = constants_1.CHANNEL_STATES.closed;
+            this.socket.remove(this);
+        });
+        this.onError(reason => {
+            if (this.socket.hasLogger())
+                this.socket.log("channel", `error ${this.topic}`, reason);
+            if (this.isJoining()) {
+                this.joinPush.reset();
+            }
+            this.state = constants_1.CHANNEL_STATES.errored;
+            if (this.socket.isConnected()) {
+                this.rejoinTimer.scheduleTimeout();
+            }
+        });
+        this.joinPush.receive("timeout", () => {
+            if (this.socket.hasLogger())
+                this.socket.log("channel", `timeout ${this.topic} (${this.joinRef()})`, this.joinPush.timeout);
+            let leavePush = new push_1.default(this, constants_1.CHANNEL_EVENTS.leave, (0, utils_1.closure)({}), this.timeout);
+            leavePush.send();
+            this.state = constants_1.CHANNEL_STATES.errored;
+            this.joinPush.reset();
+            if (this.socket.isConnected()) {
+                this.rejoinTimer.scheduleTimeout();
+            }
+        });
+        this.on(constants_1.CHANNEL_EVENTS.reply, (payload, ref) => {
+            this.trigger(this.replyEventName(ref), payload);
+        });
+    }
+    /**
+     * Join the channel
+     * @param {integer} timeout
+     * @returns {Push}
+     */
+    join(timeout = this.timeout) {
+        if (this.joinedOnce) {
+            throw new Error("tried to join multiple times. 'join' can only be called a single time per channel instance");
+        }
+        else {
+            this.timeout = timeout;
+            this.joinedOnce = true;
+            this.rejoin();
+            return this.joinPush;
+        }
+    }
+    /**
+     * Hook into channel close
+     * @param {Function} callback
+     */
+    onClose(callback) {
+        this.on(constants_1.CHANNEL_EVENTS.close, callback);
+    }
+    /**
+     * Hook into channel errors
+     * @param {Function} callback
+     */
+    onError(callback) {
+        return this.on(constants_1.CHANNEL_EVENTS.error, reason => callback(reason));
+    }
+    /**
+     * Subscribes on channel events
+     *
+     * Subscription returns a ref counter, which can be used later to
+     * unsubscribe the exact event listener
+     *
+     * @example
+     * const ref1 = channel.on("event", do_stuff)
+     * const ref2 = channel.on("event", do_other_stuff)
+     * channel.off("event", ref1)
+     * // Since unsubscription, do_stuff won't fire,
+     * // while do_other_stuff will keep firing on the "event"
+     *
+     * @param {string} event
+     * @param {Function} callback
+     * @returns {integer} ref
+     */
+    on(event, callback) {
+        let ref = this.bindingRef++;
+        this.bindings.push({ event, ref, callback });
+        return ref;
+    }
+    /**
+     * Unsubscribes off of channel events
+     *
+     * Use the ref returned from a channel.on() to unsubscribe one
+     * handler, or pass nothing for the ref to unsubscribe all
+     * handlers for the given event.
+     *
+     * @example
+     * // Unsubscribe the do_stuff handler
+     * const ref1 = channel.on("event", do_stuff)
+     * channel.off("event", ref1)
+     *
+     * // Unsubscribe all handlers from event
+     * channel.off("event")
+     *
+     * @param {string} event
+     * @param {integer} ref
+     */
+    off(event, ref) {
+        this.bindings = this.bindings.filter((bind) => {
+            return !(bind.event === event && (typeof ref === "undefined" || ref === bind.ref));
+        });
+    }
+    /**
+     * @private
+     */
+    canPush() { return this.socket.isConnected() && this.isJoined(); }
+    /**
+     * Sends a message `event` to phoenix with the payload `payload`.
+     * Phoenix receives this in the `handle_in(event, payload, socket)`
+     * function. if phoenix replies or it times out (default 10000ms),
+     * then optionally the reply can be received.
+     *
+     * @example
+     * channel.push("event")
+     *   .receive("ok", payload => console.log("phoenix replied:", payload))
+     *   .receive("error", err => console.log("phoenix errored", err))
+     *   .receive("timeout", () => console.log("timed out pushing"))
+     * @param {string} event
+     * @param {Object} payload
+     * @param {number} [timeout]
+     * @returns {Push}
+     */
+    push(event, payload, timeout = this.timeout) {
+        payload = payload || {};
+        if (!this.joinedOnce) {
+            throw new Error(`tried to push '${event}' to '${this.topic}' before joining. Use channel.join() before pushing events`);
+        }
+        let pushEvent = new push_1.default(this, event, function () { return payload; }, timeout);
+        if (this.canPush()) {
+            pushEvent.send();
+        }
+        else {
+            pushEvent.startTimeout();
+            this.pushBuffer.push(pushEvent);
+        }
+        return pushEvent;
+    }
+    /** Leaves the channel
+     *
+     * Unsubscribes from server events, and
+     * instructs channel to terminate on server
+     *
+     * Triggers onClose() hooks
+     *
+     * To receive leave acknowledgements, use the `receive`
+     * hook to bind to the server ack, ie:
+     *
+     * @example
+     * channel.leave().receive("ok", () => alert("left!") )
+     *
+     * @param {integer} timeout
+     * @returns {Push}
+     */
+    leave(timeout = this.timeout) {
+        this.rejoinTimer.reset();
+        this.joinPush.cancelTimeout();
+        this.state = constants_1.CHANNEL_STATES.leaving;
+        let onClose = () => {
+            if (this.socket.hasLogger())
+                this.socket.log("channel", `leave ${this.topic}`);
+            this.trigger(constants_1.CHANNEL_EVENTS.close, "leave");
+        };
+        let leavePush = new push_1.default(this, constants_1.CHANNEL_EVENTS.leave, (0, utils_1.closure)({}), timeout);
+        leavePush.receive("ok", () => onClose())
+            .receive("timeout", () => onClose());
+        leavePush.send();
+        if (!this.canPush()) {
+            leavePush.trigger("ok", {});
+        }
+        return leavePush;
+    }
+    /**
+     * Overridable message hook
+     *
+     * Receives all events for specialized message handling
+     * before dispatching to the channel callbacks.
+     *
+     * Must return the payload, modified or unmodified
+     * @param {string} event
+     * @param {Object} payload
+     * @param {integer} ref
+     * @returns {Object}
+     */
+    onMessage(_event, payload, _ref) { return payload; }
+    /**
+     * @private
+     */
+    isMember(topic, event, payload, joinRef) {
+        if (this.topic !== topic) {
+            return false;
+        }
+        if (joinRef && joinRef !== this.joinRef()) {
+            if (this.socket.hasLogger())
+                this.socket.log("channel", "dropping outdated message", { topic, event, payload, joinRef });
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * @private
+     */
+    joinRef() { return this.joinPush.ref; }
+    /**
+     * @private
+     */
+    rejoin(timeout = this.timeout) {
+        if (this.isLeaving()) {
+            return;
+        }
+        this.socket.leaveOpenTopic(this.topic);
+        this.state = constants_1.CHANNEL_STATES.joining;
+        this.joinPush.resend(timeout);
+    }
+    /**
+     * @private
+     */
+    trigger(event, payload, ref, joinRef) {
+        let handledPayload = this.onMessage(event, payload, ref, joinRef);
+        if (payload && !handledPayload) {
+            throw new Error("channel onMessage callbacks must return the payload, modified or unmodified");
+        }
+        let eventBindings = this.bindings.filter(bind => bind.event === event);
+        for (let i = 0; i < eventBindings.length; i++) {
+            let bind = eventBindings[i];
+            bind.callback(handledPayload, ref, joinRef || this.joinRef());
+        }
+    }
+    /**
+     * @private
+     */
+    replyEventName(ref) { return `chan_reply_${ref}`; }
+    /**
+     * @private
+     */
+    isClosed() { return this.state === constants_1.CHANNEL_STATES.closed; }
+    /**
+     * @private
+     */
+    isErrored() { return this.state === constants_1.CHANNEL_STATES.errored; }
+    /**
+     * @private
+     */
+    isJoined() { return this.state === constants_1.CHANNEL_STATES.joined; }
+    /**
+     * @private
+     */
+    isJoining() { return this.state === constants_1.CHANNEL_STATES.joining; }
+    /**
+     * @private
+     */
+    isLeaving() { return this.state === constants_1.CHANNEL_STATES.leaving; }
+}
+exports.default = Channel;

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

@@ -0,0 +1,33 @@
+export declare const globalSelf: any;
+export declare const phxWindow: any;
+export declare const global: any;
+export declare const DEFAULT_VSN = "2.0.0";
+export declare const SOCKET_STATES: {
+    connecting: number;
+    open: number;
+    closing: number;
+    closed: number;
+};
+export declare const DEFAULT_TIMEOUT = 10000;
+export declare const WS_CLOSE_NORMAL = 1000;
+export declare const CHANNEL_STATES: {
+    closed: string;
+    errored: string;
+    joined: string;
+    joining: string;
+    leaving: string;
+};
+export declare const CHANNEL_EVENTS: {
+    close: string;
+    error: string;
+    join: string;
+    reply: string;
+    leave: string;
+};
+export declare const TRANSPORTS: {
+    longpoll: string;
+    websocket: string;
+};
+export declare const XHR_STATES: {
+    complete: number;
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XHR_STATES = exports.TRANSPORTS = exports.CHANNEL_EVENTS = exports.CHANNEL_STATES = exports.WS_CLOSE_NORMAL = exports.DEFAULT_TIMEOUT = exports.SOCKET_STATES = exports.DEFAULT_VSN = exports.global = exports.phxWindow = exports.globalSelf = void 0;
+// @ts-nocheck
+exports.globalSelf = typeof self !== "undefined" ? self : null;
+exports.phxWindow = typeof window !== "undefined" ? window : null;
+exports.global = exports.globalSelf || exports.phxWindow || {};
+exports.DEFAULT_VSN = "2.0.0";
+exports.SOCKET_STATES = { connecting: 0, open: 1, closing: 2, closed: 3 };
+exports.DEFAULT_TIMEOUT = 10000;
+exports.WS_CLOSE_NORMAL = 1000;
+exports.CHANNEL_STATES = {
+    closed: "closed",
+    errored: "errored",
+    joined: "joined",
+    joining: "joining",
+    leaving: "leaving",
+};
+exports.CHANNEL_EVENTS = {
+    close: "phx_close",
+    error: "phx_error",
+    join: "phx_join",
+    reply: "phx_reply",
+    leave: "phx_leave"
+};
+exports.TRANSPORTS = {
+    longpoll: "longpoll",
+    websocket: "websocket"
+};
+exports.XHR_STATES = {
+    complete: 4
+};