@arcblock/ws 1.28.8 → 1.29.0

package/esm/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require };

package/esm/browser.d.mts

@@ -0,0 +1,2 @@
+import _default from "./client/browser.mjs";
+export { _default as WsClient };

package/esm/browser.mjs

@@ -0,0 +1,3 @@
+import browser_default from "./client/browser.mjs";
+
+export { browser_default as WsClient };

package/esm/client/base.d.mts

@@ -0,0 +1,80 @@
+import _default$1 from "../logger.mjs";
+
+//#region src/client/base.d.ts
+interface SocketConstructor {
+  new (endpoint: string, opts: object): SocketInstance;
+}
+interface SocketInstance {
+  channels: Channel[];
+  connect(): void;
+  disconnect(callback?: () => void, code?: number, reason?: string): void;
+  isConnected(): boolean;
+  onOpen(cb: () => void): void;
+  onClose(cb: () => void): void;
+  onError(cb: (err: {
+    error: Error;
+  }) => void): void;
+  onMessage(cb: (message: unknown) => void): void;
+  channel(topic: string, params?: object | (() => object)): Channel;
+  remove(channel: Channel): void;
+}
+interface Channel {
+  topic: string;
+  join(): ChannelPush;
+  leave(): ChannelPush;
+  on(event: string, callback: (data: {
+    status: string;
+    response: unknown;
+  }) => void): void;
+  off(event: string): void;
+}
+interface ChannelPush {
+  receive(status: string, callback: (data: unknown) => void): ChannelPush;
+}
+interface EventEmitterConstructor {
+  new (): EventEmitterInstance;
+}
+interface EventEmitterInstance {
+  on(event: string, handler: (data: unknown) => void): void;
+  off(event: string, handler?: (data: unknown) => void): void;
+  emit(event: string, data: unknown): void;
+  removeAllListeners(event: string): void;
+  listenerCount(event: string): number;
+  eventNames(): (string | symbol)[];
+}
+interface WsClientOptions {
+  silent?: boolean;
+  [key: string]: unknown;
+}
+declare const _default: (Socket: SocketConstructor, EventEmitter: EventEmitterConstructor, transport?: unknown) => {
+  new (endpoint: string, opts?: WsClientOptions): {
+    _logger: ReturnType<typeof _default$1>;
+    emitter: EventEmitterInstance;
+    on(event: string, handler: (data: unknown) => void, params?: object): void;
+    off(event: string, handler?: (data: unknown) => void): void;
+    disconnect(callback?: () => void, code?: number, reason?: string): void;
+    /**
+     * private
+     */
+    ensureJoinChannel(topic: string, params?: object): void;
+    /**
+     * private
+     */
+    ensureLeaveChannel(topic: string): void;
+    subscribe(topic: string, params?: object): Channel;
+    unsubscribe(topic: string): void;
+    channels: Channel[];
+    connect(): void;
+    isConnected(): boolean;
+    onOpen(cb: () => void): void;
+    onClose(cb: () => void): void;
+    onError(cb: (err: {
+      error: Error;
+    }) => void): void;
+    onMessage(cb: (message: unknown) => void): void;
+    channel(topic: string, params?: object | (() => object)): Channel;
+    remove(channel: Channel): void;
+  };
+};
+//#endregion
+export { Channel, ChannelPush, EventEmitterConstructor, EventEmitterInstance, SocketConstructor, SocketInstance, WsClientOptions, _default as default };

package/esm/client/base.mjs

