oorja 1.5.1 → 1.6.3

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+/**
+ * Initializes the Presence
+ * @param {Channel} channel - The Channel
+ * @param {Object} opts - The options,
+ *        for example `{events: {state: "state", diff: "diff"}}`
+ */
+class Presence {
+    constructor(channel, opts = {}) {
+        let events = opts.events || { state: "presence_state", diff: "presence_diff" };
+        this.state = {};
+        this.pendingDiffs = [];
+        this.channel = channel;
+        this.joinRef = null;
+        this.caller = {
+            onJoin: function () { },
+            onLeave: function () { },
+            onSync: function () { }
+        };
+        this.channel.on(events.state, newState => {
+            let { onJoin, onLeave, onSync } = this.caller;
+            this.joinRef = this.channel.joinRef();
+            this.state = Presence.syncState(this.state, newState, onJoin, onLeave);
+            this.pendingDiffs.forEach(diff => {
+                this.state = Presence.syncDiff(this.state, diff, onJoin, onLeave);
+            });
+            this.pendingDiffs = [];
+            onSync();
+        });
+        this.channel.on(events.diff, diff => {
+            let { onJoin, onLeave, onSync } = this.caller;
+            if (this.inPendingSyncState()) {
+                this.pendingDiffs.push(diff);
+            }
+            else {
+                this.state = Presence.syncDiff(this.state, diff, onJoin, onLeave);
+                onSync();
+            }
+        });
+    }
+    onJoin(callback) { this.caller.onJoin = callback; }
+    onLeave(callback) { this.caller.onLeave = callback; }
+    onSync(callback) { this.caller.onSync = callback; }
+    list(by) { return Presence.list(this.state, by); }
+    inPendingSyncState() {
+        return !this.joinRef || (this.joinRef !== this.channel.joinRef());
+    }
+    // lower-level public static API
+    /**
+     * Used to sync the list of presences on the server
+     * with the client's state. An optional `onJoin` and `onLeave` callback can
+     * be provided to react to changes in the client's local presences across
+     * disconnects and reconnects with the server.
+     *
+     * @returns {Presence}
+     */
+    static syncState(currentState, newState, onJoin, onLeave) {
+        let state = this.clone(currentState);
+        let joins = {};
+        let leaves = {};
+        this.map(state, (key, presence) => {
+            if (!newState[key]) {
+                leaves[key] = presence;
+            }
+        });
+        this.map(newState, (key, newPresence) => {
+            let currentPresence = state[key];
+            if (currentPresence) {
+                let newRefs = newPresence.metas.map(m => m.phx_ref);
+                let curRefs = currentPresence.metas.map(m => m.phx_ref);
+                let joinedMetas = newPresence.metas.filter(m => curRefs.indexOf(m.phx_ref) < 0);
+                let leftMetas = currentPresence.metas.filter(m => newRefs.indexOf(m.phx_ref) < 0);
+                if (joinedMetas.length > 0) {
+                    joins[key] = newPresence;
+                    joins[key].metas = joinedMetas;
+                }
+                if (leftMetas.length > 0) {
+                    leaves[key] = this.clone(currentPresence);
+                    leaves[key].metas = leftMetas;
+                }
+            }
+            else {
+                joins[key] = newPresence;
+            }
+        });
+        return this.syncDiff(state, { joins: joins, leaves: leaves }, onJoin, onLeave);
+    }
+    /**
+     *
+     * Used to sync a diff of presence join and leave
+     * events from the server, as they happen. Like `syncState`, `syncDiff`
+     * accepts optional `onJoin` and `onLeave` callbacks to react to a user
+     * joining or leaving from a device.
+     *
+     * @returns {Presence}
+     */
+    static syncDiff(state, diff, onJoin, onLeave) {
+        let { joins, leaves } = this.clone(diff);
+        if (!onJoin) {
+            onJoin = function () { };
+        }
+        if (!onLeave) {
+            onLeave = function () { };
+        }
+        this.map(joins, (key, newPresence) => {
+            let currentPresence = state[key];
+            state[key] = this.clone(newPresence);
+            if (currentPresence) {
+                let joinedRefs = state[key].metas.map(m => m.phx_ref);
+                let curMetas = currentPresence.metas.filter(m => joinedRefs.indexOf(m.phx_ref) < 0);
+                state[key].metas.unshift(...curMetas);
+            }
+            onJoin(key, currentPresence, newPresence);
+        });
+        this.map(leaves, (key, leftPresence) => {
+            let currentPresence = state[key];
+            if (!currentPresence) {
+                return;
+            }
+            let refsToRemove = leftPresence.metas.map(m => m.phx_ref);
+            currentPresence.metas = currentPresence.metas.filter(p => {
+                return refsToRemove.indexOf(p.phx_ref) < 0;
+            });
+            onLeave(key, currentPresence, leftPresence);
+            if (currentPresence.metas.length === 0) {
+                delete state[key];
+            }
+        });
+        return state;
+    }
+    /**
+     * Returns the array of presences, with selected metadata.
+     *
+     * @param {Object} presences
+     * @param {Function} chooser
+     *
+     * @returns {Presence}
+     */
+    static list(presences, chooser) {
+        if (!chooser) {
+            chooser = function (key, pres) { return pres; };
+        }
+        return this.map(presences, (key, presence) => {
+            return chooser(key, presence);
+        });
+    }
+    // private
+    static map(obj, func) {
+        return Object.getOwnPropertyNames(obj).map(key => func(key, obj[key]));
+    }
+    static clone(obj) { return JSON.parse(JSON.stringify(obj)); }
+}
+exports.default = Presence;

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

