@borealise/pipeline 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,518 @@
+"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, {
+  Activity: () => Activity,
+  CloseCodes: () => CloseCodes,
+  Events: () => Events,
+  Opcodes: () => Opcodes,
+  PipelineClient: () => PipelineClient,
+  PipelineErrors: () => PipelineErrors,
+  Presence: () => Presence,
+  Roles: () => Roles,
+  createPipeline: () => createPipeline,
+  getEventName: () => getEventName,
+  getPipelineErrorName: () => getPipelineErrorName
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants/opcodes.ts
+var Opcodes = {
+  IDENTIFY: 0,
+  HEARTBEAT: 1,
+  PRESENCE_UPDATE: 2,
+  SUBSCRIBE: 3,
+  UNSUBSCRIBE: 4,
+  REQUEST: 5,
+  CHAT_SEND: 6,
+  HELLO: 16,
+  HEARTBEAT_ACK: 17,
+  READY: 18,
+  INVALID_SESSION: 19,
+  RECONNECT: 20,
+  DISPATCH: 21,
+  ERROR: 255
+};
+var Events = {
+  USER_UPDATE: 0,
+  USER_PRESENCE_UPDATE: 1,
+  USER_TYPING: 2,
+  USER_LEVEL_UP: 3,
+  SESSION_CREATE: 16,
+  SESSION_DELETE: 17,
+  SESSION_UPDATE: 18,
+  NOTIFICATION_CREATE: 32,
+  NOTIFICATION_DELETE: 33,
+  ROOM_JOIN: 48,
+  ROOM_LEAVE: 49,
+  ROOM_UPDATE: 50,
+  ROOM_DELETE: 51,
+  ROOM_USER_JOIN: 64,
+  ROOM_USER_LEAVE: 65,
+  ROOM_USER_KICK: 66,
+  ROOM_USER_BAN: 67,
+  ROOM_USER_MUTE: 68,
+  ROOM_USER_UNMUTE: 69,
+  ROOM_USER_ROLE_UPDATE: 70,
+  ROOM_USER_AVATAR_UPDATE: 71,
+  ROOM_USER_SUBSCRIPTION_UPDATE: 72,
+  ROOM_CHAT_MESSAGE: 80,
+  ROOM_CHAT_DELETE: 81,
+  ROOM_DJ_ADVANCE: 96,
+  ROOM_DJ_UPDATE: 97,
+  ROOM_WAITLIST_JOIN: 98,
+  ROOM_WAITLIST_LEAVE: 99,
+  ROOM_WAITLIST_UPDATE: 100,
+  ROOM_WAITLIST_LOCK: 101,
+  ROOM_WAITLIST_CYCLE: 102,
+  ROOM_TIME_SYNC: 103,
+  ROOM_VOTE: 112,
+  ROOM_GRAB: 113,
+  FRIEND_REQUEST: 128,
+  FRIEND_REQUEST_CANCEL: 129,
+  FRIEND_ACCEPT: 130,
+  FRIEND_REMOVE: 131,
+  SYSTEM_MESSAGE: 240,
+  MAINTENANCE: 241,
+  RATE_LIMIT: 242
+};
+var Presence = {
+  ONLINE: 0,
+  IDLE: 1,
+  DND: 2,
+  INVISIBLE: 3,
+  OFFLINE: 4
+};
+var Activity = {
+  NONE: 0,
+  VIEWING: 1,
+  EDITING: 2,
+  IDLE: 3,
+  STREAMING: 4,
+  LISTENING: 5,
+  WATCHING: 6,
+  CUSTOM: 255
+};
+var Roles = {
+  USER: 0,
+  MODERATOR: 1,
+  ADMIN: 2,
+  OWNER: 255
+};
+var CloseCodes = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNKNOWN_ERROR: 4e3,
+  UNKNOWN_OPCODE: 4001,
+  DECODE_ERROR: 4002,
+  NOT_AUTHENTICATED: 4003,
+  AUTHENTICATION_FAILED: 4004,
+  ALREADY_AUTHENTICATED: 4005,
+  INVALID_SESSION: 4006,
+  RATE_LIMITED: 4008,
+  SESSION_TIMEOUT: 4009,
+  SERVER_SHUTDOWN: 4010
+};
+var PipelineErrors = {
+  CHAT_MESSAGE_EMPTY: 4100,
+  CHAT_MESSAGE_TOO_LONG: 4101,
+  CHAT_ROOM_NOT_FOUND: 4102,
+  CHAT_NOT_IN_ROOM: 4103,
+  CHAT_USER_MUTED: 4104,
+  ROOM_NOT_FOUND: 4200,
+  ROOM_NOT_ACTIVE: 4201,
+  ROOM_ALREADY_MEMBER: 4202,
+  ROOM_NOT_MEMBER: 4203,
+  ROOM_BANNED: 4204,
+  ROOM_FULL: 4205,
+  WAITLIST_LOCKED: 4300,
+  WAITLIST_FULL: 4301,
+  WAITLIST_ALREADY_IN: 4302,
+  WAITLIST_NOT_IN: 4303,
+  VOTE_INVALID: 4400,
+  VOTE_ALREADY_VOTED: 4401,
+  VOTE_NO_TRACK: 4402
+};
+function getPipelineErrorName(code) {
+  return Object.entries(PipelineErrors).find(([, value]) => value === code)?.[0] || "UNKNOWN_ERROR";
+}
+function getEventName(code) {
+  return Object.entries(Events).find(([, value]) => value === code)?.[0] || "UNKNOWN";
+}
+
+// src/logger.ts
+var _Logger = class _Logger {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.options = options;
+  }
+  static create(name, options = {}) {
+    const logger = new _Logger(name, options);
+    _Logger.loggers.set(name, logger);
+    return logger;
+  }
+  enabled(level) {
+    return level >= (this.options.minLevel ?? 0 /* DEBUG */);
+  }
+  debug(message, ...args) {
+    if (!this.enabled(0 /* DEBUG */)) return;
+    console.log(`[DEBUG] [${this.name}] ${message}`, ...args);
+  }
+  info(message, ...args) {
+    if (!this.enabled(1 /* INFO */)) return;
+    console.info(`[INFO] [${this.name}] ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    if (!this.enabled(2 /* WARN */)) return;
+    console.warn(`[WARN] [${this.name}] ${message}`, ...args);
+  }
+  error(message, ...args) {
+    if (!this.enabled(3 /* ERROR */)) return;
+    console.error(`[ERROR] [${this.name}] ${message}`, ...args);
+  }
+};
+_Logger.loggers = /* @__PURE__ */ new Map();
+var Logger = _Logger;
+
+// src/PipelineClient.ts
+var PipelineClient = class {
+  constructor(options) {
+    this.ws = null;
+    this.sessionId = null;
+    this.heartbeatInterval = null;
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+    this.reconnectAttempts = 0;
+    this.lastSequence = 0;
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this._state = "disconnected";
+    this._user = null;
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.connectionListeners = /* @__PURE__ */ new Map();
+    this.dispatchHandler = null;
+    this.maxReconnectAttempts = 10;
+    this.reconnectBackoff = [1e3, 2e3, 5e3, 1e4, 3e4];
+    this.options = { ...options };
+    this.logger = Logger.create(options.loggerName || "Pipeline");
+  }
+  get state() {
+    return this._state;
+  }
+  get user() {
+    return this._user;
+  }
+  get isConnected() {
+    return this._state === "connected" || this._state === "identified";
+  }
+  get isIdentified() {
+    return this._state === "identified";
+  }
+  setDispatchHandler(handler) {
+    this.dispatchHandler = handler;
+  }
+  connect() {
+    if (!this.options.url) {
+      this.logger.error("Cannot connect: missing pipeline url");
+      return;
+    }
+    if (this.ws && (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN)) {
+      this.logger.warn("Already connected or connecting");
+      return;
+    }
+    this.setState("connecting");
+    try {
+      const factory = this.options.webSocketFactory || ((url) => new WebSocket(url));
+      this.ws = factory(this.options.url);
+      this.ws.onopen = () => this.handleOpen();
+      this.ws.onmessage = (event) => this.handleMessage(event);
+      this.ws.onclose = (event) => this.handleClose(event);
+      this.ws.onerror = (event) => this.handleError(event);
+    } catch (error) {
+      this.logger.error("Connection failed", error);
+      this.scheduleReconnect();
+    }
+  }
+  disconnect() {
+    this.clearTimers();
+    this.reconnectAttempts = 0;
+    if (this.ws) {
+      this.ws.close(CloseCodes.NORMAL, "client disconnect");
+      this.ws = null;
+    }
+    this.sessionId = null;
+    this._user = null;
+    this.setState("disconnected");
+  }
+  identify(token) {
+    this.send(Opcodes.IDENTIFY, { token });
+  }
+  updatePresence(status, activity) {
+    this.send(Opcodes.PRESENCE_UPDATE, { status, activity });
+  }
+  subscribe(events) {
+    for (const event of events) {
+      this.subscriptions.add(event);
+    }
+    if (this.isIdentified) {
+      this.send(Opcodes.SUBSCRIBE, { events });
+    }
+  }
+  unsubscribe(events) {
+    for (const event of events) {
+      this.subscriptions.delete(event);
+    }
+    if (this.isIdentified) {
+      this.send(Opcodes.UNSUBSCRIBE, { events });
+    }
+  }
+  sendChatMessage(roomSlug, content) {
+    if (!this.isIdentified) {
+      this.logger.warn("Cannot send chat: not identified");
+      return false;
+    }
+    this.send(Opcodes.CHAT_SEND, {
+      room_slug: roomSlug,
+      content
+    });
+    return true;
+  }
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.eventListeners.get(event)?.delete(listener);
+  }
+  onConnection(event, listener) {
+    if (!this.connectionListeners.has(event)) {
+      this.connectionListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.connectionListeners.get(event).add(listener);
+    return () => this.offConnection(event, listener);
+  }
+  offConnection(event, listener) {
+    this.connectionListeners.get(event)?.delete(listener);
+  }
+  setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    this.emit("onStateChange", state);
+    this.dispatchHandler?.("pipeline/setConnectionState", state);
+  }
+  clearTimers() {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  handleOpen() {
+    this.logger.info("Connected");
+    this.setState("connected");
+    this.reconnectAttempts = 0;
+    this.emit("onConnect");
+  }
+  handleMessage(event) {
+    try {
+      const message = JSON.parse(String(event.data));
+      switch (message.op) {
+        case Opcodes.HELLO:
+          this.handleHello(message.d);
+          break;
+        case Opcodes.HEARTBEAT_ACK:
+          break;
+        case Opcodes.READY:
+          this.handleReady(message.d);
+          break;
+        case Opcodes.INVALID_SESSION:
+          this.handleInvalidSession(message.d);
+          break;
+        case Opcodes.RECONNECT:
+          this.handleReconnect();
+          break;
+        case Opcodes.DISPATCH:
+          this.handleDispatch(message.t, message.d, message.s);
+          break;
+        case Opcodes.ERROR:
+          this.handleServerError(message.d);
+          break;
+        default:
+          this.logger.warn(`Unknown opcode: ${message.op}`);
+      }
+    } catch (error) {
+      this.logger.error("Failed to parse message", error);
+    }
+  }
+  handleClose(event) {
+    this.logger.info(`Disconnected: ${event.code} - ${event.reason}`);
+    this.clearTimers();
+    this.ws = null;
+    this.emit("onDisconnect", event.code, event.reason);
+    const noReconnectCodes = [
+      CloseCodes.AUTHENTICATION_FAILED,
+      CloseCodes.NOT_AUTHENTICATED,
+      CloseCodes.NORMAL
+    ];
+    if (!noReconnectCodes.includes(event.code)) {
+      this.scheduleReconnect();
+      return;
+    }
+    this.setState("disconnected");
+  }
+  handleError(_event) {
+    this.logger.error("WebSocket error");
+  }
+  handleHello(payload) {
+    this.sessionId = payload.session_id;
+    this.heartbeatInterval = payload.heartbeat_interval;
+    this.startHeartbeat();
+    const token = this.resolveToken();
+    if (token) {
+      this.identify(token);
+    }
+  }
+  handleReady(payload) {
+    this._user = payload.user;
+    this.setState("identified");
+    this.emit("onReady", payload);
+    this.dispatchHandler?.("pipeline/setReady", payload);
+    if (this.subscriptions.size > 0) {
+      this.subscribe(Array.from(this.subscriptions));
+    }
+  }
+  handleInvalidSession(payload) {
+    if (!payload.resumable) {
+      this._user = null;
+      this.setState("connected");
+      this.dispatchHandler?.("pipeline/setInvalidSession");
+    }
+  }
+  handleReconnect() {
+    this.logger.info("Server requested reconnect");
+    this.disconnect();
+    this.connect();
+  }
+  handleDispatch(event, data, sequence) {
+    if (typeof sequence === "number") {
+      this.lastSequence = sequence;
+    }
+    this.emitEvent(event, data);
+    this.emit("onDispatch", event, data);
+    this.dispatchHandler?.("pipeline/handleDispatch", { event, data });
+  }
+  handleServerError(payload) {
+    this.logger.error(`Server error: ${payload.code} - ${payload.message || "unknown"}`);
+    this.emit("onError", payload);
+    this.dispatchHandler?.("pipeline/handleServerError", payload);
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+    }
+    if (!this.heartbeatInterval) return;
+    const jitter = this.heartbeatInterval * 0.1 * (Math.random() * 2 - 1);
+    const interval = this.heartbeatInterval + jitter;
+    this.heartbeatTimer = window.setInterval(() => {
+      this.sendHeartbeat();
+    }, interval);
+    this.sendHeartbeat();
+  }
+  sendHeartbeat() {
+    this.send(Opcodes.HEARTBEAT, {
+      seq: this.lastSequence || null
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.logger.error("Max reconnect attempts reached");
+      this.setState("disconnected");
+      return;
+    }
+    this.setState("reconnecting");
+    const backoffIndex = Math.min(this.reconnectAttempts, this.reconnectBackoff.length - 1);
+    const delay = this.reconnectBackoff[backoffIndex];
+    this.reconnectTimer = window.setTimeout(() => {
+      this.reconnectAttempts += 1;
+      this.emit("onReconnect", this.reconnectAttempts);
+      this.connect();
+    }, delay);
+  }
+  send(op, data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.logger.warn("Cannot send: not connected");
+      return;
+    }
+    const message = { op, d: data };
+    this.ws.send(JSON.stringify(message));
+  }
+  emitEvent(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (!listeners) return;
+    for (const listener of listeners) {
+      try {
+        listener(data);
+      } catch (error) {
+        this.logger.error(`Event listener error for ${event}`, error);
+      }
+    }
+  }
+  emit(event, ...args) {
+    const listeners = this.connectionListeners.get(event);
+    if (!listeners) return;
+    for (const listener of listeners) {
+      try {
+        ;
+        listener(...args);
+      } catch (error) {
+        this.logger.error(`Connection listener error for ${event}`, error);
+      }
+    }
+  }
+  resolveToken() {
+    const fromProvider = this.options.tokenProvider?.();
+    if (!fromProvider) return null;
+    return fromProvider;
+  }
+};
+function createPipeline(options) {
+  return new PipelineClient(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Activity,
+  CloseCodes,
+  Events,
+  Opcodes,
+  PipelineClient,
+  PipelineErrors,
+  Presence,
+  Roles,
+  createPipeline,
+  getEventName,
+  getPipelineErrorName
+});