@@ -0,0 +1,118 @@
+import logger_default from "../logger.mjs";
+
+//#region src/client/base.ts
+var base_default = (Socket, EventEmitter, transport) => {
+	return class WsClient extends Socket {
+		constructor(endpoint, opts = {}) {
+			super(endpoint, {
+				transport,
+				...opts
+			});
+			this._logger = logger_default("client", opts.silent);
+			this.emitter = new EventEmitter();
+			this.onOpen(() => {
+				this._logger.debug("socket open", endpoint);
+			});
+			this.onClose(() => {
+				this._logger.debug("socket close", endpoint);
+			});
+			this.onError((err) => {
+				this._logger.error("socket error", err.error);
+			});
+			this.onMessage((message) => {
+				this._logger.debug("socket message", message);
+			});
+		}
+		on(event, handler, params = {}) {
+			this.ensureJoinChannel(event, params);
+			this.emitter.on(event, handler);
+		}
+		off(event, handler) {
+			if (handler) this.emitter.off(event, handler);
+			else this.emitter.removeAllListeners(event);
+			this.ensureLeaveChannel(event);
+		}
+		disconnect(callback, code, reason) {
+			this.emitter.eventNames().forEach((event) => {
+				this.emitter.removeAllListeners(event);
+			});
+			super.disconnect(callback, code, reason);
+		}
+		/**
+		* private
+		*/
+		ensureJoinChannel(topic, params = {}) {
+			if (this.emitter.listenerCount(topic) > 0) return;
+			const channel = this.channel(topic, params);
+			channel.join().receive("ok", (message) => {
+				this._logger.debug("join success", {
+					topic,
+					message
+				});
+			}).receive("error", (error) => {
+				this._logger.error("join error", {
+					topic,
+					error
+				});
+			}).receive("timeout", () => {
+				this._logger.debug("join timeout", { topic });
+			});
+			channel.on(topic, ({ status, response: data }) => {
+				if (status === "ok") this.emitter.emit(topic, data);
+				else this._logger.debug("response error", {
+					topic,
+					status,
+					data
+				});
+			});
+		}
+		/**
+		* private
+		*/
+		ensureLeaveChannel(topic) {
+			if (this.emitter.listenerCount(topic) > 0) return;
+			const channel = this.channels.find((c) => c.topic === topic);
+			if (!channel) return;
+			this.remove(channel);
+			channel.leave().receive("ok", (message) => {
+				this._logger.debug("leave success", {
+					topic,
+					message
+				});
+			}).receive("error", (err) => {
+				this._logger.error("leave error", {
+					topic,
+					err
+				});
+			}).receive("timeout", () => {
+				this._logger.debug("leave timeout", { topic });
+			});
+			channel.off(topic);
+		}
+		subscribe(topic, params = {}) {
+			let channel = this.channels.find((c) => c.topic === topic);
+			if (channel) return channel;
+			channel = this.channel(topic, params);
+			channel.join().receive("ok", (message) => {
+				this._logger.debug("join success", {
+					topic,
+					message
+				});
+			}).receive("error", (error) => {
+				this._logger.error("join error", {
+					topic,
+					error
+				});
+			}).receive("timeout", () => {
+				this._logger.debug("join timeout", { topic });
+			});
+			return channel;
+		}
+		unsubscribe(topic) {
+			this.ensureLeaveChannel(topic);
+		}
+	};
+};
+
+//#endregion
+export { base_default as default };

package/esm/client/browser.d.mts

@@ -0,0 +1,30 @@
+import _default$1 from "../logger.mjs";
+import { Channel, EventEmitterInstance, WsClientOptions } from "./base.mjs";
+
+//#region src/client/browser.d.ts
+declare const _default: {
+  new (endpoint: string, opts?: WsClientOptions): {
+    _logger: ReturnType<typeof _default$1>;
+    emitter: EventEmitterInstance;
+    on(event: string, handler: (data: unknown) => void, params?: object): void;
+    off(event: string, handler?: (data: unknown) => void): void;
+    disconnect(callback?: () => void, code?: number, reason?: string): void;
+    ensureJoinChannel(topic: string, params?: object): void;
+    ensureLeaveChannel(topic: string): void;
+    subscribe(topic: string, params?: object): Channel;
+    unsubscribe(topic: string): void;
+    channels: Channel[];
+    connect(): void;
+    isConnected(): boolean;
+    onOpen(cb: () => void): void;
+    onClose(cb: () => void): void;
+    onError(cb: (err: {
+      error: Error;
+    }) => void): void;
+    onMessage(cb: (message: unknown) => void): void;
+    channel(topic: string, params?: object | (() => object)): Channel;
+    remove(channel: Channel): void;
+  };
+};
+//#endregion
+export { _default as default };

