@pythnetwork/pyth-lazer-sdk 4.0.0 → 5.2.0

package/dist/esm/protocol.d.ts

@@ -1,7 +1,7 @@
 export type Format = "evm" | "solana" | "leEcdsa" | "leUnsigned";
 export type DeliveryFormat = "json" | "binary";
 export type JsonBinaryEncoding = "base64" | "hex";
-export type PriceFeedProperty = "price" | "bestBidPrice" | "bestAskPrice" | "exponent" | "publisherCount" | "confidence";
+export type PriceFeedProperty = "price" | "bestBidPrice" | "bestAskPrice" | "exponent" | "publisherCount" | "confidence" | "fundingRate" | "fundingTimestamp" | "fundingRateInterval";
 export type Channel = "real_time" | "fixed_rate@50ms" | "fixed_rate@200ms";
 export type Request = {
     type: "subscribe";
@@ -122,3 +122,6 @@ export type JsonUpdate = {
     leEcdsa?: JsonBinaryData;
     leUnsigned?: JsonBinaryData;
 };
+export declare enum CustomSocketClosureCodes {
+    CLIENT_TIMEOUT_BUT_RECONNECTING = 4000
+}

package/dist/esm/protocol.mjs

@@ -0,0 +1,12 @@
+export const BINARY_UPDATE_FORMAT_MAGIC_LE = 461_928_307;
+export const FORMAT_MAGICS_LE = {
+    JSON: 3_302_625_434,
+    EVM: 2_593_727_018,
+    SOLANA: 2_182_742_457,
+    LE_ECDSA: 1_296_547_300,
+    LE_UNSIGNED: 1_499_680_012
+};
+export var CustomSocketClosureCodes = /*#__PURE__*/ function(CustomSocketClosureCodes) {
+    CustomSocketClosureCodes[CustomSocketClosureCodes["CLIENT_TIMEOUT_BUT_RECONNECTING"] = 4000] = "CLIENT_TIMEOUT_BUT_RECONNECTING";
+    return CustomSocketClosureCodes;
+}({});

package/dist/esm/socket/resilient-websocket.d.ts

@@ -10,6 +10,19 @@ export type ResilientWebSocketConfig = {
     maxRetryDelayMs?: number;
     logAfterRetryCount?: number;
 };
+/**
+ * the isomorphic-ws package ships with some slightly-erroneous typings.
+ * namely, it returns a WebSocket with typings that indicate the "terminate()" function
+ * is available on all platforms.
+ * Given that, under the hood, it is using the globalThis.WebSocket class, if it's available,
+ * and falling back to using the https://www.npmjs.com/package/ws package, this
+ * means there are API differences between the native WebSocket (the one in a web browser)
+ * and the server-side version from the "ws" package.
+ *
+ * This type creates a WebSocket type reference we use to indicate the unknown
+ * nature of the env in which is code is run.
+ */
+type UnsafeWebSocket = Omit<WebSocket, "terminate"> & Partial<Pick<WebSocket, "terminate">>;
 export declare class ResilientWebSocket {
     private endpoint;
     private wsOptions?;
@@ -17,7 +30,7 @@ export declare class ResilientWebSocket {
     private heartbeatTimeoutDurationMs;
     private maxRetryDelayMs;
     private logAfterRetryCount;
-    wsClient: undefined | WebSocket;
+    wsClient: UnsafeWebSocket | undefined;
     wsUserClosed: boolean;
     private wsFailedAttempts;
     private heartbeatTimeout?;
@@ -47,3 +60,4 @@ export declare class ResilientWebSocket {
      */
     private retryDelayMs;
 }
+export {};

package/dist/esm/socket/{resilient-websocket.js → resilient-websocket.mjs}

@@ -1,5 +1,7 @@
 import WebSocket from "isomorphic-ws";
 import { dummyLogger } from "ts-log";
+import { CustomSocketClosureCodes } from "../protocol.mjs";
+import { envIsBrowserOrWorker } from "../util/env-util.mjs";
 const DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS = 5000; // 5 seconds
 const DEFAULT_MAX_RETRY_DELAY_MS = 1000; // 1 second'
 const DEFAULT_LOG_AFTER_RETRY_COUNT = 10;
@@ -28,33 +30,29 @@ export class ResilientWebSocket {
     onError;
     onMessage;
     onReconnect;
-    constructor(config) {
+    constructor(config){
         this.endpoint = config.endpoint;
         this.wsOptions = config.wsOptions;
         this.logger = config.logger ?? dummyLogger;
-        this.heartbeatTimeoutDurationMs =
-            config.heartbeatTimeoutDurationMs ??
-                DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
+        this.heartbeatTimeoutDurationMs = config.heartbeatTimeoutDurationMs ?? DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
         this.maxRetryDelayMs = config.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-        this.logAfterRetryCount =
-            config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
+        this.logAfterRetryCount = config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
         this.wsFailedAttempts = 0;
-        this.onError = (error) => {
+        this.onError = (error)=>{
             void error;
         };
-        this.onMessage = (data) => {
+        this.onMessage = (data)=>{
             void data;
         };
-        this.onReconnect = () => {
-            // Empty function, can be set by the user.
+        this.onReconnect = ()=>{
+        // Empty function, can be set by the user.
         };
     }
     send(data) {
         this.logger.debug(`Sending message`);
         if (this.isConnected()) {
             this.wsClient.send(data);
-        }
-        else {
+        } else {
             this.logger.warn(`WebSocket to ${this.endpoint} is not connected. Cannot send message.`);
         }
     }
@@ -74,34 +72,36 @@ export class ResilientWebSocket {
             clearTimeout(this.retryTimeout);
             this.retryTimeout = undefined;
         }
-        this.wsClient = new WebSocket(this.endpoint, this.wsOptions);
-        this.wsClient.addEventListener("open", () => {
+        // browser constructor supports a different 2nd argument for the constructor,
+        // so we need to ensure it's not included if we're running in that environment:
+        // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/WebSocket#protocols
+        this.wsClient = new WebSocket(this.endpoint, envIsBrowserOrWorker() ? undefined : this.wsOptions);
+        this.wsClient.addEventListener("open", ()=>{
             this.logger.info("WebSocket connection established");
             this.wsFailedAttempts = 0;
             this._isReconnecting = false;
             this.resetHeartbeat();
             this.onReconnect();
         });
-        this.wsClient.addEventListener("close", (e) => {
+        this.wsClient.addEventListener("close", (e)=>{
             if (this.wsUserClosed) {
                 this.logger.info(`WebSocket connection to ${this.endpoint} closed by user`);
-            }
-            else {
+            } else {
                 if (this.shouldLogRetry()) {
                     this.logger.warn(`WebSocket connection to ${this.endpoint} closed unexpectedly: Code: ${e.code.toString()}`);
                 }
                 this.handleReconnect();
             }
         });
-        this.wsClient.addEventListener("error", (event) => {
+        this.wsClient.addEventListener("error", (event)=>{
             this.onError(event);
         });
-        this.wsClient.addEventListener("message", (event) => {
+        this.wsClient.addEventListener("message", (event)=>{
             this.resetHeartbeat();
             this.onMessage(event.data);
         });
         if ("on" in this.wsClient) {
-            this.wsClient.on("ping", () => {
+            this.wsClient.on("ping", ()=>{
                 this.logger.info("Ping received");
                 this.resetHeartbeat();
             });
@@ -111,9 +111,19 @@ export class ResilientWebSocket {
         if (this.heartbeatTimeout !== undefined) {
             clearTimeout(this.heartbeatTimeout);
         }
-        this.heartbeatTimeout = setTimeout(() => {
-            this.logger.warn("Connection timed out. Reconnecting...");
-            this.wsClient?.terminate();
+        this.heartbeatTimeout = setTimeout(()=>{
+            const warnMsg = "Connection timed out. Reconnecting...";
+            this.logger.warn(warnMsg);
+            if (this.wsClient) {
+                if (typeof this.wsClient.terminate === "function") {
+                    this.wsClient.terminate();
+                } else {
+                    // terminate is an implementation detail of the node-friendly
+                    // https://www.npmjs.com/package/ws package, but is not a native WebSocket API,
+                    // so we have to use the close method
+                    this.wsClient.close(CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
+                }
+            }
             this.handleReconnect();
         }, this.heartbeatTimeoutDurationMs);
     }
@@ -132,11 +142,9 @@ export class ResilientWebSocket {
         this.wsClient = undefined;
         this._isReconnecting = true;
         if (this.shouldLogRetry()) {
-            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " +
-                String(this.retryDelayMs()) +
-                "ms.");
+            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " + String(this.retryDelayMs()) + "ms.");
         }
-        this.retryTimeout = setTimeout(() => {
+        this.retryTimeout = setTimeout(()=>{
             this.startWebSocket();
         }, this.retryDelayMs());
     }
@@ -148,14 +156,13 @@ export class ResilientWebSocket {
         this.wsUserClosed = true;
     }
     /**
-     * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
-     *
-     * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
-     * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
-     *
-     * @returns The calculated delay in milliseconds before the next retry.
-     */
-    retryDelayMs() {
+   * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
+   *
+   * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
+   * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
+   *
+   * @returns The calculated delay in milliseconds before the next retry.
+   */ retryDelayMs() {
         if (this.wsFailedAttempts >= 10) {
             return this.maxRetryDelayMs;
         }

package/dist/esm/socket/websocket-pool.d.ts

@@ -4,6 +4,7 @@ import type { Logger } from "ts-log";
 import type { Request } from "../protocol.js";
 import type { ResilientWebSocketConfig } from "./resilient-websocket.js";
 import { ResilientWebSocket } from "./resilient-websocket.js";
+type WebSocketOnMessageCallback = (data: WebSocket.Data) => void | Promise<void>;
 export type WebSocketPoolConfig = {
     urls?: string[];
     numConnections?: number;
@@ -33,15 +34,16 @@ export declare class WebSocketPool {
      * Checks for error responses in JSON messages and throws appropriate errors
      */
     private handleErrorMessages;
+    private constructCacheKeyFromWebsocketData;
     /**
      * Handles incoming websocket messages by deduplicating identical messages received across
      * multiple connections before forwarding to registered handlers
      */
-    dedupeHandler: (data: WebSocket.Data) => void;
+    dedupeHandler: (data: WebSocket.Data) => Promise<void>;
     sendRequest(request: Request): void;
     addSubscription(request: Request): void;
     removeSubscription(subscriptionId: number): void;
-    addMessageListener(handler: (data: WebSocket.Data) => void): void;
+    addMessageListener(handler: WebSocketOnMessageCallback): void;
     /**
      * Calls the handler if all websocket connections are currently down or in reconnecting state.
      * The connections may still try to reconnect in the background.
@@ -52,3 +54,4 @@ export declare class WebSocketPool {
     private checkConnectionStates;
     shutdown(): void;
 }
+export {};

package/dist/esm/socket/{websocket-pool.js → websocket-pool.mjs}

@@ -1,74 +1,76 @@
 import TTLCache from "@isaacs/ttlcache";
-import WebSocket from "isomorphic-ws";
 import { dummyLogger } from "ts-log";
-import { ResilientWebSocket } from "./resilient-websocket.js";
-import { DEFAULT_STREAM_SERVICE_0_URL, DEFAULT_STREAM_SERVICE_1_URL, } from "../constants.js";
+import { ResilientWebSocket } from "./resilient-websocket.mjs";
+import { DEFAULT_STREAM_SERVICE_0_URL, DEFAULT_STREAM_SERVICE_1_URL } from "../constants.mjs";
+import { addAuthTokenToWebSocketUrl, bufferFromWebsocketData, envIsBrowserOrWorker } from "../util/index.mjs";
 const DEFAULT_NUM_CONNECTIONS = 4;
 export class WebSocketPool {
     logger;
     rwsPool;
     cache;
-    subscriptions; // id -> subscription Request
+    subscriptions;
     messageListeners;
     allConnectionsDownListeners;
     wasAllDown = true;
     checkConnectionStatesInterval;
-    constructor(logger) {
+    constructor(logger){
         this.logger = logger;
         this.rwsPool = [];
-        this.cache = new TTLCache({ ttl: 1000 * 10 }); // TTL of 10 seconds
+        this.cache = new TTLCache({
+            ttl: 1000 * 10
+        }); // TTL of 10 seconds
         this.subscriptions = new Map();
         this.messageListeners = [];
         this.allConnectionsDownListeners = [];
         // Start monitoring connection states
-        this.checkConnectionStatesInterval = setInterval(() => {
+        this.checkConnectionStatesInterval = setInterval(()=>{
             this.checkConnectionStates();
         }, 100);
     }
     /**
-     * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
-     * Usage semantics are similar to using a regular WebSocket client.
-     * @param urls - List of WebSocket URLs to connect to
-     * @param token - Authentication token to use for the connections
-     * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
-     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
-     */
-    static async create(config, token, logger) {
+   * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+   * Usage semantics are similar to using a regular WebSocket client.
+   * @param urls - List of WebSocket URLs to connect to
+   * @param token - Authentication token to use for the connections
+   * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
+   * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+   */ static async create(config, token, logger) {
         const urls = config.urls ?? [
             DEFAULT_STREAM_SERVICE_0_URL,
-            DEFAULT_STREAM_SERVICE_1_URL,
+            DEFAULT_STREAM_SERVICE_1_URL
         ];
         const log = logger ?? dummyLogger;
         const pool = new WebSocketPool(log);
         const numConnections = config.numConnections ?? DEFAULT_NUM_CONNECTIONS;
-        for (let i = 0; i < numConnections; i++) {
-            const url = urls[i % urls.length];
+        for(let i = 0; i < numConnections; i++){
+            const baseUrl = urls[i % urls.length];
+            const isBrowser = envIsBrowserOrWorker();
+            const url = isBrowser ? addAuthTokenToWebSocketUrl(baseUrl, token) : baseUrl;
             if (!url) {
                 throw new Error(`URLs must not be null or empty`);
             }
             const wsOptions = {
                 ...config.rwsConfig?.wsOptions,
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                },
+                headers: isBrowser ? undefined : {
+                    Authorization: `Bearer ${token}`
+                }
             };
             const rws = new ResilientWebSocket({
                 ...config.rwsConfig,
                 endpoint: url,
                 wsOptions,
-                logger: log,
+                logger: log
             });
             // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
             // the connection and call the onReconnect callback.
-            rws.onReconnect = () => {
+            rws.onReconnect = ()=>{
                 if (rws.wsUserClosed) {
                     return;
                 }
-                for (const [, request] of pool.subscriptions) {
+                for (const [, request] of pool.subscriptions){
                     try {
                         rws.send(JSON.stringify(request));
-                    }
-                    catch (error) {
+                    } catch (error) {
                         pool.logger.error("Failed to resend subscription on reconnect:", error);
                     }
                 }
@@ -77,37 +79,42 @@ export class WebSocketPool {
                 rws.onError = config.onError;
             }
             // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
-            rws.onMessage = pool.dedupeHandler;
+            rws.onMessage = (data)=>{
+                pool.dedupeHandler(data).catch((error)=>{
+                    const errMsg = `An error occurred in the WebSocket pool's dedupeHandler: ${error instanceof Error ? error.message : String(error)}`;
+                    throw new Error(errMsg);
+                });
+            };
             pool.rwsPool.push(rws);
             rws.startWebSocket();
         }
         pool.logger.info(`Started WebSocketPool with ${numConnections.toString()} connections. Waiting for at least one to connect...`);
-        while (!pool.isAnyConnectionEstablished()) {
-            await new Promise((resolve) => setTimeout(resolve, 100));
+        while(!pool.isAnyConnectionEstablished()){
+            await new Promise((resolve)=>setTimeout(resolve, 100));
         }
         pool.logger.info(`At least one WebSocket connection is established. WebSocketPool is ready.`);
         return pool;
     }
     /**
-     * Checks for error responses in JSON messages and throws appropriate errors
-     */
-    handleErrorMessages(data) {
+   * Checks for error responses in JSON messages and throws appropriate errors
+   */ handleErrorMessages(data) {
         const message = JSON.parse(data);
         if (message.type === "subscriptionError") {
             throw new Error(`Error occurred for subscription ID ${String(message.subscriptionId)}: ${message.error}`);
-        }
-        else if (message.type === "error") {
+        } else if (message.type === "error") {
             throw new Error(`Error: ${message.error}`);
         }
     }
+    async constructCacheKeyFromWebsocketData(data) {
+        if (typeof data === "string") return data;
+        const buff = await bufferFromWebsocketData(data);
+        return buff.toString("hex");
+    }
     /**
-     * Handles incoming websocket messages by deduplicating identical messages received across
-     * multiple connections before forwarding to registered handlers
-     */
-    dedupeHandler = (data) => {
-        const cacheKey = typeof data === "string"
-            ? data
-            : Buffer.from(data).toString("hex");
+   * Handles incoming websocket messages by deduplicating identical messages received across
+   * multiple connections before forwarding to registered handlers
+   */ dedupeHandler = async (data)=>{
+        const cacheKey = await this.constructCacheKeyFromWebsocketData(data);
         if (this.cache.has(cacheKey)) {
             this.logger.debug("Dropping duplicate message");
             return;
@@ -116,12 +123,10 @@ export class WebSocketPool {
         if (typeof data === "string") {
             this.handleErrorMessages(data);
         }
-        for (const handler of this.messageListeners) {
-            handler(data);
-        }
+        await Promise.all(this.messageListeners.map((handler)=>handler(data)));
     };
     sendRequest(request) {
-        for (const rws of this.rwsPool) {
+        for (const rws of this.rwsPool){
             rws.send(JSON.stringify(request));
         }
     }
@@ -136,7 +141,7 @@ export class WebSocketPool {
         this.subscriptions.delete(subscriptionId);
         const request = {
             type: "unsubscribe",
-            subscriptionId,
+            subscriptionId
         };
         this.sendRequest(request);
     }
@@ -144,17 +149,16 @@ export class WebSocketPool {
         this.messageListeners.push(handler);
     }
     /**
-     * Calls the handler if all websocket connections are currently down or in reconnecting state.
-     * The connections may still try to reconnect in the background.
-     */
-    addAllConnectionsDownListener(handler) {
+   * Calls the handler if all websocket connections are currently down or in reconnecting state.
+   * The connections may still try to reconnect in the background.
+   */ addAllConnectionsDownListener(handler) {
         this.allConnectionsDownListeners.push(handler);
     }
     areAllConnectionsDown() {
-        return this.rwsPool.every((ws) => !ws.isConnected() || ws.isReconnecting());
+        return this.rwsPool.every((ws)=>!ws.isConnected() || ws.isReconnecting());
     }
     isAnyConnectionEstablished() {
-        return this.rwsPool.some((ws) => ws.isConnected());
+        return this.rwsPool.some((ws)=>ws.isConnected());
     }
     checkConnectionStates() {
         const allDown = this.areAllConnectionsDown();
@@ -163,7 +167,7 @@ export class WebSocketPool {
             this.wasAllDown = true;
             this.logger.error("All WebSocket connections are down or reconnecting");
             // Notify all listeners
-            for (const listener of this.allConnectionsDownListeners) {
+            for (const listener of this.allConnectionsDownListeners){
                 listener();
             }
         }
@@ -173,7 +177,7 @@ export class WebSocketPool {
         }
     }
     shutdown() {
-        for (const rws of this.rwsPool) {
+        for (const rws of this.rwsPool){
             rws.closeWebSocket();
         }
         this.rwsPool = [];

package/dist/esm/util/buffer-util.d.ts

@@ -0,0 +1,7 @@
+import type { Data } from "isomorphic-ws";
+/**
+ * given a relatively unknown websocket frame data object,
+ * returns a valid Buffer instance that is safe to use
+ * isomorphically in any JS runtime environment
+ */
+export declare function bufferFromWebsocketData(data: Data): Promise<Buffer>;

package/dist/esm/util/buffer-util.mjs

@@ -0,0 +1,27 @@
+// the linting rules don't allow importing anything that might clash with
+// a global, top-level import. we disable this rule because we need this
+// imported from our installed dependency
+// eslint-disable-next-line unicorn/prefer-node-protocol
+import { Buffer as BrowserBuffer } from "buffer";
+const BufferClassToUse = "Buffer" in globalThis ? globalThis.Buffer : BrowserBuffer;
+/**
+ * given a relatively unknown websocket frame data object,
+ * returns a valid Buffer instance that is safe to use
+ * isomorphically in any JS runtime environment
+ */ export async function bufferFromWebsocketData(data) {
+    if (typeof data === "string") {
+        return BufferClassToUse.from(new TextEncoder().encode(data).buffer);
+    }
+    if (data instanceof BufferClassToUse) return data;
+    if (data instanceof Blob) {
+        // let the uncaught promise exception bubble up if there's an issue
+        return BufferClassToUse.from(await data.arrayBuffer());
+    }
+    if (data instanceof ArrayBuffer) return BufferClassToUse.from(data);
+    if (Array.isArray(data)) {
+        // an array of buffers is highly unlikely, but it is a possibility
+        // indicated by the WebSocket Data interface
+        return BufferClassToUse.concat(data);
+    }
+    return data;
+}

package/dist/esm/util/env-util.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Detects if this code is running within any Service or WebWorker context.
+ * @returns true if in a worker of some kind, false if otherwise
+ */
+export declare function envIsServiceOrWebWorker(): boolean;
+/**
+ * Detects if the code is running in a regular DOM or Web Worker context.
+ * @returns true if running in a DOM or Web Worker context, false if running in Node.js
+ */
+export declare function envIsBrowser(): boolean;
+/**
+ * a convenience method that returns whether or not
+ * this code is executing in some type of browser-centric environment
+ *
+ * @returns true if in the browser's main UI thread or in a worker, false if otherwise
+ */
+export declare function envIsBrowserOrWorker(): boolean;

package/dist/esm/util/env-util.mjs

@@ -0,0 +1,23 @@
+// we create this local-only type, which has assertions made to indicate
+// that we do not know and cannot guarantee which JS environment we are in
+const g = globalThis;
+/**
+ * Detects if this code is running within any Service or WebWorker context.
+ * @returns true if in a worker of some kind, false if otherwise
+ */ export function envIsServiceOrWebWorker() {
+    return typeof WorkerGlobalScope !== "undefined" && g.self instanceof WorkerGlobalScope;
+}
+/**
+ * Detects if the code is running in a regular DOM or Web Worker context.
+ * @returns true if running in a DOM or Web Worker context, false if running in Node.js
+ */ export function envIsBrowser() {
+    return g.window !== undefined;
+}
+/**
+ * a convenience method that returns whether or not
+ * this code is executing in some type of browser-centric environment
+ *
+ * @returns true if in the browser's main UI thread or in a worker, false if otherwise
+ */ export function envIsBrowserOrWorker() {
+    return envIsServiceOrWebWorker() || envIsBrowser();
+}

package/dist/esm/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./buffer-util.js";
+export * from "./env-util.js";
+export * from "./url-util.js";

package/dist/esm/util/index.mjs

@@ -0,0 +1,3 @@
+export * from "./buffer-util.mjs";
+export * from "./env-util.mjs";
+export * from "./url-util.mjs";

package/dist/esm/util/url-util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Given a URL to a hosted lazer stream service and a possible auth token,
+ * appends the auth token as a query parameter and returns the URL with the token
+ * contained within.
+ * If the URL provided is nullish, it is returned as-is (in the same nullish format).
+ * If the token is nullish, the baseUrl given is returned, instead.
+ */
+export declare function addAuthTokenToWebSocketUrl(baseUrl: string | null | undefined, authToken: string | null | undefined): string | null | undefined;

package/dist/esm/util/url-util.mjs

@@ -0,0 +1,13 @@
+const ACCESS_TOKEN_QUERY_PARAM_KEY = "ACCESS_TOKEN";
+/**
+ * Given a URL to a hosted lazer stream service and a possible auth token,
+ * appends the auth token as a query parameter and returns the URL with the token
+ * contained within.
+ * If the URL provided is nullish, it is returned as-is (in the same nullish format).
+ * If the token is nullish, the baseUrl given is returned, instead.
+ */ export function addAuthTokenToWebSocketUrl(baseUrl, authToken) {
+    if (!baseUrl || !authToken) return baseUrl;
+    const parsedUrl = new URL(baseUrl);
+    parsedUrl.searchParams.set(ACCESS_TOKEN_QUERY_PARAM_KEY, authToken);
+    return parsedUrl.toString();
+}