@eventmodelers/node-kit 0.0.2

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/push.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @import Channel from "./channel"
+ * @import { ChannelEvent } from "./types"
+ */
+export default class Push {
+    /**
+     * Initializes the Push
+     * @param {Channel} channel - The Channel
+     * @param {ChannelEvent} event - The event, for example `"phx_join"`
+     * @param {() => Record<string, unknown>} payload - The payload, for example `{user_id: 123}`
+     * @param {number} timeout - The push timeout in milliseconds
+     */
+    constructor(channel: Channel, event: ChannelEvent, payload: () => Record<string, unknown>, timeout: number);
+    /** @type{Channel} */
+    channel: Channel;
+    /** @type{ChannelEvent} */
+    event: ChannelEvent;
+    /** @type{() => Record<string, unknown>} */
+    payload: () => Record<string, unknown>;
+    receivedResp: unknown;
+    /** @type{number} */
+    timeout: number;
+    /** @type{(ReturnType<typeof setTimeout>) | null} */
+    timeoutTimer: (ReturnType<typeof setTimeout>) | null;
+    /** @type{{status: string; callback: (response: any) => void}[]} */
+    recHooks: {
+        status: string;
+        callback: (response: any) => void;
+    }[];
+    /** @type{boolean} */
+    sent: boolean;
+    /** @type{string | null | undefined} */
+    ref: string | null | undefined;
+    /**
+     *
+     * @param {number} timeout
+     */
+    resend(timeout: number): void;
+    /**
+     *
+     */
+    send(): void;
+    /**
+     *
+     * @param {string} status
+     * @param {(response: any) => void} callback
+     */
+    receive(status: string, callback: (response: any) => void): this;
+    reset(): void;
+    refEvent: string | null | undefined;
+    destroy(): void;
+    /**
+     * @private
+     */
+    private matchReceive;
+    /**
+     * @private
+     */
+    private cancelRefEvent;
+    cancelTimeout(): void;
+    startTimeout(): void;
+    /**
+     * @private
+     */
+    private hasReceived;
+    trigger(status: any, response: any): void;
+}
+import type Channel from "./channel";
+import type { ChannelEvent } from "./types";
+//# sourceMappingURL=push.d.ts.map

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../assets/js/phoenix/push.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IACE;;;;;;OAMG;IACH,qBALW,OAAO,SACP,YAAY,WACZ,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAC7B,MAAM,EAoBhB;IAjBC,qBAAqB;IACrB,SADU,OAAO,CACK;IACtB,0BAA0B;IAC1B,OADU,YAAY,CACJ;IAClB,2CAA2C;IAC3C,SADU,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACW;IAClD,sBAAwB;IACxB,oBAAoB;IACpB,SADU,MAAM,CACM;IACtB,oDAAoD;IACpD,cADU,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,GAAG,IAAI,CACxB;IACxB,mEAAmE;IACnE,UADU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,CAAA;KAAC,EAAE,CAC7C;IAClB,qBAAqB;IACrB,MADU,OAAO,CACA;IACjB,uCAAuC;IACvC,KADU,MAAM,GAAG,IAAI,GAAG,SAAS,CACf;IAGtB;;;OAGG;IACH,gBAFW,MAAM,QAMhB;IAED;;OAEG;IACH,aAWC;IAED;;;;OAIG;IACH,gBAHW,MAAM,YACN,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,QASjC;IAED,cAMC;IAHC,oCAAoB;IAKtB,gBAGC;IAED;;OAEG;IACH,qBAGC;IAED;;OAEG;IACH,uBAGC;IAED,sBAGC;IAED,qBAeC;IAED;;OAEG;IACH,oBAEC;IAED,0CAEC;CACF;yBApIuB,WAAW;kCACF,SAAS"}

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/serializer.d.ts

