camstreamerlib 3.1.0 → 3.2.1

package/CreatePackage.js

@@ -4,16 +4,19 @@ const AdmZip = require("adm-zip");
 const Path = require("path");
 const fs = require("fs");
 const child_process_1 = require("child_process");
+const productionModulesFolder = 'production_modules';
 function isDirectory(path) {
     const stat = fs.statSync(path);
     return stat.isDirectory();
 }
-const productionModulesFolder = 'production_modules';
-function getPackageVersion(folder) {
+function getPackageInfo(folder) {
     try {
         const manifest = fs.readFileSync(Path.join(folder, 'manifest.json'));
         const manifestParsed = JSON.parse(manifest.toString());
-        return manifestParsed.package_version.replace(/\./g, '_');
+        return {
+            packageName: manifestParsed.package_name,
+            packageVersion: manifestParsed.package_version.replace(/\./g, '_'),
+        };
     }
     catch (err) {
         console.error('Get package version:', err);
@@ -81,8 +84,12 @@ function main(args) {
         options.typeScriptPackage = true;
     }
     const folder = Path.resolve('.');
-    const packageVersion = getPackageVersion(folder);
-    const zipFile = `${options.outputFolder}/${Path.basename(folder)}_${packageVersion}.zip`;
+    const packageInfo = getPackageInfo(folder);
+    if (packageInfo === undefined) {
+        console.error('Package info not found');
+        process.exit(1);
+    }
+    const zipFile = `${options.outputFolder}/${packageInfo.packageName}_${packageInfo.packageVersion}.zip`;
     if (fs.existsSync(zipFile)) {
         try {
             fs.unlinkSync(zipFile);

package/DefaultAgent.d.ts

@@ -1,15 +1,15 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { Options, IClient } from './internal/common';
+import { IClient, HttpOptions } from './internal/common';
 export declare class DefaultAgent implements IClient {
     private tls;
-    private tlsInsecure;
     private ip;
     private port;
     private user;
     private pass;
-    constructor(opt?: Options);
-    private getBaseConnectionParams;
+    private httpRequestSender;
+    constructor(opt?: HttpOptions);
     get(path: string, parameters?: Record<string, string>, headers?: Record<string, string>): Promise<Response>;
     post(path: string, data: string | Buffer | FormData, parameters?: Record<string, string>, headers?: Record<string, string>): Promise<Response>;
+    private getBaseConnectionParams;
 }

package/DefaultAgent.js

@@ -10,22 +10,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultAgent = void 0;
-const HttpRequest_1 = require("./internal/HttpRequest");
-function isBrowserEnvironment() {
-    return typeof process === 'undefined' || process.versions === null || process.versions.node === null;
-}
+const HttpRequestSender_1 = require("./internal/HttpRequestSender");
 class DefaultAgent {
     constructor(opt = {}) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         this.tls = (_a = opt.tls) !== null && _a !== void 0 ? _a : false;
-        this.tlsInsecure = (_b = opt.tlsInsecure) !== null && _b !== void 0 ? _b : false;
-        this.ip = (_c = opt.ip) !== null && _c !== void 0 ? _c : '127.0.0.1';
-        this.port = (_d = opt.port) !== null && _d !== void 0 ? _d : (this.tls ? 443 : 80);
-        this.user = (_e = opt.user) !== null && _e !== void 0 ? _e : '';
-        this.pass = (_f = opt.pass) !== null && _f !== void 0 ? _f : '';
-        if (isBrowserEnvironment() && opt.tlsInsecure) {
-            throw new Error("HTTPS insecure can't be used on the frontend side.");
+        this.ip = (_b = opt.ip) !== null && _b !== void 0 ? _b : '127.0.0.1';
+        this.port = (_c = opt.port) !== null && _c !== void 0 ? _c : (this.tls ? 443 : 80);
+        this.user = (_d = opt.user) !== null && _d !== void 0 ? _d : '';
+        this.pass = (_e = opt.pass) !== null && _e !== void 0 ? _e : '';
+        let agentOptions;
+        if (opt.tlsInsecure !== undefined || opt.keepAlive !== undefined) {
+            agentOptions = {
+                rejectUnaurhorized: !opt.tlsInsecure,
+                keepAlive: opt.keepAlive,
+            };
         }
+        this.httpRequestSender = new HttpRequestSender_1.HttpRequestSender(agentOptions);
+    }
+    get(path, parameters = {}, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = this.getBaseConnectionParams('GET', path, parameters);
+            options.headers = headers;
+            return this.httpRequestSender.sendRequest(options);
+        });
+    }
+    post(path, data, parameters = {}, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = this.getBaseConnectionParams('POST', path, parameters);
+            options.headers = headers;
+            return this.httpRequestSender.sendRequest(options, data);
+        });
     }
     getBaseConnectionParams(method, path, params) {
         if (path.indexOf('?') === -1) {
@@ -46,22 +61,7 @@ class DefaultAgent {
             path: path,
             user: this.user,
             pass: this.pass,
-            rejectUnauthorized: !this.tlsInsecure,
         };
     }
-    get(path, parameters = {}, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = this.getBaseConnectionParams('GET', path, parameters);
-            options.headers = headers;
-            return (0, HttpRequest_1.sendRequest)(options);
-        });
-    }
-    post(path, data, parameters = {}, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = this.getBaseConnectionParams('POST', path, parameters);
-            options.headers = headers;
-            return (0, HttpRequest_1.sendRequest)(options, data);
-        });
-    }
 }
 exports.DefaultAgent = DefaultAgent;