@@ -0,0 +1,57 @@
+/**
+ * Initializes the Push
+ * @param {Channel} channel - The Channel
+ * @param {string} event - The event, for example `"phx_join"`
+ * @param {Object} payload - The payload, for example `{user_id: 123}`
+ * @param {number} timeout - The push timeout in milliseconds
+ */
+export default class Push {
+    constructor(channel: any, event: any, payload: any, timeout: any);
+    /**
+     *
+     * @param {number} timeout
+     */
+    resend(timeout: any): void;
+    /**
+     *
+     */
+    send(): void;
+    /**
+     *
+     * @param {*} status
+     * @param {*} callback
+     */
+    receive(status: any, callback: any): this;
+    /**
+     * @private
+     */
+    reset(): void;
+    /**
+     * @private
+     */
+    matchReceive({ status, response, _ref }: {
+        status: any;
+        response: any;
+        _ref: any;
+    }): void;
+    /**
+     * @private
+     */
+    cancelRefEvent(): void;
+    /**
+     * @private
+     */
+    cancelTimeout(): void;
+    /**
+     * @private
+     */
+    startTimeout(): void;
+    /**
+     * @private
+     */
+    hasReceived(status: any): any;
+    /**
+     * @private
+     */
+    trigger(status: any, response: any): void;
+}

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+/**
+ * Initializes the Push
+ * @param {Channel} channel - The Channel
+ * @param {string} event - The event, for example `"phx_join"`
+ * @param {Object} payload - The payload, for example `{user_id: 123}`
+ * @param {number} timeout - The push timeout in milliseconds
+ */
+class Push {
+    constructor(channel, event, payload, timeout) {
+        this.channel = channel;
+        this.event = event;
+        this.payload = payload || function () { return {}; };
+        this.receivedResp = null;
+        this.timeout = timeout;
+        this.timeoutTimer = null;
+        this.recHooks = [];
+        this.sent = false;
+    }
+    /**
+     *
+     * @param {number} timeout
+     */
+    resend(timeout) {
+        this.timeout = timeout;
+        this.reset();
+        this.send();
+    }
+    /**
+     *
+     */
+    send() {
+        if (this.hasReceived("timeout")) {
+            return;
+        }
+        this.startTimeout();
+        this.sent = true;
+        this.channel.socket.push({
+            topic: this.channel.topic,
+            event: this.event,
+            payload: this.payload(),
+            ref: this.ref,
+            join_ref: this.channel.joinRef()
+        });
+    }
+    /**
+     *
+     * @param {*} status
+     * @param {*} callback
+     */
+    receive(status, callback) {
+        if (this.hasReceived(status)) {
+            callback(this.receivedResp.response);
+        }
+        this.recHooks.push({ status, callback });
+        return this;
+    }
+    /**
+     * @private
+     */
+    reset() {
+        this.cancelRefEvent();
+        this.ref = null;
+        this.refEvent = null;
+        this.receivedResp = null;
+        this.sent = false;
+    }
+    /**
+     * @private
+     */
+    matchReceive({ status, response, _ref }) {
+        this.recHooks.filter(h => h.status === status)
+            .forEach(h => h.callback(response));
+    }
+    /**
+     * @private
+     */
+    cancelRefEvent() {
+        if (!this.refEvent) {
+            return;
+        }
+        this.channel.off(this.refEvent);
+    }
+    /**
+     * @private
+     */
+    cancelTimeout() {
+        clearTimeout(this.timeoutTimer);
+        this.timeoutTimer = null;
+    }
+    /**
+     * @private
+     */
+    startTimeout() {
+        if (this.timeoutTimer) {
+            this.cancelTimeout();
+        }
+        this.ref = this.channel.socket.makeRef();
+        this.refEvent = this.channel.replyEventName(this.ref);
+        this.channel.on(this.refEvent, payload => {
+            this.cancelRefEvent();
+            this.cancelTimeout();
+            this.receivedResp = payload;
+            this.matchReceive(payload);
+        });
+        this.timeoutTimer = setTimeout(() => {
+            this.trigger("timeout", {});
+        }, this.timeout);
+    }
+    /**
+     * @private
+     */
+    hasReceived(status) {
+        return this.receivedResp && this.receivedResp.status === status;
+    }
+    /**
+     * @private
+     */
+    trigger(status, response) {
+        this.channel.trigger(this.refEvent, { status, response });
+    }
+}
+exports.default = Push;

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