@@ -0,0 +1,74 @@
+declare namespace _default {
+    let HEADER_LENGTH: number;
+    let META_LENGTH: number;
+    namespace KINDS {
+        let push: number;
+        let reply: number;
+        let broadcast: number;
+    }
+    /**
+    * @template T
+    * @param {Message<Record<string, any>>} msg
+    * @param {(msg: ArrayBuffer | string) => T} callback
+    * @returns {T}
+    */
+    function encode<T>(msg: Message<Record<string, any>>, callback: (msg: ArrayBuffer | string) => T): T;
+    /**
+    * @template T
+    * @param {ArrayBuffer | string} rawPayload
+    * @param {(msg: Message<unknown>) => T} callback
+    * @returns {T}
+    */
+    function decode<T>(rawPayload: ArrayBuffer | string, callback: (msg: Message<unknown>) => T): T;
+    /** @private */
+    function binaryEncode(message: any): any;
+    /**
+    * @private
+    */
+    function binaryDecode(buffer: any): {
+        join_ref: any;
+        ref: null;
+        topic: any;
+        event: any;
+        payload: any;
+    } | {
+        join_ref: any;
+        ref: any;
+        topic: any;
+        event: "phx_reply";
+        payload: {
+            status: any;
+            response: any;
+        };
+    } | undefined;
+    /** @private */
+    function decodePush(buffer: any, view: any, decoder: any): {
+        join_ref: any;
+        ref: null;
+        topic: any;
+        event: any;
+        payload: any;
+    };
+    /** @private */
+    function decodeReply(buffer: any, view: any, decoder: any): {
+        join_ref: any;
+        ref: any;
+        topic: any;
+        event: "phx_reply";
+        payload: {
+            status: any;
+            response: any;
+        };
+    };
+    /** @private */
+    function decodeBroadcast(buffer: any, view: any, decoder: any): {
+        join_ref: null;
+        ref: null;
+        topic: any;
+        event: any;
+        payload: any;
+    };
+}
+export default _default;
+import type { Message } from "./types";
+//# sourceMappingURL=serializer.d.ts.map

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../assets/js/phoenix/serializer.js"],"names":[],"mappings":";;;;;;;;IAcE;;;;;MAKE;IACF,gBALY,CAAC,OACH,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,YAC5B,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,KAAK,CAAC,GAC9B,CAAC,CASZ;IAED;;;;;MAKE;IACF,gBALY,CAAC,cACH,WAAW,GAAG,MAAM,YACpB,CAAC,GAAG,EAAE,QAAQ,OAAO,CAAC,KAAK,CAAC,GAC1B,CAAC,CASZ;IAED,eAAe;IACf,yCAsBC;IAED;;MAEE;IACF;;;;;;;;;;;;;;;kBASC;IAED,eAAe;IACf;;;;;;MAaC;IAED,eAAe;IACf;;;;;;;;;MAiBC;IAED,eAAe;IACf;;;;;;MAWC;;;6BA7HyB,SAAS"}

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/socket.d.ts

