oorja 1.5.0 → 1.6.2

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

@@ -0,0 +1,199 @@
+/**
+ * Phoenix Channels JavaScript client
+ *
+ * ## Socket Connection
+ *
+ * A single connection is established to the server and
+ * channels are multiplexed over the connection.
+ * Connect to the server using the `Socket` class:
+ *
+ * ```javascript
+ * let socket = new Socket("/socket", {params: {userToken: "123"}})
+ * socket.connect()
+ * ```
+ *
+ * The `Socket` constructor takes the mount point of the socket,
+ * the authentication params, as well as options that can be found in
+ * the Socket docs, such as configuring the `LongPoll` transport, and
+ * heartbeat.
+ *
+ * ## Channels
+ *
+ * Channels are isolated, concurrent processes on the server that
+ * subscribe to topics and broker events between the client and server.
+ * To join a channel, you must provide the topic, and channel params for
+ * authorization. Here's an example chat room example where `"new_msg"`
+ * events are listened for, messages are pushed to the server, and
+ * the channel is joined with ok/error/timeout matches:
+ *
+ * ```javascript
+ * let channel = socket.channel("room:123", {token: roomToken})
+ * channel.on("new_msg", msg => console.log("Got message", msg) )
+ * $input.onEnter( e => {
+ *   channel.push("new_msg", {body: e.target.val}, 10000)
+ *     .receive("ok", (msg) => console.log("created message", msg) )
+ *     .receive("error", (reasons) => console.log("create failed", reasons) )
+ *     .receive("timeout", () => console.log("Networking issue...") )
+ * })
+ *
+ * channel.join()
+ *   .receive("ok", ({messages}) => console.log("catching up", messages) )
+ *   .receive("error", ({reason}) => console.log("failed join", reason) )
+ *   .receive("timeout", () => console.log("Networking issue. Still waiting..."))
+ *```
+ *
+ * ## Joining
+ *
+ * Creating a channel with `socket.channel(topic, params)`, binds the params to
+ * `channel.params`, which are sent up on `channel.join()`.
+ * Subsequent rejoins will send up the modified params for
+ * updating authorization params, or passing up last_message_id information.
+ * Successful joins receive an "ok" status, while unsuccessful joins
+ * receive "error".
+ *
+ * With the default serializers and WebSocket transport, JSON text frames are
+ * used for pushing a JSON object literal. If an `ArrayBuffer` instance is provided,
+ * binary encoding will be used and the message will be sent with the binary
+ * opcode.
+ *
+ * *Note*: binary messages are only supported on the WebSocket transport.
+ *
+ * ## Duplicate Join Subscriptions
+ *
+ * While the client may join any number of topics on any number of channels,
+ * the client may only hold a single subscription for each unique topic at any
+ * given time. When attempting to create a duplicate subscription,
+ * the server will close the existing channel, log a warning, and
+ * spawn a new channel for the topic. The client will have their
+ * `channel.onClose` callbacks fired for the existing channel, and the new
+ * channel join will have its receive hooks processed as normal.
+ *
+ * ## Pushing Messages
+ *
+ * From the previous example, we can see that pushing messages to the server
+ * can be done with `channel.push(eventName, payload)` and we can optionally
+ * receive responses from the push. Additionally, we can use
+ * `receive("timeout", callback)` to abort waiting for our other `receive` hooks
+ *  and take action after some period of waiting. The default timeout is 10000ms.
+ *
+ *
+ * ## Socket Hooks
+ *
+ * Lifecycle events of the multiplexed connection can be hooked into via
+ * `socket.onError()` and `socket.onClose()` events, ie:
+ *
+ * ```javascript
+ * socket.onError( () => console.log("there was an error with the connection!") )
+ * socket.onClose( () => console.log("the connection dropped") )
+ * ```
+ *
+ *
+ * ## Channel Hooks
+ *
+ * For each joined channel, you can bind to `onError` and `onClose` events
+ * to monitor the channel lifecycle, ie:
+ *
+ * ```javascript
+ * channel.onError( () => console.log("there was an error!") )
+ * channel.onClose( () => console.log("the channel has gone away gracefully") )
+ * ```
+ *
+ * ### onError hooks
+ *
+ * `onError` hooks are invoked if the socket connection drops, or the channel
+ * crashes on the server. In either case, a channel rejoin is attempted
+ * automatically in an exponential backoff manner.
+ *
+ * ### onClose hooks
+ *
+ * `onClose` hooks are invoked only in two cases. 1) the channel explicitly
+ * closed on the server, or 2). The client explicitly closed, by calling
+ * `channel.leave()`
+ *
+ *
+ * ## Presence
+ *
+ * The `Presence` object provides features for syncing presence information
+ * from the server with the client and handling presences joining and leaving.
+ *
+ * ### Syncing state from the server
+ *
+ * To sync presence state from the server, first instantiate an object and
+ * pass your channel in to track lifecycle events:
+ *
+ * ```javascript
+ * let channel = socket.channel("some:topic")
+ * let presence = new Presence(channel)
+ * ```
+ *
+ * Next, use the `presence.onSync` callback to react to state changes
+ * from the server. For example, to render the list of users every time
+ * the list changes, you could write:
+ *
+ * ```javascript
+ * presence.onSync(() => {
+ *   myRenderUsersFunction(presence.list())
+ * })
+ * ```
+ *
+ * ### Listing Presences
+ *
+ * `presence.list` is used to return a list of presence information
+ * based on the local state of metadata. By default, all presence
+ * metadata is returned, but a `listBy` function can be supplied to
+ * allow the client to select which metadata to use for a given presence.
+ * For example, you may have a user online from different devices with
+ * a metadata status of "online", but they have set themselves to "away"
+ * on another device. In this case, the app may choose to use the "away"
+ * status for what appears on the UI. The example below defines a `listBy`
+ * function which prioritizes the first metadata which was registered for
+ * each user. This could be the first tab they opened, or the first device
+ * they came online from:
+ *
+ * ```javascript
+ * let listBy = (id, {metas: [first, ...rest]}) => {
+ *   first.count = rest.length + 1 // count of this user's presences
+ *   first.id = id
+ *   return first
+ * }
+ * let onlineUsers = presence.list(listBy)
+ * ```
+ *
+ * ### Handling individual presence join and leave events
+ *
+ * The `presence.onJoin` and `presence.onLeave` callbacks can be used to
+ * react to individual presences joining and leaving the app. For example:
+ *
+ * ```javascript
+ * let presence = new Presence(channel)
+ *
+ * // detect if user has joined for the 1st time or from another tab/device
+ * presence.onJoin((id, current, newPres) => {
+ *   if(!current){
+ *     console.log("user has entered for the first time", newPres)
+ *   } else {
+ *     console.log("user additional presence", newPres)
+ *   }
+ * })
+ *
+ * // detect if user has left from all tabs/devices, or is still present
+ * presence.onLeave((id, current, leftPres) => {
+ *   if(current.metas.length === 0){
+ *     console.log("user has left from all devices", leftPres)
+ *   } else {
+ *     console.log("user left from a device", leftPres)
+ *   }
+ * })
+ * // receive presence data from server
+ * presence.onSync(() => {
+ *   displayUsers(presence.list())
+ * })
+ * ```
+ * @module phoenix
+ */
+import Channel from "./channel";
+import LongPoll from "./longpoll";
+import Presence from "./presence";
+import Serializer from "./serializer";
+import Socket from "./socket";
+export { Channel, LongPoll, Presence, Serializer, Socket };

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

