reverb-ws-client 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,55 @@
+type ReverbScheme = "ws" | "wss";
+type EventCallback<T = unknown> = (data: T) => void;
+type ReverbClientOptions = {
+    appKey: string;
+    host: string;
+    port?: number;
+    scheme?: ReverbScheme;
+    authorizer?: Authorizer;
+};
+type PusherOutgoingMessage = {
+    event: string;
+    data?: Record<string, unknown>;
+    channel?: string;
+};
+type AuthResponse = {
+    auth: string;
+    channel_data?: string;
+};
+type Authorizer = (params: {
+    socketId: string;
+    channelName: string;
+}) => Promise<AuthResponse>;
+
+declare class Channel {
+    private name;
+    private client;
+    private listeners;
+    private subscribed;
+    constructor(name: string, client: ReverbClient);
+    subscribe(): Promise<void>;
+    listen(event: string, callback: EventCallback): this;
+    stopListening(event: string, callback?: EventCallback): this;
+    handleEvent(event: string, data: unknown): void;
+    getName(): string;
+}
+
+declare class ReverbClient {
+    private options;
+    private connection;
+    private channels;
+    private socketId;
+    constructor(options: ReverbClientOptions);
+    connect(): void;
+    disconnect(): void;
+    channel(name: string): Channel;
+    private(name: string): Channel;
+    presence(name: string): Channel;
+    send(data: PusherOutgoingMessage | object): void;
+    getSocketId(): string | null;
+    authorize(socketId: string, channelName: string): Promise<AuthResponse>;
+    private getChannel;
+    private handleMessage;
+}
+
+export { ReverbClient };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+type ReverbScheme = "ws" | "wss";
+type EventCallback<T = unknown> = (data: T) => void;
+type ReverbClientOptions = {
+    appKey: string;
+    host: string;
+    port?: number;
+    scheme?: ReverbScheme;
+    authorizer?: Authorizer;
+};
+type PusherOutgoingMessage = {
+    event: string;
+    data?: Record<string, unknown>;
+    channel?: string;
+};
+type AuthResponse = {
+    auth: string;
+    channel_data?: string;
+};
+type Authorizer = (params: {
+    socketId: string;
+    channelName: string;
+}) => Promise<AuthResponse>;
+
+declare class Channel {
+    private name;
+    private client;
+    private listeners;
+    private subscribed;
+    constructor(name: string, client: ReverbClient);
+    subscribe(): Promise<void>;
+    listen(event: string, callback: EventCallback): this;
+    stopListening(event: string, callback?: EventCallback): this;
+    handleEvent(event: string, data: unknown): void;
+    getName(): string;
+}
+
+declare class ReverbClient {
+    private options;
+    private connection;
+    private channels;
+    private socketId;
+    constructor(options: ReverbClientOptions);
+    connect(): void;
+    disconnect(): void;
+    channel(name: string): Channel;
+    private(name: string): Channel;
+    presence(name: string): Channel;
+    send(data: PusherOutgoingMessage | object): void;
+    getSocketId(): string | null;
+    authorize(socketId: string, channelName: string): Promise<AuthResponse>;
+    private getChannel;
+    private handleMessage;
+}
+
+export { ReverbClient };

package/dist/index.js