@@ -0,0 +1,291 @@
+/**
+* @import { Encode, Decode, Message, Vsn, SocketTransport, Params, SocketOnOpen, SocketOnClose, SocketOnError, SocketOnMessage, SocketOptions, SocketStateChangeCallbacks, HeartbeatCallback } from "./types"
+*/
+export default class Socket {
+    /** Initializes the Socket *
+     *
+     * For IE8 support use an ES5-shim (https://github.com/es-shims/es5-shim)
+     *
+     * @constructor
+     * @param {string} endPoint - The string WebSocket endpoint, ie, `"ws://example.com/socket"`,
+     *                                               `"wss://example.com"`
+     *                                               `"/socket"` (inherited host & protocol)
+     * @param {SocketOptions} [opts] - Optional configuration
+     */
+    constructor(endPoint: string, opts?: SocketOptions);
+    /** @type{SocketStateChangeCallbacks} */
+    stateChangeCallbacks: SocketStateChangeCallbacks;
+    /** @type{Channel[]} */
+    channels: Channel[];
+    /** @type{(() => void)[]} */
+    sendBuffer: (() => void)[];
+    /** @type{number} */
+    ref: number;
+    /** @type{?string} */
+    fallbackRef: string | null;
+    /** @type{number} */
+    timeout: number;
+    /** @type{SocketTransport} */
+    transport: SocketTransport;
+    /** @type{InstanceType<SocketTransport> | undefined | null} */
+    conn: InstanceType<SocketTransport> | undefined | null;
+    /** @type{boolean} */
+    primaryPassedHealthCheck: boolean;
+    /** @type{number | undefined} */
+    longPollFallbackMs: number | undefined;
+    /** @type{ReturnType<typeof setTimeout>} */
+    fallbackTimer: ReturnType<typeof setTimeout>;
+    /** @type{Storage} */
+    sessionStore: Storage;
+    /** @type{number} */
+    establishedConnections: number;
+    /** @type{Encode<void>} */
+    defaultEncoder: Encode<void>;
+    /** @type{Decode<void>} */
+    defaultDecoder: Decode<void>;
+    /** @type{boolean} */
+    closeWasClean: boolean;
+    /** @type{boolean} */
+    disconnecting: boolean;
+    /** @type{BinaryType} */
+    binaryType: BinaryType;
+    /** @type{number} */
+    connectClock: number;
+    /** @type{boolean} */
+    pageHidden: boolean;
+    /** @type{Encode<void>} */
+    encode: Encode<void>;
+    /** @type{Decode<void>} */
+    decode: Decode<void>;
+    /** @type{number} */
+    heartbeatIntervalMs: number;
+    /** @type{boolean} */
+    autoSendHeartbeat: boolean;
+    /** @type{HeartbeatCallback} */
+    heartbeatCallback: HeartbeatCallback;
+    /** @type{(tries: number) => number} */
+    rejoinAfterMs: (tries: number) => number;
+    /** @type{(tries: number) => number} */
+    reconnectAfterMs: (tries: number) => number;
+    /** @type{((kind: string, msg: string, data: any) => void) | null} */
+    logger: ((kind: string, msg: string, data: any) => void) | null;
+    /** @type{number} */
+    longpollerTimeout: number;
+    /** @type{() => Params} */
+    params: () => Params;
+    /** @type{string} */
+    endPoint: string;
+    /** @type{Vsn} */
+    vsn: Vsn;
+    /** @type{ReturnType<typeof setTimeout>} */
+    heartbeatTimeoutTimer: ReturnType<typeof setTimeout>;
+    /** @type{ReturnType<typeof setTimeout>} */
+    heartbeatTimer: ReturnType<typeof setTimeout>;
+    /** @type{number | null} */
+    heartbeatSentAt: number | null;
+    /** @type{?string} */
+    pendingHeartbeatRef: string | null;
+    /** @type{Timer} */
+    reconnectTimer: Timer;
+    /** @type{string | undefined} */
+    authToken: string | undefined;
+    /**
+     * Returns the LongPoll transport reference
+     */
+    getLongPollTransport(): typeof LongPoll;
+    /**
+     * Disconnects and replaces the active transport
+     *
+     * @param {SocketTransport} newTransport - The new transport class to instantiate
+     *
+     */
+    replaceTransport(newTransport: SocketTransport): void;
+    /**
+     * Returns the socket protocol
+     *
+     * @returns {"wss" | "ws"}
+     */
+    protocol(): "wss" | "ws";
+    /**
+     * The fully qualified socket url
+     *
+     * @returns {string}
+     */
+    endPointURL(): string;
+    /**
+     * Disconnects the socket
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes.
+     *
+     * @param {() => void} [callback] - Optional callback which is called after socket is disconnected.
+     * @param {number} [code] - A status code for disconnection (Optional).
+     * @param {string} [reason] - A textual description of the reason to disconnect. (Optional)
+     */
+    disconnect(callback?: () => void, code?: number, reason?: string): void;
+    /**
+     * @param {Params} [params] - [DEPRECATED] 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?: Params): void;
+    /**
+     * Logs the message. Override `this.logger` for specialized logging. noops by default
+     * @param {string} kind
+     * @param {string} msg
+     * @param {Object} data
+     */
+    log(kind: string, msg: string, data: Object): void;
+    /**
+     * Returns true if a logger has been set on this socket.
+     */
+    hasLogger(): boolean;
+    /**
+     * Registers callbacks for connection open events
+     *
+     * @example socket.onOpen(function(){ console.info("the socket was opened") })
+     *
+     * @param {SocketOnOpen} callback
+     */
+    onOpen(callback: SocketOnOpen): string;
+    /**
+     * Registers callbacks for connection close events
+     * @param {SocketOnClose} callback
+     * @returns {string}
+     */
+    onClose(callback: SocketOnClose): string;
+    /**
+     * Registers callbacks for connection error events
+     *
+     * @example socket.onError(function(error){ alert("An error occurred") })
+     *
+     * @param {SocketOnError} callback
+     * @returns {string}
+     */
+    onError(callback: SocketOnError): string;
+    /**
+     * Registers callbacks for connection message events
+     * @param {SocketOnMessage} callback
+     * @returns {string}
+     */
+    onMessage(callback: SocketOnMessage): string;
+    /**
+     * Sets a callback that receives lifecycle events for internal heartbeat messages.
+     * Useful for instrumenting connection health (e.g. sent/ok/timeout/disconnected).
+     * @param {HeartbeatCallback} callback
+     */
+    onHeartbeat(callback: HeartbeatCallback): void;
+    /**
+     * Pings the server and invokes the callback with the RTT in milliseconds
+     * @param {(timeDelta: number) => void} callback
+     *
+     * Returns true if the ping was pushed or false if unable to be pushed.
+     */
+    ping(callback: (timeDelta: number) => void): boolean;
+    /**
+     * @private
+     *
+     * @param {Function}
+     */
+    private transportName;
+    /**
+     * @private
+     */
+    private transportConnect;
+    getSession(key: any): string | null;
+    storeSession(key: any, val: any): void;
+    connectWithFallback(fallbackTransport: any, fallbackThreshold?: number): void;
+    clearHeartbeats(): void;
+    onConnOpen(): void;
+    /**
+     * @private
+     */
+    private heartbeatTimeout;
+    resetHeartbeat(): void;
+    teardown(callback: any, code: any, reason: any): any;
+    waitForBufferDone(conn: any, callback: any, tries?: number): void;
+    waitForSocketClosed(conn: any, callback: any, tries?: number): void;
+    /**
+    * @param {CloseEvent} event
+    */
+    onConnClose(event: CloseEvent): void;
+    /**
+     * @private
+     * @param {Event} error
+     */
+    private onConnError;
+    /**
+     * @private
+     * @param {unknown} [reason] underlying close/error event forwarded to channel error listeners
+     */
+    private triggerChanError;
+    /**
+     * @returns {string}
+     */
+    connectionState(): string;
+    /**
+     * @returns {boolean}
+     */
+    isConnected(): boolean;
+    /**
+     *
+     * @param {Channel} channel
+     */
+    remove(channel: Channel): void;
+    /**
+     * Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations.
+     *
+     * @param {string[]} refs - list of refs returned by calls to
+     *                 `onOpen`, `onClose`, `onError,` and `onMessage`
+     */
+    off(refs: string[]): void;
+    /**
+     * Initiates a new channel for the given topic
+     *
+     * @param {string} topic
+     * @param {Params | (() => Params)} [chanParams]- Parameters for the channel
+     * @returns {Channel}
+     */
+    channel(topic: string, chanParams?: Params | (() => Params)): Channel;
+    /**
+     * @param {Message<Record<string, any>>} data
+     */
+    push(data: Message<Record<string, any>>): void;
+    /**
+     * Return the next message ref, accounting for overflows
+     * @returns {string}
+     */
+    makeRef(): string;
+    sendHeartbeat(): void;
+    flushSendBuffer(): void;
+    /**
+    * @param {MessageEvent<any>} rawMessage
+    */
+    onConnMessage(rawMessage: MessageEvent<any>): void;
+    /**
+     * @private
+     * @template {keyof SocketStateChangeCallbacks} K
+     * @param {K} event
+     * @param {...Parameters<SocketStateChangeCallbacks[K][number][1]>} args
+     * @returns {void}
+     */
+    private triggerStateCallbacks;
+    leaveOpenTopic(topic: any): void;
+}
+import type { SocketStateChangeCallbacks } from "./types";
+import Channel from "./channel";
+import type { SocketTransport } from "./types";
+import type { Encode } from "./types";
+import type { Decode } from "./types";
+import type { HeartbeatCallback } from "./types";
+import type { Params } from "./types";
+import type { Vsn } from "./types";
+import Timer from "./timer";
+import LongPoll from "./longpoll";
+import type { SocketOnOpen } from "./types";
+import type { SocketOnClose } from "./types";
+import type { SocketOnError } from "./types";
+import type { SocketOnMessage } from "./types";
+import type { Message } from "./types";
+import type { SocketOptions } from "./types";
+//# sourceMappingURL=socket.d.ts.map

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../../assets/js/phoenix/socket.js"],"names":[],"mappings":"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"}

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/timer.d.ts

