@digipair/skill-client-websocket 0.90.0 → 0.91.0-0

package/.swcrc

@@ -0,0 +1,28 @@
+{
+  "jsc": {
+    "target": "es2017",
+    "parser": {
+      "syntax": "typescript",
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "transform": {
+      "decoratorMetadata": true,
+      "legacyDecorator": true
+    },
+    "keepClassNames": true,
+    "externalHelpers": true,
+    "loose": true
+  },
+  "module": {
+    "type": "es6"
+  },
+  "sourceMaps": true,
+  "exclude": [
+    "jest.config.ts",
+    ".*\\.spec.tsx?$",
+    ".*\\.test.tsx?$",
+    "./src/jest-setup.ts$",
+    "./**/jest-setup.ts$"
+  ]
+}

package/README.md

@@ -0,0 +1,7 @@
+# mylib
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build mylib` to build the library.

package/eslint.config.mjs

@@ -0,0 +1,22 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/rollup.config.{js,ts,mjs,mts,cjs,cts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/package.json

@@ -1,15 +1,28 @@
 {
   "name": "@digipair/skill-client-websocket",
-  "version": "0.90.0",
+  "version": "0.91.0-0",
+  "type": "module",
+  "main": "dist/libs/skill-client-websocket/index.cjs.js",
+  "module": "dist/libs/skill-client-websocket/index.esm.js",
+  "types": "dist/libs/skill-client-websocket/index.esm.d.ts",
+  "exports": {
+    "./package.json": "./libs/skill-client-websocket/package.json",
+    ".": {
+      "development": "./dist/libs/skill-client-websocket/src/index.ts",
+      "types": "./dist/libs/skill-client-websocket/index.esm.d.ts",
+      "import": "./dist/libs/skill-client-websocket/index.esm.js",
+      "default": "./dist/libs/skill-client-websocket/index.cjs.js"
+    }
+  },
   "keywords": [
     "digipair",
     "web",
-    "service",
-    "tool"
+    "service"
   ],
-  "dependencies": {
-    "ws": "^8.18.0"
+  "nx": {
+    "name": "skill-client-websocket"
   },
-  "main": "./index.cjs.js",
-  "module": "./index.esm.js"
-}
+  "dependencies": {
+    "@digipair/engine": "0.91.0-0"
+  }
+}

package/rollup.config.cjs

@@ -0,0 +1,28 @@
+const { withNx } = require('@nx/rollup/with-nx');
+
+module.exports = withNx(
+  {
+    main: 'libs/skill-client-websocket/src/index.ts',
+    outputPath: 'dist/libs/skill-client-websocket',
+    tsConfig: 'libs/skill-client-websocket/tsconfig.lib.json',
+    compiler: 'swc',
+    format: ['esm', "cjs"],
+    assets: [
+      {
+        input: 'libs/skill-client-websocket/',
+        glob: 'package.json',
+        output: '.'
+      },
+      {
+        input: 'libs/skill-client-websocket/src/',
+        glob: '*.json',
+        output: '.'
+      }
+    ]
+  },
+  {
+    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+    // e.g.
+    // output: { sourcemap: true },
+  }
+);

package/src/handlebars.d.ts

@@ -0,0 +1 @@
+declare module 'handlebars/dist/handlebars.min.js';

package/src/lib/skill-client-websocket.spec.ts

@@ -0,0 +1,7 @@
+import { skillWebsocket } from './skill-client-websocket';
+
+describe('skillWebsocket', () => {
+  it('should work', () => {
+    expect(skillWebsocket()).toEqual('skill-client-websocket');
+  });
+});

package/src/lib/skill-client-websocket.ts

@@ -0,0 +1,130 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { PinsSettings, executePinsList } from '@digipair/engine';
+
+const WS = typeof WebSocket === 'undefined' ? require('ws') : WebSocket;
+
+class ClientWebSocketService {
+  private retryInterval!: number;
+  private maxRetries!: number;
+  private retryCount = 0;
+
+  ws: WebSocket | null = null;
+  cwssForceClose = false;
+
+  async send(params: any, _pinsSettingsList: PinsSettings[], context: any): Promise<any> {
+    const { websocket = context.websocket, message } = params;
+    return websocket.ws?.send(JSON.stringify(message));
+  }
+
+  async close(params: any, _pinsSettingsList: PinsSettings[], context: any): Promise<any> {
+    const { websocket = context.websocket } = params;
+    websocket.cwssForceClose = true;
+    return websocket.ws?.close();
+  }
+
+  async connect(params: any, pinsSettingsList: PinsSettings[], context: any): Promise<any> {
+    const {
+      url = '',
+      message = [],
+      open = [],
+      close = [],
+      error = [],
+      retryInterval = 1000,
+      maxRetries = 10,
+    } = params;
+
+    this.retryInterval = retryInterval;
+    this.maxRetries = maxRetries;
+
+    // Crée une nouvelle instance WebSocket
+    this.ws = new WS(url, { signal: context.protected?.signal }) as WebSocket;
+
+    // Event onopen: Connexion réussie
+    this.ws.onopen = async () => {
+      this.retryCount = 0; // Réinitialise le compteur de tentatives après une connexion réussie
+
+      try {
+        await executePinsList(open, { ...context, websocket: this }, `${context.__PATH__}.open`);
+      } catch (error: any) {
+        console.error(error);
+
+        const skillLogger = require('@digipair/skill-logger');
+        skillLogger.addLog(context, 'ERROR', error.message);
+      }
+    };
+
+    // Event onmessage: Réception d'un message
+    this.ws.onmessage = async (event: any) => {
+      try {
+        await executePinsList(message, {
+          ...context,
+          message: JSON.parse(event.data),
+          websocket: this,
+        }, `${context.__PATH__}.message`);
+      } catch (error: any) {
+        console.error(error);
+
+        const skillLogger = require('@digipair/skill-logger');
+        skillLogger.addLog(context, 'ERROR', error.message);
+      }
+    };
+
+    // Event onclose: Déconnexion
+    this.ws.onclose = async () => {
+      this.ws = null;
+      const reconnect = this.cwssForceClose
+        ? false
+        : this.reconnectWebSocket(params, pinsSettingsList, context);
+
+      if (!reconnect) {
+        try {
+          await executePinsList(close, { ...context, websocket: this }, `${context.__PATH__}.close`);
+        } catch (error: any) {
+          console.error(error);
+
+          const skillLogger = require('@digipair/skill-logger');
+          skillLogger.addLog(context, 'ERROR', error.message);
+        }
+      }
+    };
+
+    // Event onerror: Erreur
+    this.ws.onerror = async (err: Event) => {
+      try {
+        await executePinsList(error, { ...context, error: err, websocket: this }, `${context.__PATH__}.error`);
+      } catch (error: any) {
+        console.error(error);
+        
+        const skillLogger = require('@digipair/skill-logger');
+        skillLogger.addLog(context, 'ERROR', error.message);
+      }
+
+      this.ws?.close(); // Ferme la connexion en cas d'erreur
+    };
+
+    return this;
+  }
+
+  private reconnectWebSocket(params: any, pinsSettingsList: PinsSettings[], context: any) {
+    if (this.retryCount >= this.maxRetries) {
+      return false;
+    }
+
+    setTimeout(() => {
+      this.retryCount++;
+      this.retryInterval *= 2; // Double l'intervalle entre les tentatives
+      this.connect(params, pinsSettingsList, context);
+    }, this.retryInterval);
+
+    return true;
+  }
+}
+
+export const connect = (params: any, pinsSettingsList: PinsSettings[], context: any) =>
+  new ClientWebSocketService().connect(params, pinsSettingsList, context);
+
+export const send = (params: any, pinsSettingsList: PinsSettings[], context: any) =>
+  new ClientWebSocketService().send(params, pinsSettingsList, context);
+
+export const close = (params: any, pinsSettingsList: PinsSettings[], context: any) =>
+  new ClientWebSocketService().close(params, pinsSettingsList, context);

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "../skill-logger"
+    },
+    {
+      "path": "../engine"
+    },
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "references": [
+    {
+      "path": "../skill-logger/tsconfig.lib.json"
+    },
+    {
+      "path": "../engine/tsconfig.lib.json"
+    }
+  ]
+}

package/index.cjs.d.ts

@@ -1 +0,0 @@
-export * from "./src/index";

package/index.cjs.js

@@ -1,122 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var engine = require('@digipair/engine');
-
-function _extends() {
-    _extends = Object.assign || function assign(target) {
-        for(var i = 1; i < arguments.length; i++){
-            var source = arguments[i];
-            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
-        }
-        return target;
-    };
-    return _extends.apply(this, arguments);
-}
-
-const WS = typeof WebSocket === 'undefined' ? require('ws') : WebSocket;
-let ClientWebSocketService = class ClientWebSocketService {
-    async send(params, _pinsSettingsList, context) {
-        var _websocket_ws;
-        const { websocket = context.websocket, message } = params;
-        return (_websocket_ws = websocket.ws) == null ? void 0 : _websocket_ws.send(JSON.stringify(message));
-    }
-    async close(params, _pinsSettingsList, context) {
-        var _websocket_ws;
-        const { websocket = context.websocket } = params;
-        websocket.cwssForceClose = true;
-        return (_websocket_ws = websocket.ws) == null ? void 0 : _websocket_ws.close();
-    }
-    async connect(params, pinsSettingsList, context) {
-        var _context_protected;
-        const { url = '', message = [], open = [], close = [], error = [], retryInterval = 1000, maxRetries = 10 } = params;
-        this.retryInterval = retryInterval;
-        this.maxRetries = maxRetries;
-        // Crée une nouvelle instance WebSocket
-        this.ws = new WS(url, {
-            signal: (_context_protected = context.protected) == null ? void 0 : _context_protected.signal
-        });
-        // Event onopen: Connexion réussie
-        this.ws.onopen = async ()=>{
-            this.retryCount = 0; // Réinitialise le compteur de tentatives après une connexion réussie
-            try {
-                await engine.executePinsList(open, _extends({}, context, {
-                    websocket: this
-                }), `${context.__PATH__}.open`);
-            } catch (error) {
-                console.error(error);
-                const skillLogger = require('@digipair/skill-logger');
-                skillLogger.addLog(context, 'ERROR', error.message);
-            }
-        };
-        // Event onmessage: Réception d'un message
-        this.ws.onmessage = async (event)=>{
-            try {
-                await engine.executePinsList(message, _extends({}, context, {
-                    message: JSON.parse(event.data),
-                    websocket: this
-                }), `${context.__PATH__}.message`);
-            } catch (error) {
-                console.error(error);
-                const skillLogger = require('@digipair/skill-logger');
-                skillLogger.addLog(context, 'ERROR', error.message);
-            }
-        };
-        // Event onclose: Déconnexion
-        this.ws.onclose = async ()=>{
-            this.ws = null;
-            const reconnect = this.cwssForceClose ? false : this.reconnectWebSocket(params, pinsSettingsList, context);
-            if (!reconnect) {
-                try {
-                    await engine.executePinsList(close, _extends({}, context, {
-                        websocket: this
-                    }), `${context.__PATH__}.close`);
-                } catch (error) {
-                    console.error(error);
-                    const skillLogger = require('@digipair/skill-logger');
-                    skillLogger.addLog(context, 'ERROR', error.message);
-                }
-            }
-        };
-        // Event onerror: Erreur
-        this.ws.onerror = async (err)=>{
-            var _this_ws;
-            try {
-                await engine.executePinsList(error, _extends({}, context, {
-                    error: err,
-                    websocket: this
-                }), `${context.__PATH__}.error`);
-            } catch (error) {
-                console.error(error);
-                const skillLogger = require('@digipair/skill-logger');
-                skillLogger.addLog(context, 'ERROR', error.message);
-            }
-            (_this_ws = this.ws) == null ? void 0 : _this_ws.close(); // Ferme la connexion en cas d'erreur
-        };
-        return this;
-    }
-    reconnectWebSocket(params, pinsSettingsList, context) {
-        if (this.retryCount >= this.maxRetries) {
-            return false;
-        }
-        setTimeout(()=>{
-            this.retryCount++;
-            this.retryInterval *= 2; // Double l'intervalle entre les tentatives
-            this.connect(params, pinsSettingsList, context);
-        }, this.retryInterval);
-        return true;
-    }
-    constructor(){
-        this.retryCount = 0;
-        this.ws = null;
-        this.cwssForceClose = false;
-    }
-};
-const connect = (params, pinsSettingsList, context)=>new ClientWebSocketService().connect(params, pinsSettingsList, context);
-const send = (params, pinsSettingsList, context)=>new ClientWebSocketService().send(params, pinsSettingsList, context);
-const close = (params, pinsSettingsList, context)=>new ClientWebSocketService().close(params, pinsSettingsList, context);
-
-exports.close = close;
-exports.connect = connect;
-exports.send = send;