@@ -0,0 +1,251 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ReverbClient: () => ReverbClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Channel.ts
+var Channel = class {
+  constructor(name, client) {
+    this.name = name;
+    this.client = client;
+  }
+  name;
+  client;
+  listeners = /* @__PURE__ */ new Map();
+  subscribed = false;
+  async subscribe() {
+    if (this.subscribed) return;
+    const isPrivate = this.name.startsWith("private-");
+    const isPresence = this.name.startsWith("presence-");
+    let authPayload = {};
+    if (isPrivate || isPresence) {
+      const socketId = this.client.getSocketId();
+      if (!socketId) {
+        throw new Error("[Reverb] socket_id not ready yet");
+      }
+      const auth = await this.client.authorize(socketId, this.name);
+      authPayload = {
+        auth: auth.auth,
+        ...auth.channel_data ? { channel_data: auth.channel_data } : {}
+      };
+      this.client.send({
+        event: "pusher:subscribe",
+        data: {
+          channel: this.name,
+          ...authPayload
+        }
+      });
+    }
+  }
+  listen(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    this.subscribe().catch((err) => {
+      console.error("[Reverb] subscribe failed", err);
+    });
+    return this;
+  }
+  stopListening(event, callback) {
+    if (!this.listeners.has(event)) return this;
+    if (callback) {
+      this.listeners.get(event).delete(callback);
+    } else {
+      this.listeners.delete(event);
+    }
+    return this;
+  }
+  handleEvent(event, data) {
+    const callbacks = this.listeners.get(event);
+    if (!callbacks) return;
+    let parsedData = data;
+    if (typeof data === "string") {
+      try {
+        parsedData = JSON.parse(data);
+      } catch {
+        parsedData = data;
+      }
+    }
+    callbacks.forEach((cb) => cb(parsedData));
+  }
+  getName() {
+    return this.name;
+  }
+};
+
+// src/ConnectionManager.ts
+var ConnectionManager = class {
+  constructor(options, onMessage) {
+    this.options = options;
+    this.onMessage = onMessage;
+  }
+  options;
+  onMessage;
+  ws = null;
+  state = "disconnected";
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectDelay = 2e3;
+  manuallyDisconnected = false;
+  connect() {
+    if (this.state === "connecting" || this.state === "connected") return;
+    this.manuallyDisconnected = false;
+    this.state = "connecting";
+    const url = this.buildUrl();
+    this.ws = new WebSocket(url);
+    this.ws.onopen = () => {
+      this.state = "connected";
+      this.reconnectAttempts = 0;
+      console.log("[Reverb] Connected");
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const parsed = JSON.parse(event.data);
+        this.onMessage(parsed);
+      } catch (err) {
+        console.warn("[Reverb] Failed to parse message", err);
+      }
+    };
+    this.ws.onerror = (err) => {
+      console.warn("[Reverb] WebSocket error", err);
+    };
+    this.ws.onclose = () => {
+      this.ws = null;
+      this.state = "disconnected";
+      console.log("[Reverb] Disconnected");
+      if (!this.manuallyDisconnected) {
+        this.reconnect();
+      }
+    };
+  }
+  disconnect() {
+    this.manuallyDisconnected = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.state = "disconnected";
+  }
+  send(data) {
+    if (!this.ws || this.state !== "connected") {
+      console.warn("[Reverb] Cannot send, socket not connected");
+      return;
+    }
+    this.ws.send(JSON.stringify(data));
+  }
+  getState() {
+    return this.state;
+  }
+  buildUrl() {
+    const { scheme = "ws", host, port, appKey } = this.options;
+    const portPart = port ? `:${port}` : "";
+    return `${scheme}://${host}${portPart}/app/${appKey}?protocol=7&client=js&version=1.0&flash=false`;
+  }
+  reconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.warn("[Reverb] Max reconnect attempts reached");
+      return;
+    }
+    this.state = "reconnecting";
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      console.log("[Reverb] Reconnecting...");
+      this.connect();
+    }, this.reconnectDelay);
+  }
+};
+
+// src/ReverbClient.ts
+var ReverbClient = class {
+  constructor(options) {
+    this.options = options;
+    this.connection = new ConnectionManager(
+      options,
+      this.handleMessage.bind(this)
+    );
+  }
+  options;
+  connection;
+  channels = /* @__PURE__ */ new Map();
+  socketId = null;
+  connect() {
+    this.connection.connect();
+  }
+  disconnect() {
+    this.connection.disconnect();
+  }
+  channel(name) {
+    return this.getChannel(name);
+  }
+  private(name) {
+    return this.getChannel(`private-${name}`);
+  }
+  presence(name) {
+    return this.getChannel(`presence-${name}`);
+  }
+  send(data) {
+    this.connection.send(data);
+  }
+  getSocketId() {
+    return this.socketId;
+  }
+  authorize(socketId, channelName) {
+    if (!this.options.authorizer) {
+      throw new Error("[Reverb] authorizer is required for private channels");
+    }
+    return this.options.authorizer({
+      socketId,
+      channelName
+    });
+  }
+  getChannel(name) {
+    if (!this.channels.has(name)) {
+      this.channels.set(name, new Channel(name, this));
+    }
+    return this.channels.get(name);
+  }
+  handleMessage(message) {
+    if (message.event === "pusher:connection_established") {
+      const data = typeof message.data === "string" ? JSON.parse(message.data) : message.data;
+      this.socketId = data?.socket_id;
+      return;
+    }
+    if (message.event === "pusher:ping") {
+      this.send({
+        event: "pusher:pong",
+        data: {}
+      });
+      return;
+    }
+    if (message.channel) {
+      const channel = this.channels.get(message.channel);
+      channel?.handleEvent(message.event, message.data);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReverbClient
+});

package/dist/index.mjs

@@ -0,0 +1,224 @@
+// src/Channel.ts
+var Channel = class {
+  constructor(name, client) {
+    this.name = name;
+    this.client = client;
+  }
+  name;
+  client;
+  listeners = /* @__PURE__ */ new Map();
+  subscribed = false;
+  async subscribe() {
+    if (this.subscribed) return;
+    const isPrivate = this.name.startsWith("private-");
+    const isPresence = this.name.startsWith("presence-");
+    let authPayload = {};
+    if (isPrivate || isPresence) {
+      const socketId = this.client.getSocketId();
+      if (!socketId) {
+        throw new Error("[Reverb] socket_id not ready yet");
+      }
+      const auth = await this.client.authorize(socketId, this.name);
+      authPayload = {
+        auth: auth.auth,
+        ...auth.channel_data ? { channel_data: auth.channel_data } : {}
+      };
+      this.client.send({
+        event: "pusher:subscribe",
+        data: {
+          channel: this.name,
+          ...authPayload
+        }
+      });
+    }
+  }
+  listen(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    this.subscribe().catch((err) => {
+      console.error("[Reverb] subscribe failed", err);
+    });
+    return this;
+  }
+  stopListening(event, callback) {
+    if (!this.listeners.has(event)) return this;
+    if (callback) {
+      this.listeners.get(event).delete(callback);
+    } else {
+      this.listeners.delete(event);
+    }
+    return this;
+  }
+  handleEvent(event, data) {
+    const callbacks = this.listeners.get(event);
+    if (!callbacks) return;
+    let parsedData = data;
+    if (typeof data === "string") {
+      try {
+        parsedData = JSON.parse(data);
+      } catch {
+        parsedData = data;
+      }
+    }
+    callbacks.forEach((cb) => cb(parsedData));
+  }
+  getName() {
+    return this.name;
+  }
+};
+
+// src/ConnectionManager.ts
+var ConnectionManager = class {
+  constructor(options, onMessage) {
+    this.options = options;
+    this.onMessage = onMessage;
+  }
+  options;
+  onMessage;
+  ws = null;
+  state = "disconnected";
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectDelay = 2e3;
+  manuallyDisconnected = false;
+  connect() {
+    if (this.state === "connecting" || this.state === "connected") return;
+    this.manuallyDisconnected = false;
+    this.state = "connecting";
+    const url = this.buildUrl();
+    this.ws = new WebSocket(url);
+    this.ws.onopen = () => {
+      this.state = "connected";
+      this.reconnectAttempts = 0;
+      console.log("[Reverb] Connected");
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const parsed = JSON.parse(event.data);
+        this.onMessage(parsed);
+      } catch (err) {
+        console.warn("[Reverb] Failed to parse message", err);
+      }
+    };
+    this.ws.onerror = (err) => {
+      console.warn("[Reverb] WebSocket error", err);
+    };
+    this.ws.onclose = () => {
+      this.ws = null;
+      this.state = "disconnected";
+      console.log("[Reverb] Disconnected");
+      if (!this.manuallyDisconnected) {
+        this.reconnect();
+      }
+    };
+  }
+  disconnect() {
+    this.manuallyDisconnected = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.state = "disconnected";
+  }
+  send(data) {
+    if (!this.ws || this.state !== "connected") {
+      console.warn("[Reverb] Cannot send, socket not connected");
+      return;
+    }
+    this.ws.send(JSON.stringify(data));
+  }
+  getState() {
+    return this.state;
+  }
+  buildUrl() {
+    const { scheme = "ws", host, port, appKey } = this.options;
+    const portPart = port ? `:${port}` : "";
+    return `${scheme}://${host}${portPart}/app/${appKey}?protocol=7&client=js&version=1.0&flash=false`;
+  }
+  reconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.warn("[Reverb] Max reconnect attempts reached");
+      return;
+    }
+    this.state = "reconnecting";
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      console.log("[Reverb] Reconnecting...");
+      this.connect();
+    }, this.reconnectDelay);
+  }
+};
+
+// src/ReverbClient.ts
+var ReverbClient = class {
+  constructor(options) {
+    this.options = options;
+    this.connection = new ConnectionManager(
+      options,
+      this.handleMessage.bind(this)
+    );
+  }
+  options;
+  connection;
+  channels = /* @__PURE__ */ new Map();
+  socketId = null;
+  connect() {
+    this.connection.connect();
+  }
+  disconnect() {
+    this.connection.disconnect();
+  }
+  channel(name) {
+    return this.getChannel(name);
+  }
+  private(name) {
+    return this.getChannel(`private-${name}`);
+  }
+  presence(name) {
+    return this.getChannel(`presence-${name}`);
+  }
+  send(data) {
+    this.connection.send(data);
+  }
+  getSocketId() {
+    return this.socketId;
+  }
+  authorize(socketId, channelName) {
+    if (!this.options.authorizer) {
+      throw new Error("[Reverb] authorizer is required for private channels");
+    }
+    return this.options.authorizer({
+      socketId,
+      channelName
+    });
+  }
+  getChannel(name) {
+    if (!this.channels.has(name)) {
+      this.channels.set(name, new Channel(name, this));
+    }
+    return this.channels.get(name);
+  }
+  handleMessage(message) {
+    if (message.event === "pusher:connection_established") {
+      const data = typeof message.data === "string" ? JSON.parse(message.data) : message.data;
+      this.socketId = data?.socket_id;
+      return;
+    }
+    if (message.event === "pusher:ping") {
+      this.send({
+        event: "pusher:pong",
+        data: {}
+      });
+      return;
+    }
+    if (message.channel) {
+      const channel = this.channels.get(message.channel);
+      channel?.handleEvent(message.event, message.data);
+    }
+  }
+};
+export {
+  ReverbClient
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "reverb-ws-client",
+  "version": "1.0.0",
+  "description": "A lightweight Laravel Reverb client for React Native using the Pusher protocol.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest",
+    "test:integration": "vitest tests/integration --run",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "laravel",
+    "reverb",
+    "react-native",
+    "expo",
+    "websocket",
+    "pusher"
+  ],
+  "author": "Almant",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "dotenv": "^17.4.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  }
+}