package/esm/client/browser.mjs

@@ -0,0 +1,9 @@
+import base_default from "./base.mjs";
+import EventEmitter from "eventemitter3";
+import { Socket } from "phoenix";
+
+//#region src/client/browser.ts
+var browser_default = base_default(Socket, EventEmitter);
+
+//#endregion
+export { browser_default as default };

package/esm/client/index.d.mts

@@ -0,0 +1,30 @@
+import _default$1 from "../logger.mjs";
+import { Channel, EventEmitterInstance, WsClientOptions } from "./base.mjs";
+
+//#region src/client/index.d.ts
+declare const _default: {
+  new (endpoint: string, opts?: WsClientOptions): {
+    _logger: ReturnType<typeof _default$1>;
+    emitter: EventEmitterInstance;
+    on(event: string, handler: (data: unknown) => void, params?: object): void;
+    off(event: string, handler?: (data: unknown) => void): void;
+    disconnect(callback?: () => void, code?: number, reason?: string): void;
+    ensureJoinChannel(topic: string, params?: object): void;
+    ensureLeaveChannel(topic: string): void;
+    subscribe(topic: string, params?: object): Channel;
+    unsubscribe(topic: string): void;
+    channels: Channel[];
+    connect(): void;
+    isConnected(): boolean;
+    onOpen(cb: () => void): void;
+    onClose(cb: () => void): void;
+    onError(cb: (err: {
+      error: Error;
+    }) => void): void;
+    onMessage(cb: (message: unknown) => void): void;
+    channel(topic: string, params?: object | (() => object)): Channel;
+    remove(channel: Channel): void;
+  };
+};
+//#endregion
+export { _default as default };

package/esm/client/index.mjs

@@ -0,0 +1,10 @@
+import base_default from "./base.mjs";
+import { Socket } from "phoenix";
+import EventEmitter from "node:events";
+import WebSocket from "ws";
+
+//#region src/client/index.ts
+var client_default = base_default(Socket, EventEmitter, WebSocket);
+
+//#endregion
+export { client_default as default };

package/esm/index.d.mts

@@ -0,0 +1,3 @@
+import _default from "./client/index.mjs";
+import WsServer from "./server/index.mjs";
+export { _default as WsClient, WsServer };

package/esm/index.mjs

@@ -0,0 +1,4 @@
+import client_default from "./client/index.mjs";
+import server_default from "./server/index.mjs";
+
+export { client_default as WsClient, server_default as WsServer };

package/esm/logger.d.mts

@@ -0,0 +1,13 @@
+import debug from "debug";
+
+//#region src/logger.d.ts
+interface Logger {
+  debug: debug.Debugger | ((...args: unknown[]) => void);
+  warn?: debug.Debugger | ((...args: unknown[]) => void);
+  info: debug.Debugger | ((...args: unknown[]) => void);
+  trace?: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+}
+declare const _default: (subModule: string, silent?: boolean) => Logger;
+//#endregion
+export { Logger, _default as default };

package/esm/logger.mjs

@@ -0,0 +1,16 @@
+import debug from "debug";
+
+//#region src/logger.ts
+var logger_default = (subModule, silent = false) => {
+	const d = debug(["@arcblock/ws", subModule].join(":"));
+	return {
+		debug: d,
+		warn: d,
+		info: d,
+		trace: silent ? d : console.error,
+		error: silent ? d : console.error
+	};
+};
+
+//#endregion
+export { logger_default as default };

package/esm/server/index.d.mts