package/README.md

@@ -14,13 +14,23 @@ npm install camstreamerlib
 # Documentation for Node.js modules
 
 -   [HttpServer](doc/HttpServer.md) is a module for processing HTTP requests in your scripts. It also automatically serves up the content from html directory or you can register paths which you can process by your own (e.g. http://$CAMERA_IP/local/camscripter/proxy/$MY_PACKAGE_NAME/control.cgi).
+
 -   [CameraVapix](doc/CameraVapix.md) is a module to access Axis camera VAPIX interface.
+
 -   [CamStreamerAPI](doc/CamStreamerAPI.md) is a module for easy control of video streaming in the CamStreamer ACAP application (RTMP, HLS, SRT and MPEG-TS protocols).
+
 -   [CamOverlayAPI](doc/CamOverlayAPI.md) is a module to access CamOverlay HTTP interface.
+
 -   [CamOverlayDrawingAPI](doc/CamOverlayDrawingAPI.md) is a module for easy control of CamOverlay drawing API. For more details on supported video overlay drawing functions see https://camstreamer.com/camoverlay-api1
--   [CamScripterAPICameraEventsGenerator](doc/CamScripterAPICameraEventsGenerator.md) is a module which allows generating events on an Axis camera. These events can be used for triggers in the Axis camera rule engine (events/actions). It is also an easy way how to integrate events and metadata in VMS systems which support Axis camera events.
+
 -   [CamOverlayPainter/](doc/CamOverlayPainter.md) contains three modules which makes easier to use CamOverlayDrawingAPI.
 
+-   [CamScripterAPICameraEventsGenerator](doc/CamScripterAPICameraEventsGenerator.md) is a module which allows generating events on an Axis camera. These events can be used for triggers in the Axis camera rule engine (events/actions). It is also an easy way how to integrate events and metadata in VMS systems which support Axis camera events.
+
+-   [CamSwitcherEvents](doc/CamSwitcherEvents.md) is a module which allows receiving events from CamSwitcher ACAP application.
+
+-   [VapixEvents](doc/VapixEvents.md) is a module which allows receiving camera events from the VAPIX API.
+
 ## For Developers
 
 ### Publishing to npm repository

package/VapixEvents.d.ts

@@ -1,16 +1,17 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { Options } from './internal/common';
-export type VapixEventsOptions = Options;
+import { WsOptions } from './internal/common';
+export type VapixEventsOptions = WsOptions;
 export declare class VapixEvents extends EventEmitter {
-    private ws?;
     private tls;
     private tlsInsecure;
     private ip;
     private port;
     private user;
     private pass;
+    private ws;
     constructor(options?: VapixEventsOptions);
     connect(): void;
     disconnect(): void;
+    private createWsClient;
     private isReservedEventName;
 }

package/VapixEvents.js

@@ -13,12 +13,16 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
         this.port = (_d = options.port) !== null && _d !== void 0 ? _d : (this.tls ? 443 : 80);
         this.user = (_e = options.user) !== null && _e !== void 0 ? _e : 'root';
         this.pass = (_f = options.pass) !== null && _f !== void 0 ? _f : '';
+        this.createWsClient();
         eventemitter2_1.EventEmitter2.call(this);
     }
     connect() {
-        if (this.ws !== undefined) {
-            throw new Error('Websocket is already opened.');
-        }
+        this.ws.open();
+    }
+    disconnect() {
+        this.ws.close();
+    }
+    createWsClient() {
         const options = {
             tls: this.tls,
             tlsInsecure: this.tlsInsecure,
@@ -30,7 +34,6 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
         };
         this.ws = new WsClient_1.WsClient(options);
         this.ws.on('open', () => {
-            var _a;
             const topics = [];
             const eventNames = this.eventNames();
             for (let i = 0; i < eventNames.length; i++) {
@@ -48,16 +51,16 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
                     eventFilterList: topics,
                 },
             };
-            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(topicFilter));
+            this.ws.send(JSON.stringify(topicFilter));
         });
         this.ws.on('message', (data) => {
             const dataJSON = JSON.parse(data.toString());
             if (dataJSON.method === 'events:configure') {
                 if (dataJSON.error === undefined) {
-                    this.emit('eventsConnect');
+                    this.emit('open');
                 }
                 else {
-                    this.emit('eventsDisconnect', dataJSON.error);
+                    this.emit('error', dataJSON.error);
                     this.disconnect();
                 }
                 return;
@@ -66,24 +69,14 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
             this.emit(eventName, dataJSON);
         });
         this.ws.on('error', (error) => {
-            this.emit('eventsDisconnect', error);
-            this.ws = undefined;
+            this.emit('error', error);
         });
         this.ws.on('close', () => {
-            if (this.ws !== undefined) {
-                this.emit('eventsClose');
-            }
-            this.ws = undefined;
+            this.emit('close');
         });
-        this.ws.open();
-    }
-    disconnect() {
-        if (this.ws !== undefined) {
-            this.ws.close();
-        }
     }
     isReservedEventName(eventName) {
-        return eventName === 'eventsConnect' || eventName === 'eventsDisconnect' || eventName === 'eventsClose';
+        return eventName === 'open' || eventName === 'close' || eventName === 'error';
     }
 }
 exports.VapixEvents = VapixEvents;

