@nomalism-com/api 0.45.6 → 0.45.7

package/dist/index.js

@@ -127,6 +127,132 @@ __export(main_exports, {
 import axios, { AxiosHeaders } from "axios";
 import Nomalism from "@nomalism-com/types";
 
+// src/modules/view/webSocket.ts
+var CLOSE_AUTH_REJECTED = 4401;
+var CLOSE_AUTH_UNAVAILABLE = 4503;
+var PING_INTERVAL_MS = 25e3;
+var MAX_BACKOFF_MS = 3e4;
+var BASE_BACKOFF_MS = 1e3;
+var Service = class {
+  constructor({ route }) {
+    this.route = route;
+  }
+  openChatSocket({
+    token,
+    onEvent,
+    onOpen,
+    onReconnect,
+    onClose,
+    onAuthUnverified
+  }) {
+    let ws = null;
+    let attempts = 0;
+    let opensSoFar = 0;
+    let pingTimer = null;
+    let reconnectTimer = null;
+    let closedByCaller = false;
+    const subprotocol = `bearer.${token}`;
+    const stopPing = () => {
+      if (pingTimer !== null) {
+        window.clearInterval(pingTimer);
+        pingTimer = null;
+      }
+    };
+    const startPing = () => {
+      stopPing();
+      pingTimer = setInterval(() => {
+        if (ws?.readyState === WebSocket.OPEN) {
+          try {
+            ws.send(JSON.stringify({ type: "ping" }));
+          } catch (err) {
+            console.warn("[chatSocket] ping failed", err);
+          }
+        }
+      }, PING_INTERVAL_MS);
+    };
+    const scheduleReconnect = () => {
+      if (closedByCaller) return;
+      const delay = Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** Math.min(attempts, 6));
+      attempts += 1;
+      reconnectTimer = setTimeout(connect, delay);
+    };
+    const connect = () => {
+      if (closedByCaller) return;
+      try {
+        ws = new WebSocket(this.route, [subprotocol]);
+      } catch (err) {
+        console.error("[chatSocket] WebSocket constructor threw", err);
+        scheduleReconnect();
+        return;
+      }
+      ws.onopen = () => {
+        attempts = 0;
+        opensSoFar += 1;
+        startPing();
+        if (opensSoFar === 1) {
+          onOpen?.();
+        } else {
+          onReconnect?.();
+        }
+      };
+      ws.onmessage = (msg) => {
+        let payload;
+        try {
+          payload = JSON.parse(msg.data);
+        } catch {
+          console.warn("[chatSocket] received non-JSON frame", msg.data);
+          return;
+        }
+        if (payload.type === "ping" || payload.type === "pong") return;
+        try {
+          onEvent(payload);
+        } catch (err) {
+          console.error("[chatSocket] event handler threw", err, payload);
+        }
+      };
+      ws.onerror = (err) => {
+        console.warn("[chatSocket] error", err);
+      };
+      ws.onclose = (e) => {
+        stopPing();
+        ws = null;
+        onClose?.();
+        if (e.code === CLOSE_AUTH_REJECTED) {
+          console.error("[chatSocket] auth rejected by server, not reconnecting");
+          closedByCaller = true;
+          return;
+        }
+        if (e.code === CLOSE_AUTH_UNAVAILABLE) {
+          console.warn("[chatSocket] auth verifier unavailable, retrying");
+          attempts = Math.min(attempts, 2);
+          onAuthUnverified?.();
+          scheduleReconnect();
+          return;
+        }
+        scheduleReconnect();
+      };
+    };
+    connect();
+    return {
+      close: () => {
+        closedByCaller = true;
+        if (reconnectTimer !== null) {
+          window.clearTimeout(reconnectTimer);
+          reconnectTimer = null;
+        }
+        stopPing();
+        if (ws && ws.readyState <= WebSocket.OPEN) {
+          try {
+            ws.close(1e3, "client unmount");
+          } catch {
+          }
+        }
+        ws = null;
+      }
+    };
+  }
+};
+
 // src/modules/user/bankData.ts
 var bankData_exports = {};
 __export(bankData_exports, {
@@ -4206,6 +4332,7 @@ var API = class {
       api: this.client,
       route: `${this.services[service]}${module}/`
     });
+    this.WebSocket = new Service(getModuleParams("view", "ws"));
     this.BankData = new Repository(getModuleParams("users", Nomalism.BankData.Route));
     this.Client = new Repository2(getModuleParams("users", Nomalism.Client.Route));
     this.ClientType = new Repository3(getModuleParams("users", Nomalism.ClientType.Route));

package/dist/main.d.ts

@@ -1,4 +1,5 @@
 import { AxiosInstance } from 'axios';
+import WebSocketClass from './modules/view/webSocket';
 import BankDataClass from './modules/user/bankData';
 import ClientClass from './modules/user/clients';
 import ClientTypeClass from './modules/user/clientType';
@@ -254,6 +255,7 @@ export declare class API {
     processEnvironment: IEnvironment;
     client: AxiosInstance;
     services: Record<IService, string>;
+    WebSocket: WebSocketClass;
     BankData: BankDataClass;
     Client: ClientClass;
     ClientType: ClientTypeClass;

package/dist/modules/view/webSocket.d.ts

@@ -0,0 +1,58 @@
+import type Nomalism from '@nomalism-com/types';
+import type { IModuleConstructor } from '../../main';
+export type ChatSocketEvent = {
+    type: 'chat.translation.updated';
+    chat_id: string;
+    translation: string;
+    target_language_id: string;
+} | {
+    type: 'chat.message.created';
+    balloon: Nomalism.Chat.IChatBalloon;
+} | {
+    type: 'chat.message.updated';
+    chat_id: string;
+    patch: Partial<NonNullable<Nomalism.Chat.IChatBalloon['chat']>>;
+} | {
+    type: 'chat.message.deleted';
+    chat_id: string;
+} | {
+    type: 'chat.file.deleted';
+    file_id: string;
+} | {
+    type: 'chat.read_state.updated';
+    chat_document_header_id: string;
+    client_read: boolean;
+    chat_id?: string;
+    file_id?: string;
+} | {
+    type: 'chat.tags.updated';
+    chat_document_header_id: string;
+    tags: Nomalism.Portal.ITags[];
+} | {
+    type: 'persona.updated';
+    persona: NonNullable<Nomalism.Portal.IPublicFindBySubscriberId['persona']>;
+} | {
+    type: 'document.updated';
+    document: Nomalism.Portal.IPublicDocument;
+} | {
+    type: 'ping';
+} | {
+    type: 'pong';
+};
+interface ChatSocketOptions {
+    token: string;
+    onEvent: (evt: ChatSocketEvent) => void;
+    onOpen?: () => void;
+    onReconnect?: () => void;
+    onClose?: () => void;
+    onAuthUnverified?: () => void;
+}
+interface ChatSocketHandle {
+    close: () => void;
+}
+export default class Service {
+    route: string;
+    constructor({ route }: IModuleConstructor);
+    openChatSocket({ token, onEvent, onOpen, onReconnect, onClose, onAuthUnverified, }: ChatSocketOptions): ChatSocketHandle;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomalism-com/api",
   "description": "A nomalism API package for performing HTTP requests on API endpoints",
-  "version": "0.45.6",
+  "version": "0.45.7",
   "author": "Nomalism <it.nomalism@gmail.com> (https://https://nomalism.com/)",
   "license": "UNLICENSED",
   "type": "module",