@addev-be/ui 2.4.3 → 2.4.4

package/src/services/HttpService.ts

@@ -1,92 +1,92 @@
-import { Config } from '../config';
-import { trimEnd } from 'lodash';
-import { v4 } from 'uuid';
-
-export class HttpService {
-  private static instance: HttpService;
-  private config: Config;
-  private promises: {
-    [id: string]: {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      resolve: (value: any) => void;
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      reject: (reason?: any) => void;
-    };
-  } = {};
-
-  constructor(config: Config) {
-    HttpService.instance = this;
-    this.config = config;
-  }
-
-  public static getInstance() {
-    return HttpService.instance;
-  }
-
-  public sendRequest<TReq, TRes>(
-    name: string,
-    data: TReq,
-    files?: Record<string, File>
-  ) {
-    const id = v4();
-    const promise = new Promise<TRes>((resolve, reject) => {
-      this.promises[id] = { resolve, reject };
-
-      const formData = new FormData();
-      formData.append('id', id);
-      formData.append('data', JSON.stringify(data));
-      if (files) {
-        Object.entries(files).forEach(([key, file]) => {
-          formData.append(key, file);
-        });
-      }
-
-      console.log('[HTTP] Sending request:', { id, name, data });
-      fetch(`${trimEnd(this.config.httpServerUrl, '/')}/${name}`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: formData,
-      })
-        .then(async (response) => {
-          if (!response.ok) {
-            throw new Error('HTTP request failed');
-          }
-          const body = await response.text();
-          this.parseMessage(body);
-        })
-        .catch((error) => {
-          reject(error);
-        });
-    });
-    return promise;
-  }
-
-  private parseMessage(message: string) {
-    try {
-      const response = JSON.parse(message);
-      if (!response.id) {
-        throw new Error('Received message is not valid');
-      }
-      if (this.promises[response.id]) {
-        console.log('[HTTP] Received response:', response);
-        if (
-          typeof response.data?.status === 'number' &&
-          response.data.status < 0
-        ) {
-          this.promises[response.id].reject(new Error(response.data.message));
-        } else {
-          this.promises[response.id].resolve(response.data);
-        }
-        delete this.promises[response.id];
-      } else {
-        console.log('[HTTP] Received request:', response);
-        // TODO : Implement request handling
-        throw new Error('Not yet implemented');
-      }
-    } catch (error) {
-      console.error('[HTTP] Error parsing message:', error);
-    }
-  }
-}
+import { Config } from '../config';
+import { trimEnd } from 'lodash';
+import { v4 } from 'uuid';
+
+export class HttpService {
+  private static instance: HttpService;
+  private config: Config;
+  private promises: {
+    [id: string]: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      resolve: (value: any) => void;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      reject: (reason?: any) => void;
+    };
+  } = {};
+
+  constructor(config: Config) {
+    HttpService.instance = this;
+    this.config = config;
+  }
+
+  public static getInstance() {
+    return HttpService.instance;
+  }
+
+  public sendRequest<TReq, TRes>(
+    name: string,
+    data: TReq,
+    files?: Record<string, File>
+  ) {
+    const id = v4();
+    const promise = new Promise<TRes>((resolve, reject) => {
+      this.promises[id] = { resolve, reject };
+
+      const formData = new FormData();
+      formData.append('id', id);
+      formData.append('data', JSON.stringify(data));
+      if (files) {
+        Object.entries(files).forEach(([key, file]) => {
+          formData.append(key, file);
+        });
+      }
+
+      console.log('[HTTP] Sending request:', { id, name, data });
+      fetch(`${trimEnd(this.config.httpServerUrl, '/')}/${name}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: formData,
+      })
+        .then(async (response) => {
+          if (!response.ok) {
+            throw new Error('HTTP request failed');
+          }
+          const body = await response.text();
+          this.parseMessage(body);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+    return promise;
+  }
+
+  private parseMessage(message: string) {
+    try {
+      const response = JSON.parse(message);
+      if (!response.id) {
+        throw new Error('Received message is not valid');
+      }
+      if (this.promises[response.id]) {
+        console.log('[HTTP] Received response:', response);
+        if (
+          typeof response.data?.status === 'number' &&
+          response.data.status < 0
+        ) {
+          this.promises[response.id].reject(new Error(response.data.message));
+        } else {
+          this.promises[response.id].resolve(response.data);
+        }
+        delete this.promises[response.id];
+      } else {
+        console.log('[HTTP] Received request:', response);
+        // TODO : Implement request handling
+        throw new Error('Not yet implemented');
+      }
+    } catch (error) {
+      console.error('[HTTP] Error parsing message:', error);
+    }
+  }
+}

package/src/services/WebSocketService.ts

@@ -1,155 +1,155 @@
-import { Config } from '../config';
-import { Request } from './base';
-import { Subject } from 'rxjs';
-import { v4 } from 'uuid';
-
-export class WebSocketError extends Error {
-  public status: number;
-
-  constructor(status: number, message: string) {
-    super(message);
-    this.status = status;
-    this.name = 'WebSocketError';
-  }
-}
-
-export class WebSocketService {
-  private static instance: WebSocketService;
-  private config: Config;
-  private socket: WebSocket | null = null;
-
-  public status: boolean | undefined = undefined;
-  public status$ = new Subject<boolean | undefined>();
-  public error$ = new Subject<{ status: number; message: string }>();
-
-  private queue: Request[] = [];
-  private promises: {
-    [id: string]: {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      resolve: (value: any) => void;
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      reject: (reason?: any) => void;
-    };
-  } = {};
-
-  public onOpen?: () => void = () => {};
-  public onClose?: () => void = () => {};
-  public onMessage?: (message: string) => void = () => {};
-  public onError?: (error: unknown) => void = () => {};
-
-  constructor(config: Config) {
-    WebSocketService.instance = this;
-    this.config = config;
-  }
-
-  public static getInstance() {
-    return WebSocketService.instance;
-  }
-
-  private resetConnection() {
-    this.setStatus(undefined);
-    this.socket = new WebSocket(this.config.webSocketUrl);
-
-    this.socket.onopen = () => {
-      console.log('[WS] Connected');
-      const interval = setInterval(() => {
-        if (this.socket && this.socket.readyState === 1) {
-          clearInterval(interval);
-          this.setStatus(true);
-          this.sendQueue();
-          this.onOpen?.();
-        }
-      }, 100);
-    };
-
-    this.socket.onclose = () => {
-      console.log('[WS] Disconnected');
-      setTimeout(() => this.connect(), this.status === true ? 500 : 5000);
-      this.onClose?.();
-      this.setStatus(false);
-    };
-
-    this.socket.onmessage = (event) => {
-      this.onMessage?.(event.data);
-      this.parseMessage(event.data);
-    };
-
-    this.socket.onerror = (error) => {
-      this.onError?.(error);
-      console.error('[WS] Error:', error);
-    };
-  }
-
-  public connect(force = false) {
-    if (this.status === false || force) {
-      this.resetConnection();
-    }
-  }
-
-  private setStatus(status: boolean | undefined) {
-    this.status = status;
-    this.status$.next(status);
-  }
-
-  private sendQueue() {
-    if (this.socket && this.status) {
-      let request: Request | undefined;
-      while ((request = this.queue.shift())) {
-        console.log('[WS] Sending queued request:', request);
-        this.socket?.send(JSON.stringify(request));
-      }
-      this.queue.forEach((request) =>
-        this.socket?.send(JSON.stringify(request))
-      );
-    }
-  }
-
-  public sendRequest<TReq, TRes>(name: string, data: TReq) {
-    const id = v4();
-    const promise = new Promise<TRes>((resolve, reject) => {
-      const request: Request = { id, name, data };
-      this.promises[id] = { resolve, reject };
-      if (!this.socket || !this.status) {
-        console.log('[WS] Queuing request:', request);
-        this.queue.push(request);
-        return;
-      }
-      console.log('[WS] Sending request:', request);
-      this.socket?.send(JSON.stringify(request));
-    });
-    return promise;
-  }
-
-  private parseMessage(message: string) {
-    try {
-      const response = JSON.parse(message);
-      if (!response.id) {
-        throw new Error('Received message is not valid');
-      }
-      if (this.promises[response.id]) {
-        console.log('[WS] Received response:', response);
-        if (
-          typeof response.data?.status === 'number' &&
-          response.data.status < 0
-        ) {
-          this.promises[response.id].reject(
-            new WebSocketError(response.data.status, response.data.message)
-          );
-          this.error$.next({
-            status: response.data.status,
-            message: response.data.message || 'Unknown error',
-          });
-        } else {
-          this.promises[response.id].resolve(response.data);
-        }
-        delete this.promises[response.id];
-      } else {
-        console.log('[WS] Received request:', response);
-        // TODO : Implement request handling
-        throw new Error('Not yet implemented');
-      }
-    } catch (error) {
-      console.error('[WS] Error parsing message:', error);
-    }
-  }
-}
+import { Config } from '../config';
+import { Request } from './base';
+import { Subject } from 'rxjs';
+import { v4 } from 'uuid';
+
+export class WebSocketError extends Error {
+  public status: number;
+
+  constructor(status: number, message: string) {
+    super(message);
+    this.status = status;
+    this.name = 'WebSocketError';
+  }
+}
+
+export class WebSocketService {
+  private static instance: WebSocketService;
+  private config: Config;
+  private socket: WebSocket | null = null;
+
+  public status: boolean | undefined = undefined;
+  public status$ = new Subject<boolean | undefined>();
+  public error$ = new Subject<{ status: number; message: string }>();
+
+  private queue: Request[] = [];
+  private promises: {
+    [id: string]: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      resolve: (value: any) => void;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      reject: (reason?: any) => void;
+    };
+  } = {};
+
+  public onOpen?: () => void = () => {};
+  public onClose?: () => void = () => {};
+  public onMessage?: (message: string) => void = () => {};
+  public onError?: (error: unknown) => void = () => {};
+
+  constructor(config: Config) {
+    WebSocketService.instance = this;
+    this.config = config;
+  }
+
+  public static getInstance() {
+    return WebSocketService.instance;
+  }
+
+  private resetConnection() {
+    this.setStatus(undefined);
+    this.socket = new WebSocket(this.config.webSocketUrl);
+
+    this.socket.onopen = () => {
+      console.log('[WS] Connected');
+      const interval = setInterval(() => {
+        if (this.socket && this.socket.readyState === 1) {
+          clearInterval(interval);
+          this.setStatus(true);
+          this.sendQueue();
+          this.onOpen?.();
+        }
+      }, 100);
+    };
+
+    this.socket.onclose = () => {
+      console.log('[WS] Disconnected');
+      setTimeout(() => this.connect(), this.status === true ? 500 : 5000);
+      this.onClose?.();
+      this.setStatus(false);
+    };
+
+    this.socket.onmessage = (event) => {
+      this.onMessage?.(event.data);
+      this.parseMessage(event.data);
+    };
+
+    this.socket.onerror = (error) => {
+      this.onError?.(error);
+      console.error('[WS] Error:', error);
+    };
+  }
+
+  public connect(force = false) {
+    if (this.status === false || force) {
+      this.resetConnection();
+    }
+  }
+
+  private setStatus(status: boolean | undefined) {
+    this.status = status;
+    this.status$.next(status);
+  }
+
+  private sendQueue() {
+    if (this.socket && this.status) {
+      let request: Request | undefined;
+      while ((request = this.queue.shift())) {
+        console.log('[WS] Sending queued request:', request);
+        this.socket?.send(JSON.stringify(request));
+      }
+      this.queue.forEach((request) =>
+        this.socket?.send(JSON.stringify(request))
+      );
+    }
+  }
+
+  public sendRequest<TReq, TRes>(name: string, data: TReq) {
+    const id = v4();
+    const promise = new Promise<TRes>((resolve, reject) => {
+      const request: Request = { id, name, data };
+      this.promises[id] = { resolve, reject };
+      if (!this.socket || !this.status) {
+        console.log('[WS] Queuing request:', request);
+        this.queue.push(request);
+        return;
+      }
+      console.log('[WS] Sending request:', request);
+      this.socket?.send(JSON.stringify(request));
+    });
+    return promise;
+  }
+
+  private parseMessage(message: string) {
+    try {
+      const response = JSON.parse(message);
+      if (!response.id) {
+        throw new Error('Received message is not valid');
+      }
+      if (this.promises[response.id]) {
+        console.log('[WS] Received response:', response);
+        if (
+          typeof response.data?.status === 'number' &&
+          response.data.status < 0
+        ) {
+          this.promises[response.id].reject(
+            new WebSocketError(response.data.status, response.data.message)
+          );
+          this.error$.next({
+            status: response.data.status,
+            message: response.data.message || 'Unknown error',
+          });
+        } else {
+          this.promises[response.id].resolve(response.data);
+        }
+        delete this.promises[response.id];
+      } else {
+        console.log('[WS] Received request:', response);
+        // TODO : Implement request handling
+        throw new Error('Not yet implemented');
+      }
+    } catch (error) {
+      console.error('[WS] Error parsing message:', error);
+    }
+  }
+}