@@ -0,0 +1,53 @@
+declare const _default: {
+    HEADER_LENGTH: number;
+    META_LENGTH: number;
+    KINDS: {
+        push: number;
+        reply: number;
+        broadcast: number;
+    };
+    encode(msg: any, callback: any): any;
+    decode(rawPayload: any, callback: any): any;
+    binaryEncode(message: any): ArrayBufferLike;
+    binaryDecode(buffer: any): {
+        join_ref: any;
+        ref: null;
+        topic: any;
+        event: any;
+        payload: any;
+    } | {
+        join_ref: any;
+        ref: any;
+        topic: any;
+        event: string;
+        payload: {
+            status: any;
+            response: any;
+        };
+    } | undefined;
+    decodePush(buffer: any, view: any, decoder: any): {
+        join_ref: any;
+        ref: null;
+        topic: any;
+        event: any;
+        payload: any;
+    };
+    decodeReply(buffer: any, view: any, decoder: any): {
+        join_ref: any;
+        ref: any;
+        topic: any;
+        event: string;
+        payload: {
+            status: any;
+            response: any;
+        };
+    };
+    decodeBroadcast(buffer: any, view: any, decoder: any): {
+        join_ref: null;
+        ref: null;
+        topic: any;
+        event: any;
+        payload: any;
+    };
+};
+export default _default;

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+/* The default serializer for encoding and decoding messages */
+const constants_1 = require("./constants");
+exports.default = {
+    HEADER_LENGTH: 1,
+    META_LENGTH: 4,
+    KINDS: { push: 0, reply: 1, broadcast: 2 },
+    encode(msg, callback) {
+        if (msg.payload.constructor === ArrayBuffer) {
+            return callback(this.binaryEncode(msg));
+        }
+        else {
+            let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload];
+            return callback(JSON.stringify(payload));
+        }
+    },
+    decode(rawPayload, callback) {
+        if (rawPayload.constructor === ArrayBuffer) {
+            return callback(this.binaryDecode(rawPayload));
+        }
+        else {
+            let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload);
+            return callback({ join_ref, ref, topic, event, payload });
+        }
+    },
+    // private
+    binaryEncode(message) {
+        let { join_ref, ref, event, topic, payload } = message;
+        let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length;
+        let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength);
+        let view = new DataView(header);
+        let offset = 0;
+        view.setUint8(offset++, this.KINDS.push); // kind
+        view.setUint8(offset++, join_ref.length);
+        view.setUint8(offset++, ref.length);
+        view.setUint8(offset++, topic.length);
+        view.setUint8(offset++, event.length);
+        Array.from(join_ref, char => view.setUint8(offset++, char.charCodeAt(0)));
+        Array.from(ref, char => view.setUint8(offset++, char.charCodeAt(0)));
+        Array.from(topic, char => view.setUint8(offset++, char.charCodeAt(0)));
+        Array.from(event, char => view.setUint8(offset++, char.charCodeAt(0)));
+        var combined = new Uint8Array(header.byteLength + payload.byteLength);
+        combined.set(new Uint8Array(header), 0);
+        combined.set(new Uint8Array(payload), header.byteLength);
+        return combined.buffer;
+    },
+    binaryDecode(buffer) {
+        let view = new DataView(buffer);
+        let kind = view.getUint8(0);
+        let decoder = new TextDecoder();
+        switch (kind) {
+            case this.KINDS.push: return this.decodePush(buffer, view, decoder);
+            case this.KINDS.reply: return this.decodeReply(buffer, view, decoder);
+            case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder);
+        }
+    },
+    decodePush(buffer, view, decoder) {
+        let joinRefSize = view.getUint8(1);
+        let topicSize = view.getUint8(2);
+        let eventSize = view.getUint8(3);
+        let offset = this.HEADER_LENGTH + this.META_LENGTH - 1; // pushes have no ref
+        let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize));
+        offset = offset + joinRefSize;
+        let topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+        offset = offset + topicSize;
+        let event = decoder.decode(buffer.slice(offset, offset + eventSize));
+        offset = offset + eventSize;
+        let data = buffer.slice(offset, buffer.byteLength);
+        return { join_ref: joinRef, ref: null, topic: topic, event: event, payload: data };
+    },
+    decodeReply(buffer, view, decoder) {
+        let joinRefSize = view.getUint8(1);
+        let refSize = view.getUint8(2);
+        let topicSize = view.getUint8(3);
+        let eventSize = view.getUint8(4);
+        let offset = this.HEADER_LENGTH + this.META_LENGTH;
+        let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize));
+        offset = offset + joinRefSize;
+        let ref = decoder.decode(buffer.slice(offset, offset + refSize));
+        offset = offset + refSize;
+        let topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+        offset = offset + topicSize;
+        let event = decoder.decode(buffer.slice(offset, offset + eventSize));
+        offset = offset + eventSize;
+        let data = buffer.slice(offset, buffer.byteLength);
+        let payload = { status: event, response: data };
+        return { join_ref: joinRef, ref: ref, topic: topic, event: constants_1.CHANNEL_EVENTS.reply, payload: payload };
+    },
+    decodeBroadcast(buffer, view, decoder) {
+        let topicSize = view.getUint8(1);
+        let eventSize = view.getUint8(2);
+        let offset = this.HEADER_LENGTH + 2;
+        let topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+        offset = offset + topicSize;
+        let event = decoder.decode(buffer.slice(offset, offset + eventSize));
+        offset = offset + eventSize;
+        let data = buffer.slice(offset, buffer.byteLength);
+        return { join_ref: null, ref: null, topic: topic, event: event, payload: data };
+    }
+};