package/events/AxisCameraStationEvents.d.ts

@@ -1,5 +1,5 @@
-import { IClient, Options } from '../internal/common';
-export type AcsEventsOptions = Options;
+import { IClient, HttpOptions } from '../internal/common';
+export type AcsEventsOptions = HttpOptions;
 export declare class AxisCameraStationEvents {
     private sourceKey;
     private client;

package/internal/Digest.d.ts

@@ -1,3 +1,4 @@
 export declare class Digest {
-    static getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string): string;
+    private nonceCount;
+    getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string): string;
 }

package/internal/Digest.js

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Digest = void 0;
 const crypto = require("crypto");
 class Digest {
-    static getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {
+    constructor() {
+        this.nonceCount = 1;
+    }
+    getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {
         const digestItems = {};
         const digestArr = wwwAuthenticateHeader.substring(wwwAuthenticateHeader.indexOf('Digest') + 6).split(',');
         for (let i = 0; i < digestArr.length; i++) {
@@ -14,11 +17,12 @@ class Digest {
         }
         const HA1 = crypto.createHash('md5').update(`${user}:${digestItems['realm']}:${pass}`).digest('hex');
         const HA2 = crypto.createHash('md5').update(`${method}:${uri}`).digest('hex');
+        const ncValue = ('00000000' + this.nonceCount.toString(16)).slice(-8);
         let response;
         if (digestItems['qop'] !== undefined) {
             response = crypto
                 .createHash('md5')
-                .update(`${HA1}:${digestItems['nonce']}:00000001:162d50aa594e9648:auth:${HA2}`)
+                .update(`${HA1}:${digestItems['nonce']}:${ncValue}:162d50aa594e9648:auth:${HA2}`)
                 .digest('hex');
         }
         else {
@@ -31,8 +35,9 @@ class Digest {
             `uri="${uri}",` +
             `response="${response}"`;
         if (digestItems['qop'] !== undefined) {
-            header += ',qop=auth,nc=00000001,cnonce="162d50aa594e9648"';
+            header += `,qop=auth,nc=${ncValue},cnonce="162d50aa594e9648"`;
         }
+        this.nonceCount++;
         return header;
     }
 }

package/internal/HttpRequestSender.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type HttpRequestOptions = {
+    method?: string;
+    protocol: string;
+    host: string;
+    port: number;
+    path: string;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+};
+export type AgentOptions = {
+    rejectUnaurhorized?: boolean;
+    keepAlive?: boolean;
+};
+export declare class HttpRequestSender {
+    private agent?;
+    private authData?;
+    constructor(agentOptions?: AgentOptions);
+    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | FormData): Promise<Response>;
+    private sendRequestWithAuth;
+    private static getURL;
+    private getAuthorization;
+    private invalidateAuthorization;
+    private static getAuthHeader;
+}

package/internal/HttpRequestSender.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestSender = void 0;
+const Digest_1 = require("./Digest");
+const undici_1 = require("undici");
+const common_1 = require("./common");
+class HttpRequestSender {
+    constructor(agentOptions) {
+        if ((0, common_1.isBrowserEnvironment)()) {
+            if (agentOptions !== undefined) {
+                throw new Error('Agent options can be specified only in Node.js environment.');
+            }
+        }
+        else {
+            this.agent = new undici_1.Agent({
+                connect: { rejectUnauthorized: agentOptions === null || agentOptions === void 0 ? void 0 : agentOptions.rejectUnaurhorized, keepAlive: agentOptions === null || agentOptions === void 0 ? void 0 : agentOptions.keepAlive },
+            });
+        }
+    }
+    sendRequest(options, postData) {
+        return this.sendRequestWithAuth(options, postData);
+    }
+    sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = HttpRequestSender.getURL(options);
+            const controller = new AbortController();
+            if (options.timeout !== undefined) {
+                setTimeout(() => controller.abort(new Error('Request timeout')), options.timeout);
+            }
+            const authorization = this.getAuthorization(options, wwwAuthenticateHeader);
+            if (authorization !== undefined) {
+                (_a = options.headers) !== null && _a !== void 0 ? _a : (options.headers = {});
+                options.headers['Authorization'] = authorization;
+            }
+            let res;
+            if (this.agent) {
+                const req = new undici_1.Request(url, { body: postData, method: options.method, headers: options.headers });
+                res = yield (0, undici_1.fetch)(req, { signal: controller.signal, dispatcher: this.agent });
+            }
+            else {
+                const req = new Request(url, { body: postData, method: options.method, headers: options.headers });
+                res = yield fetch(req, { signal: controller.signal });
+            }
+            if (!res.ok) {
+                this.invalidateAuthorization();
+            }
+            if (res.status === 401) {
+                const authenticateHeader = res.headers.get('www-authenticate');
+                if (authenticateHeader !== null &&
+                    authenticateHeader.indexOf('Digest') !== -1 &&
+                    wwwAuthenticateHeader === undefined) {
+                    return this.sendRequestWithAuth(options, postData, authenticateHeader);
+                }
+                else {
+                    return res;
+                }
+            }
+            else {
+                return res;
+            }
+        });
+    }
+    static getURL(options) {
+        const url = new URL(`${options.protocol}//${options.host}:${options.port}${options.path}`);
+        return url.toString();
+    }
+    getAuthorization(options, wwwAuthenticateHeader) {
+        if (options.user === undefined || options.pass === undefined) {
+            this.authData = undefined;
+            return;
+        }
+        if (this.authData &&
+            (this.authData.host !== options.host ||
+                this.authData.port !== options.port ||
+                this.authData.user !== options.user ||
+                this.authData.pass !== options.pass ||
+                (wwwAuthenticateHeader !== undefined && this.authData.wwwAuthenticateHeader !== wwwAuthenticateHeader))) {
+            this.authData = undefined;
+        }
+        if (this.authData === undefined) {
+            this.authData = {
+                host: options.host,
+                port: options.port,
+                user: options.user,
+                pass: options.pass,
+                wwwAuthenticateHeader,
+                digest: new Digest_1.Digest(),
+            };
+        }
+        return HttpRequestSender.getAuthHeader(options, this.authData);
+    }
+    invalidateAuthorization() {
+        this.authData = undefined;
+    }
+    static getAuthHeader(options, authData) {
+        var _a;
+        if (options.user === undefined || options.pass === undefined) {
+            throw new Error('No credentials found');
+        }
+        if (authData.wwwAuthenticateHeader !== undefined && authData.wwwAuthenticateHeader.indexOf('Digest') !== -1) {
+            return authData.digest.getAuthHeader(options.user, options.pass, (_a = options.method) !== null && _a !== void 0 ? _a : 'GET', options.path, authData.wwwAuthenticateHeader);
+        }
+        else {
+            return `Basic ${btoa(options.user + ':' + options.pass)}`;
+        }
+    }
+}
+exports.HttpRequestSender = HttpRequestSender;