@@ -0,0 +1,207 @@
+"use strict";
+// @ts-nocheck
+/**
+ * Phoenix Channels JavaScript client
+ *
+ * ## Socket Connection
+ *
+ * A single connection is established to the server and
+ * channels are multiplexed over the connection.
+ * Connect to the server using the `Socket` class:
+ *
+ * ```javascript
+ * let socket = new Socket("/socket", {params: {userToken: "123"}})
+ * socket.connect()
+ * ```
+ *
+ * The `Socket` constructor takes the mount point of the socket,
+ * the authentication params, as well as options that can be found in
+ * the Socket docs, such as configuring the `LongPoll` transport, and
+ * heartbeat.
+ *
+ * ## Channels
+ *
+ * Channels are isolated, concurrent processes on the server that
+ * subscribe to topics and broker events between the client and server.
+ * To join a channel, you must provide the topic, and channel params for
+ * authorization. Here's an example chat room example where `"new_msg"`
+ * events are listened for, messages are pushed to the server, and
+ * the channel is joined with ok/error/timeout matches:
+ *
+ * ```javascript
+ * let channel = socket.channel("room:123", {token: roomToken})
+ * channel.on("new_msg", msg => console.log("Got message", msg) )
+ * $input.onEnter( e => {
+ *   channel.push("new_msg", {body: e.target.val}, 10000)
+ *     .receive("ok", (msg) => console.log("created message", msg) )
+ *     .receive("error", (reasons) => console.log("create failed", reasons) )
+ *     .receive("timeout", () => console.log("Networking issue...") )
+ * })
+ *
+ * channel.join()
+ *   .receive("ok", ({messages}) => console.log("catching up", messages) )
+ *   .receive("error", ({reason}) => console.log("failed join", reason) )
+ *   .receive("timeout", () => console.log("Networking issue. Still waiting..."))
+ *```
+ *
+ * ## Joining
+ *
+ * Creating a channel with `socket.channel(topic, params)`, binds the params to
+ * `channel.params`, which are sent up on `channel.join()`.
+ * Subsequent rejoins will send up the modified params for
+ * updating authorization params, or passing up last_message_id information.
+ * Successful joins receive an "ok" status, while unsuccessful joins
+ * receive "error".
+ *
+ * With the default serializers and WebSocket transport, JSON text frames are
+ * used for pushing a JSON object literal. If an `ArrayBuffer` instance is provided,
+ * binary encoding will be used and the message will be sent with the binary
+ * opcode.
+ *
+ * *Note*: binary messages are only supported on the WebSocket transport.
+ *
+ * ## Duplicate Join Subscriptions
+ *
+ * While the client may join any number of topics on any number of channels,
+ * the client may only hold a single subscription for each unique topic at any
+ * given time. When attempting to create a duplicate subscription,
+ * the server will close the existing channel, log a warning, and
+ * spawn a new channel for the topic. The client will have their
+ * `channel.onClose` callbacks fired for the existing channel, and the new
+ * channel join will have its receive hooks processed as normal.
+ *
+ * ## Pushing Messages
+ *
+ * From the previous example, we can see that pushing messages to the server
+ * can be done with `channel.push(eventName, payload)` and we can optionally
+ * receive responses from the push. Additionally, we can use
+ * `receive("timeout", callback)` to abort waiting for our other `receive` hooks
+ *  and take action after some period of waiting. The default timeout is 10000ms.
+ *
+ *
+ * ## Socket Hooks
+ *
+ * Lifecycle events of the multiplexed connection can be hooked into via
+ * `socket.onError()` and `socket.onClose()` events, ie:
+ *
+ * ```javascript
+ * socket.onError( () => console.log("there was an error with the connection!") )
+ * socket.onClose( () => console.log("the connection dropped") )
+ * ```
+ *
+ *
+ * ## Channel Hooks
+ *
+ * For each joined channel, you can bind to `onError` and `onClose` events
+ * to monitor the channel lifecycle, ie:
+ *
+ * ```javascript
+ * channel.onError( () => console.log("there was an error!") )
+ * channel.onClose( () => console.log("the channel has gone away gracefully") )
+ * ```
+ *
+ * ### onError hooks
+ *
+ * `onError` hooks are invoked if the socket connection drops, or the channel
+ * crashes on the server. In either case, a channel rejoin is attempted
+ * automatically in an exponential backoff manner.
+ *
+ * ### onClose hooks
+ *
+ * `onClose` hooks are invoked only in two cases. 1) the channel explicitly
+ * closed on the server, or 2). The client explicitly closed, by calling
+ * `channel.leave()`
+ *
+ *
+ * ## Presence
+ *
+ * The `Presence` object provides features for syncing presence information
+ * from the server with the client and handling presences joining and leaving.
+ *
+ * ### Syncing state from the server
+ *
+ * To sync presence state from the server, first instantiate an object and
+ * pass your channel in to track lifecycle events:
+ *
+ * ```javascript
+ * let channel = socket.channel("some:topic")
+ * let presence = new Presence(channel)
+ * ```
+ *
+ * Next, use the `presence.onSync` callback to react to state changes
+ * from the server. For example, to render the list of users every time
+ * the list changes, you could write:
+ *
+ * ```javascript
+ * presence.onSync(() => {
+ *   myRenderUsersFunction(presence.list())
+ * })
+ * ```
+ *
+ * ### Listing Presences
+ *
+ * `presence.list` is used to return a list of presence information
+ * based on the local state of metadata. By default, all presence
+ * metadata is returned, but a `listBy` function can be supplied to
+ * allow the client to select which metadata to use for a given presence.
+ * For example, you may have a user online from different devices with
+ * a metadata status of "online", but they have set themselves to "away"
+ * on another device. In this case, the app may choose to use the "away"
+ * status for what appears on the UI. The example below defines a `listBy`
+ * function which prioritizes the first metadata which was registered for
+ * each user. This could be the first tab they opened, or the first device
+ * they came online from:
+ *
+ * ```javascript
+ * let listBy = (id, {metas: [first, ...rest]}) => {
+ *   first.count = rest.length + 1 // count of this user's presences
+ *   first.id = id
+ *   return first
+ * }
+ * let onlineUsers = presence.list(listBy)
+ * ```
+ *
+ * ### Handling individual presence join and leave events
+ *
+ * The `presence.onJoin` and `presence.onLeave` callbacks can be used to
+ * react to individual presences joining and leaving the app. For example:
+ *
+ * ```javascript
+ * let presence = new Presence(channel)
+ *
+ * // detect if user has joined for the 1st time or from another tab/device
+ * presence.onJoin((id, current, newPres) => {
+ *   if(!current){
+ *     console.log("user has entered for the first time", newPres)
+ *   } else {
+ *     console.log("user additional presence", newPres)
+ *   }
+ * })
+ *
+ * // detect if user has left from all tabs/devices, or is still present
+ * presence.onLeave((id, current, leftPres) => {
+ *   if(current.metas.length === 0){
+ *     console.log("user has left from all devices", leftPres)
+ *   } else {
+ *     console.log("user left from a device", leftPres)
+ *   }
+ * })
+ * // receive presence data from server
+ * presence.onSync(() => {
+ *   displayUsers(presence.list())
+ * })
+ * ```
+ * @module phoenix
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Socket = exports.Serializer = exports.Presence = exports.LongPoll = exports.Channel = void 0;
+const channel_1 = require("./channel");
+exports.Channel = channel_1.default;
+const longpoll_1 = require("./longpoll");
+exports.LongPoll = longpoll_1.default;
+const presence_1 = require("./presence");
+exports.Presence = presence_1.default;
+const serializer_1 = require("./serializer");
+exports.Serializer = serializer_1.default;
+const socket_1 = require("./socket");
+exports.Socket = socket_1.default;

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

@@ -0,0 +1,12 @@
+export default class LongPoll {
+    constructor(endPoint: any);
+    normalizeEndpoint(endPoint: any): any;
+    endpointURL(): any;
+    closeAndRetry(code: any, reason: any, wasClean: any): void;
+    ontimeout(): void;
+    isActive(): boolean;
+    poll(): void;
+    send(body: any): void;
+    close(code: any, reason: any, wasClean: any): void;
+    ajax(method: any, body: any, onCallerTimeout: any, callback: any): void;
+}

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const constants_1 = require("./constants");
+const ajax_1 = require("./ajax");
+class LongPoll {
+    constructor(endPoint) {
+        this.endPoint = null;
+        this.token = null;
+        this.skipHeartbeat = true;
+        this.reqs = new Set();
+        this.onopen = function () { }; // noop
+        this.onerror = function () { }; // noop
+        this.onmessage = function () { }; // noop
+        this.onclose = function () { }; // noop
+        this.pollEndpoint = this.normalizeEndpoint(endPoint);
+        this.readyState = constants_1.SOCKET_STATES.connecting;
+        this.poll();
+    }
+    normalizeEndpoint(endPoint) {
+        return (endPoint
+            .replace("ws://", "http://")
+            .replace("wss://", "https://")
+            .replace(new RegExp("(.*)\/" + constants_1.TRANSPORTS.websocket), "$1/" + constants_1.TRANSPORTS.longpoll));
+    }
+    endpointURL() {
+        return ajax_1.default.appendParams(this.pollEndpoint, { token: this.token });
+    }
+    closeAndRetry(code, reason, wasClean) {
+        this.close(code, reason, wasClean);
+        this.readyState = constants_1.SOCKET_STATES.connecting;
+    }
+    ontimeout() {
+        this.onerror("timeout");
+        this.closeAndRetry(1005, "timeout", false);
+    }
+    isActive() { return this.readyState === constants_1.SOCKET_STATES.open || this.readyState === constants_1.SOCKET_STATES.connecting; }
+    poll() {
+        this.ajax("GET", null, () => this.ontimeout(), resp => {
+            if (resp) {
+                var { status, token, messages } = resp;
+                this.token = token;
+            }
+            else {
+                status = 0;
+            }
+            switch (status) {
+                case 200:
+                    messages.forEach(msg => {
+                        // Tasks are what things like event handlers, setTimeout callbacks,
+                        // promise resolves and more are run within.
+                        // In modern browsers, there are two different kinds of tasks,
+                        // microtasks and macrotasks.
+                        // Microtasks are mainly used for Promises, while macrotasks are
+                        // used for everything else.
+                        // Microtasks always have priority over macrotasks. If the JS engine
+                        // is looking for a task to run, it will always try to empty the
+                        // microtask queue before attempting to run anything from the
+                        // macrotask queue.
+                        //
+                        // For the WebSocket transport, messages always arrive in their own
+                        // event. This means that if any promises are resolved from within,
+                        // their callbacks will always finish execution by the time the
+                        // next message event handler is run.
+                        //
+                        // In order to emulate this behaviour, we need to make sure each
+                        // onmessage handler is run within its own macrotask.
+                        setTimeout(() => this.onmessage({ data: msg }), 0);
+                    });
+                    this.poll();
+                    break;
+                case 204:
+                    this.poll();
+                    break;
+                case 410:
+                    this.readyState = constants_1.SOCKET_STATES.open;
+                    this.onopen({});
+                    this.poll();
+                    break;
+                case 403:
+                    this.onerror(403);
+                    this.close(1008, "forbidden", false);
+                    break;
+                case 0:
+                case 500:
+                    this.onerror(500);
+                    this.closeAndRetry(1011, "internal server error", 500);
+                    break;
+                default: throw new Error(`unhandled poll status ${status}`);
+            }
+        });
+    }
+    send(body) {
+        this.ajax("POST", body, () => this.onerror("timeout"), resp => {
+            if (!resp || resp.status !== 200) {
+                this.onerror(resp && resp.status);
+                this.closeAndRetry(1011, "internal server error", false);
+            }
+        });
+    }
+    close(code, reason, wasClean) {
+        for (let req of this.reqs) {
+            req.abort();
+        }
+        this.readyState = constants_1.SOCKET_STATES.closed;
+        let opts = Object.assign({ code: 1000, reason: undefined, wasClean: true }, { code, reason, wasClean });
+        if (typeof (CloseEvent) !== "undefined") {
+            this.onclose(new CloseEvent("close", opts));
+        }
+        else {
+            this.onclose(opts);
+        }
+    }
+    ajax(method, body, onCallerTimeout, callback) {
+        let req;
+        let ontimeout = () => {
+            this.reqs.delete(req);
+            onCallerTimeout();
+        };
+        req = ajax_1.default.request(method, this.endpointURL(), "application/json", body, this.timeout, ontimeout, resp => {
+            this.reqs.delete(req);
+            if (this.isActive()) {
+                callback(resp);
+            }
+        });
+        this.reqs.add(req);
+    }
+}
+exports.default = LongPoll;

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

@@ -0,0 +1,44 @@
+/**
+ * Initializes the Presence
+ * @param {Channel} channel - The Channel
+ * @param {Object} opts - The options,
+ *        for example `{events: {state: "state", diff: "diff"}}`
+ */
+export default class Presence {
+    constructor(channel: any, opts?: {});
+    onJoin(callback: any): void;
+    onLeave(callback: any): void;
+    onSync(callback: any): void;
+    list(by: any): any[];
+    inPendingSyncState(): boolean;
+    /**
+     * 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: any, newState: any, onJoin: any, onLeave: any): any;
+    /**
+     *
+     * 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: any, diff: any, onJoin: any, onLeave: any): any;
+    /**
+     * Returns the array of presences, with selected metadata.
+     *
+     * @param {Object} presences
+     * @param {Function} chooser
+     *
+     * @returns {Presence}
+     */
+    static list(presences: any, chooser: any): any[];
+    static map(obj: any, func: any): any[];
+    static clone(obj: any): any;
+}