@@ -0,0 +1,36 @@
+/**
+ *
+ * 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
+ *
+ */
+export default class Timer {
+    /**
+    * @param {() => void} callback
+    * @param {(tries: number) => number} timerCalc
+    */
+    constructor(callback: () => void, timerCalc: (tries: number) => number);
+    /** @type {() => void} */
+    callback: () => void;
+    /** @type {(tries: number) => number} */
+    timerCalc: (tries: number) => number;
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    timer: ReturnType<typeof setTimeout> | undefined;
+    /** @type {number} */
+    tries: number;
+    reset(): void;
+    /**
+     * Cancels any previous scheduleTimeout and schedules callback
+     */
+    scheduleTimeout(): void;
+}
+//# sourceMappingURL=timer.d.ts.map

package/templates/realtime-agent/node_modules/@supabase/phoenix/priv/static/types/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../../assets/js/phoenix/timer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH;IACE;;;MAGE;IACF,sBAHU,MAAM,IAAI,aACV,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAWlC;IARC,yBAAyB;IACzB,UADW,MAAM,IAAI,CACG;IACxB,wCAAwC;IACxC,WADW,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CACV;IAC1B,wDAAwD;IACxD,OADW,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CAC9B;IACtB,qBAAqB;IACrB,OADW,MAAM,CACH;IAGhB,cAGC;IAED;;OAEG;IACH,wBAOC;CACF"}