package/internal/WsClient.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as EventEmitter from 'events';
-import { Options } from './common';
-export type WsClientOptions = Options & {
+import { WsOptions } from './common';
+export type WsClientOptions = WsOptions & {
     address: string;
     headers?: Record<string, string>;
     pingInterval?: number;
@@ -19,9 +19,10 @@ export declare class WsClient extends EventEmitter {
     private isAlive;
     private pingTimer?;
     private ws?;
+    private isClosed;
     constructor(options: WsClientOptions);
-    open(digestHeader?: string): void;
+    open(wwwAuthenticateHeader?: string): void;
     send(data: Buffer | string): void;
     close(): void;
-    private handleCloseEvent;
+    private closeWsConnection;
 }

package/internal/WsClient.js

@@ -1,14 +1,25 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WsClient = void 0;
 const EventEmitter = require("events");
 const WebSocket = require("ws");
+const timersPromises = require("timers/promises");
 const Digest_1 = require("./Digest");
 class WsClient extends EventEmitter {
     constructor(options) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         super();
         this.isAlive = true;
+        this.isClosed = false;
         const tls = (_a = options === null || options === void 0 ? void 0 : options.tls) !== null && _a !== void 0 ? _a : false;
         const tlsInsecure = (_b = options === null || options === void 0 ? void 0 : options.tlsInsecure) !== null && _b !== void 0 ? _b : false;
         const ip = (_c = options === null || options === void 0 ? void 0 : options.ip) !== null && _c !== void 0 ? _c : '127.0.0.1';
@@ -26,7 +37,11 @@ class WsClient extends EventEmitter {
             headers: (_h = options.headers) !== null && _h !== void 0 ? _h : {},
         };
     }
-    open(digestHeader) {
+    open(wwwAuthenticateHeader) {
+        if (this.ws !== undefined) {
+            return;
+        }
+        this.isClosed = false;
         if (this.protocol === undefined) {
             this.ws = new WebSocket(this.address, this.wsOptions);
         }
@@ -35,39 +50,42 @@ class WsClient extends EventEmitter {
         }
         this.ws.binaryType = 'arraybuffer';
         this.isAlive = true;
-        this.pingTimer = setInterval(() => {
+        this.pingTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _a;
             if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
                 this.emit('error', new Error('Connection timeout'));
-                this.close();
+                yield this.closeWsConnection();
             }
             else {
                 this.isAlive = false;
                 (_a = this.ws) === null || _a === void 0 ? void 0 : _a.ping();
             }
-        }, this.pingInterval);
+        }), this.pingInterval);
         this.ws.on('pong', () => {
             this.isAlive = true;
         });
