oorja 1.11.4 → 2.0.1

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

@@ -1,308 +0,0 @@
-// @ts-nocheck
-import { closure } from "./utils.js";
-import { CHANNEL_EVENTS, CHANNEL_STATES, } from "./constants.js";
-import Push from "./push.js";
-import Timer from "./timer.js";
-/**
- *
- * @param {string} topic
- * @param {(Object|function)} params
- * @param {Socket} socket
- */
-export default class Channel {
-    constructor(topic, params, socket) {
-        this.state = CHANNEL_STATES.closed;
-        this.topic = topic;
-        this.params = closure(params || {});
-        this.socket = socket;
-        this.bindings = [];
-        this.bindingRef = 0;
-        this.timeout = this.socket.timeout;
-        this.joinedOnce = false;
-        this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout);
-        this.pushBuffer = [];
-        this.stateChangeRefs = [];
-        this.rejoinTimer = new Timer(() => {
-            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 = CHANNEL_STATES.joined;
-            this.rejoinTimer.reset();
-            this.pushBuffer.forEach(pushEvent => pushEvent.send());
-            this.pushBuffer = [];
-        });
-        this.joinPush.receive("error", () => {
-            this.state = 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 = 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 = 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(this, CHANNEL_EVENTS.leave, closure({}), this.timeout);
-            leavePush.send();
-            this.state = CHANNEL_STATES.errored;
-            this.joinPush.reset();
-            if (this.socket.isConnected()) {
-                this.rejoinTimer.scheduleTimeout();
-            }
-        });
-        this.on(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(CHANNEL_EVENTS.close, callback);
-    }
-    /**
-     * Hook into channel errors
-     * @param {Function} callback
-     */
-    onError(callback) {
-        return this.on(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(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 = CHANNEL_STATES.leaving;
-        let onClose = () => {
-            if (this.socket.hasLogger())
-                this.socket.log("channel", `leave ${this.topic}`);
-            this.trigger(CHANNEL_EVENTS.close, "leave");
-        };
-        let leavePush = new Push(this, CHANNEL_EVENTS.leave, 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 = 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 === CHANNEL_STATES.closed; }
-    /**
-     * @private
-     */
-    isErrored() { return this.state === CHANNEL_STATES.errored; }
-    /**
-     * @private
-     */
-    isJoined() { return this.state === CHANNEL_STATES.joined; }
-    /**
-     * @private
-     */
-    isJoining() { return this.state === CHANNEL_STATES.joining; }
-    /**
-     * @private
-     */
-    isLeaving() { return this.state === CHANNEL_STATES.leaving; }
-}

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

@@ -1,33 +0,0 @@
-export declare const globalSelf: (Window & typeof globalThis) | null;
-export declare const phxWindow: (Window & typeof globalThis) | null;
-export declare const global: {};
-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/dist/lib/surya/vendor/phoenix/constants.js

@@ -1,29 +0,0 @@
-// @ts-nocheck
-export const globalSelf = typeof self !== "undefined" ? self : null;
-export const phxWindow = typeof window !== "undefined" ? window : null;
-export const global = globalSelf || phxWindow || {};
-export const DEFAULT_VSN = "2.0.0";
-export const SOCKET_STATES = { connecting: 0, open: 1, closing: 2, closed: 3 };
-export const DEFAULT_TIMEOUT = 10000;
-export const WS_CLOSE_NORMAL = 1000;
-export const CHANNEL_STATES = {
-    closed: "closed",
-    errored: "errored",
-    joined: "joined",
-    joining: "joining",
-    leaving: "leaving",
-};
-export const CHANNEL_EVENTS = {
-    close: "phx_close",
-    error: "phx_error",
-    join: "phx_join",
-    reply: "phx_reply",
-    leave: "phx_leave"
-};
-export const TRANSPORTS = {
-    longpoll: "longpoll",
-    websocket: "websocket"
-};
-export const XHR_STATES = {
-    complete: 4
-};

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

@@ -1,199 +0,0 @@
-/**
- * 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.js";
-import LongPoll from "./longpoll.js";
-import Presence from "./presence.js";
-import Serializer from "./serializer.js";
-import Socket from "./socket.js";
-export { Channel, LongPoll, Presence, Serializer, Socket };