@@ -0,0 +1,138 @@
+import { Logger } from "../logger.mjs";
+import EventEmitter from "node:events";
+import WebSocket, { WebSocketServer } from "ws";
+import http from "node:http";
+import { Duplex } from "node:stream";
+
+//#region src/server/index.d.ts
+interface WsSocket extends WebSocket {
+  id: string;
+  channel: Record<string, {
+    authInfo?: unknown;
+  }>;
+  heartbeatAt: number;
+  authInfo?: unknown;
+}
+interface HookParams {
+  socket: WsSocket;
+  joinRef: string;
+  ref: string;
+  topic: string;
+  event: string;
+  payload: unknown;
+}
+interface Hooks {
+  authenticateJoinChannel: (params: any) => unknown;
+  preJoinChannel: (params: any) => void | Promise<void>;
+  postJoinChannel: (params: any) => void | Promise<void>;
+  preLeaveChannel: (params: any) => void | Promise<void>;
+  postLeaveChannel: (params: any) => void | Promise<void>;
+  postBroadcast: (opts: BroadcastResult) => void | Promise<void>;
+  postSend: (opts: SendOptions) => void | Promise<void>;
+  receiveMessage: (params: any) => void | Promise<void>;
+}
+interface WsServerOptions {
+  pathname?: string;
+  authenticate?: (req: http.IncomingMessage, cb: (err: Error | null, authInfo?: unknown) => void) => void;
+  hooks?: Partial<Hooks>;
+  logger?: Logger;
+  silent?: boolean;
+  skipLogOnHookError?: boolean;
+  broadcastEventName?: string;
+  heartbeatTimeout?: number;
+}
+interface BroadcastOptions {
+  enableLog?: boolean;
+  socketFilters?: Record<string, unknown>;
+  noCluster?: boolean;
+}
+interface BroadcastResult {
+  count: number;
+  topic: string;
+  event: string;
+  data: unknown;
+  options: BroadcastOptions;
+}
+interface SendOptions {
+  topic: string;
+  event: string;
+  data: unknown;
+  options: {
+    enableLog?: boolean;
+  };
+}
+/**
+ * Create a websocket server
+ *
+ * @param {Object} opts
+ * @param {String} opts.pathname - which path to mount the socket server
+ * @param {Object} opts.authenticate - authentication function to be called on connection
+ * @param {Object} opts.hooks - hooks to be called on events
+ * @param {Object} opts.logger - logger used to log messages
+ * @param {Object} opts.broadcastEventName - used in cluster mode, default is '@arcblock/ws:broadcast'
+ * @param {Object} opts.heartbeatTimeout - maximum non-response time of a connection socket
+ * @class WsServer
+ * @extends {EventEmitter}
+ */
+declare class WsServer extends EventEmitter {
+  pathname?: string;
+  authenticate: WsServerOptions['authenticate'];
+  hooks: Hooks;
+  logger: Logger;
+  skipLogOnHookError: boolean;
+  heartbeatTimeout: number;
+  wss: WebSocketServer;
+  topics: Record<string, Set<WsSocket>>;
+  broadcastEventName: string;
+  constructor(opts?: WsServerOptions);
+  attach(server: http.Server): this;
+  onConnect(request: http.IncomingMessage, socket: Duplex, head: Buffer): void;
+  /**
+   * Broadcast message to all subscribers of a topic, can be used as
+   * - broadcast(event, data) ==> broadcast(event, event, data)
+   * - broadcast(topic, event, data)
+   * - broadcast(topic, event, data, options)
+   */
+  broadcast(...args: unknown[]): Promise<void>;
+  _doBroadCast({
+    topic,
+    event,
+    data,
+    enableLog,
+    replyId,
+    socketFilters
+  }?: DoBroadcastParams): {
+    count: number;
+    error?: Error;
+  };
+  /**
+   * Send message to 1 subscriber of a topic, can be used as
+   * - send(socket, event, data)
+   * - send(socket, topic, event, data)
+   * - send(socket, topic, event, data, options)
+   */
+  send(...args: unknown[]): Promise<void>;
+  /**
+   * private
+   */
+  onWssConnection(socket: WebSocket): Promise<void>;
+  /**
+   * private
+   */
+  onWssClose(): void;
+  /**
+   * private
+   */
+  onWssError(error: Error): void;
+  _leaveChannel(socket: WsSocket, topic: string): void;
+}
+interface DoBroadcastParams {
+  topic: string;
+  event: string;
+  data: unknown;
+  enableLog?: boolean;
+  replyId?: string;
+  socketFilters?: Record<string, unknown>;
+}
+//#endregion
+export { HookParams, Hooks, WsSocket, WsServer as default };