-        if (digestHeader !== undefined) {
-            this.wsOptions.headers['Authorization'] = Digest_1.Digest.getAuthHeader(this.user, this.pass, 'GET', this.digestAddress, digestHeader);
+        if (wwwAuthenticateHeader !== undefined) {
+            this.wsOptions.headers['Authorization'] = new Digest_1.Digest().getAuthHeader(this.user, this.pass, 'GET', this.digestAddress, wwwAuthenticateHeader);
         }
-        this.ws.on('unexpected-response', (req, res) => {
+        this.ws.on('unexpected-response', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _b;
             if (res.statusCode === 401 && res.headers['www-authenticate'] !== undefined) {
                 if (this.pingTimer) {
                     clearInterval(this.pingTimer);
                 }
+                (_b = this.ws) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
+                this.ws = undefined;
                 this.open(res.headers['www-authenticate']);
             }
             else {
-                const e = new Error('Status code: ' + res.statusCode);
-                this.emit('error', e);
+                this.emit('error', new Error('Status code: ' + res.statusCode));
+                yield this.closeWsConnection();
             }
-        });
+        }));
         this.ws.on('open', () => this.emit('open'));
         this.ws.on('message', (data) => this.emit('message', data));
         this.ws.on('error', (error) => this.emit('error', error));
-        this.ws.on('close', () => this.handleCloseEvent());
+        this.ws.on('close', () => this.closeWsConnection());
     }
     send(data) {
         if (this.ws === undefined) {
@@ -78,30 +96,45 @@ class WsClient extends EventEmitter {
         }
     }
     close() {
-        if (this.ws === undefined) {
-            throw new Error("This websocket hasn't been opened yet.");
-        }
-        try {
-            this.handleCloseEvent();
-            if (this.ws.readyState !== WebSocket.CLOSING && this.ws.readyState !== WebSocket.CLOSED) {
-                this.ws.close();
-            }
-        }
-        catch (err) {
+        if (this.isClosed) {
+            return;
         }
+        this.isClosed = true;
+        const currentWs = this.ws;
+        this.closeWsConnection().catch((err) => {
+            console.error(err);
+        });
         setTimeout(() => {
-            if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
-                this.ws.terminate();
+            if (currentWs && currentWs.readyState !== WebSocket.CLOSED) {
+                currentWs.terminate();
             }
         }, 5000);
     }
-    handleCloseEvent() {
-        var _a;
-        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
-        if (this.pingTimer) {
-            clearInterval(this.pingTimer);
-        }
-        this.emit('close');
+    closeWsConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.ws === undefined) {
+                    return;
+                }
+                this.ws.removeAllListeners();
+                if (this.pingTimer) {
+                    clearInterval(this.pingTimer);
+                }
+                if (this.ws.readyState !== WebSocket.CONNECTING &&
+                    this.ws.readyState !== WebSocket.CLOSING &&
+                    this.ws.readyState !== WebSocket.CLOSED) {
+                    this.ws.close();
+                }
+                this.ws = undefined;
+                this.emit('close');
+                if (!this.isClosed) {
+                    yield timersPromises.setTimeout(10000);
+                    yield this.open();
+                }
+            }
+            catch (err) {
+            }
+        });
     }
 }
 exports.WsClient = WsClient;

package/internal/common.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-export type Options = {
+type Options = {
     ip?: string;
     port?: number;
     user?: string;
@@ -8,6 +8,10 @@ export type Options = {
     tls?: boolean;
     tlsInsecure?: boolean;
 };
+export type HttpOptions = Options & {
+    keepAlive?: boolean;
+};
+export type WsOptions = Options;
 export type TGetFunction = (url: string, parameters?: Record<string, string>, headers?: Record<string, string>) => Promise<Response>;
 export type TPostFunction = (url: string, data: string | Buffer | FormData, parameters?: Record<string, string>, headers?: Record<string, string>) => Promise<Response>;
 export interface IClient {
@@ -15,3 +19,5 @@ export interface IClient {
     post: TPostFunction;
 }
 export declare function isClient(arg?: Options | IClient): arg is IClient;
+export declare function isBrowserEnvironment(): boolean;
+export {};