camstreamerlib 4.0.0-beta.13 → 4.0.0-beta.130

package/esm/{CamOverlayDrawingAPI.js → node/CamOverlayDrawingAPI.js}

@@ -1,5 +1,5 @@
-import * as EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import { EventEmitter } from 'events';
+import { WsClient } from './WsClient';
 export class CamOverlayDrawingAPI extends EventEmitter {
     tls;
     tlsInsecure;
@@ -41,7 +41,7 @@ export class CamOverlayDrawingAPI extends EventEmitter {
         this.startMsgsTimeoutCheck();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
         this.stopMsgsTimeoutCheck();
     }
     isConnected() {
@@ -98,23 +98,23 @@ export class CamOverlayDrawingAPI extends EventEmitter {
             tlsInsecure: this.tlsInsecure,
         };
         this.ws = new WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             console.log('CamOverlay connection opened');
             this.wsConnected = true;
             this.emit('open');
-        });
-        this.ws.on('message', (msgData) => this.incomingWsMessageHandler(msgData));
-        this.ws.on('error', (error) => {
+        };
+        this.ws.onMessage = (data) => this.incomingWsMessageHandler(data.toString());
+        this.ws.onError = (error) => {
             this.reportError(error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             console.log('CamOverlay connection closed');
             this.wsConnected = false;
             this.reportClose();
-        });
+        };
     }
     incomingWsMessageHandler(msgData) {
-        const dataJSON = JSON.parse(msgData.toString());
+        const dataJSON = JSON.parse(msgData);
         let errorResponse;
         if ('error' in dataJSON) {
             errorResponse = dataJSON;
@@ -165,13 +165,21 @@ export class CamOverlayDrawingAPI extends EventEmitter {
                     throw new Error('No CamOverlay connection');
                 }
                 msgJson.call_id = ++this.callId;
-                const jsonBuffer = Buffer.from(JSON.stringify(msgJson));
-                const header = new ArrayBuffer(5);
-                const headerView = new DataView(header);
-                headerView.setInt8(0, 1);
-                headerView.setInt32(1, jsonBuffer.byteLength);
-                const msgBuffer = Buffer.concat([Buffer.from(header), jsonBuffer, data]);
-                this.ws.send(msgBuffer);
+                const jsonString = JSON.stringify(msgJson);
+                const jsonByteLength = Buffer.byteLength(jsonString);
+                const headerLength = 5;
+                const totalLength = headerLength + jsonByteLength + data.byteLength;
+                const arrayBuffer = new ArrayBuffer(totalLength);
+                const view = new DataView(arrayBuffer);
+                view.setInt8(0, 1);
+                view.setInt32(1, jsonByteLength);
+                const jsonBuffer = new Uint8Array(arrayBuffer, 5, jsonByteLength);
+                for (let i = 0; i < jsonString.length; i++) {
+                    jsonBuffer[i] = jsonString.charCodeAt(i);
+                }
+                const dataBuffer = new Uint8Array(arrayBuffer, 5 + jsonByteLength, data.byteLength);
+                data.copy(dataBuffer);
+                this.ws.send(arrayBuffer);
                 this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
             }
             catch (err) {

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/Frame.js

@@ -54,6 +54,14 @@ export class Frame extends EventEmitter {
         this.width = width;
         this.height = height;
     }
+    getFrameInfo() {
+        return {
+            x: this.posX,
+            y: this.posY,
+            width: this.width,
+            height: this.height,
+        };
+    }
     setText(text, align, textType = 'TFM_OVERFLOW', fontColor) {
         this.text = text;
         this.align = align;
@@ -73,6 +81,16 @@ export class Frame extends EventEmitter {
         this.fontName = undefined;
         this.font = fontData;
     }
+    getTextInfo() {
+        return {
+            text: this.text,
+            textAlign: this.align,
+            textType: this.textType,
+            fontColor: this.fontColor,
+            font: this.font,
+            fontName: this.fontName,
+        };
+    }
     setBgColor(color) {
         this.bgColor = color;
     }
@@ -89,6 +107,14 @@ export class Frame extends EventEmitter {
     setBgType(type) {
         this.bgType = type;
     }
+    getBgInfo() {
+        return {
+            bgColor: this.bgColor,
+            bgImage: this.bgImage,
+            bgImageName: this.bgImageName,
+            bgType: this.bgType,
+        };
+    }
     setBorderRadius(radius) {
         this.borderRadius = radius;
     }
@@ -98,6 +124,13 @@ export class Frame extends EventEmitter {
     setBorderColor(color) {
         this.borderColor = color;
     }
+    getBorderInfo() {
+        return {
+            borderRadius: this.borderRadius,
+            borderWidth: this.borderWidth,
+            borderColor: this.borderColor,
+        };
+    }
     setCustomDraw(customDraw) {
         this.customDraw = customDraw;
     }

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/Painter.js

@@ -1,17 +1,7 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
+import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
-export const COORD = {
-    top_left: [-1, -1],
-    center_left: [-1, 0],
-    bottom_left: [-1, 1],
-    top_center: [0, -1],
-    center: [0, 0],
-    bottom_center: [0, 1],
-    top_right: [1, -1],
-    center_right: [1, 0],
-    bottom_right: [1, 1],
-};
+import { COORD } from '../../types/CamOverlayPainter';
 export class Painter extends Frame {
     screenWidth;
     screenHeight;
@@ -163,4 +153,3 @@ export class Painter extends Frame {
         }
     }
 }
-export { Frame, ResourceManager };

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/ResourceManager.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs/promises';
-export default class ResourceManager {
+export class ResourceManager {
     co;
     imgFileNames = {};
     fontFileNames = {};
@@ -18,8 +18,9 @@ export default class ResourceManager {
         if (this.images[moniker] !== undefined) {
             return this.images[moniker];
         }
-        if (this.imgFileNames[moniker] !== undefined) {
-            const imgData = await fs.readFile(this.imgFileNames[moniker]);
+        const path = this.imgFileNames[moniker];
+        if (path !== undefined) {
+            const imgData = await fs.readFile(path);
             this.images[moniker] = await this.co.uploadImageData(imgData);
             return this.images[moniker];
         }
@@ -29,8 +30,9 @@ export default class ResourceManager {
         if (this.fonts[moniker] !== undefined) {
             return this.fonts[moniker];
         }
-        if (this.fontFileNames[moniker] !== undefined) {
-            const fontData = await fs.readFile(this.fontFileNames[moniker]);
+        const path = this.fontFileNames[moniker];
+        if (path !== undefined) {
+            const fontData = await fs.readFile(path);
             this.fonts[moniker] = await this.co.uploadFontData(fontData);
             return this.fonts[moniker];
         }

package/esm/{CamScripterAPICameraEventsGenerator.js → node/CamScripterAPICameraEventsGenerator.js}

@@ -1,5 +1,5 @@
-import * as EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import { EventEmitter } from 'events';
+import { WsClient } from './WsClient';
 export class CamScripterAPICameraEventsGenerator extends EventEmitter {
     tls;
     tlsInsecure;
@@ -31,7 +31,7 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
         this.startMsgsTimeoutCheck();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
         this.stopMsgsTimeoutCheck();
     }
     declareEvent(eventDeclaration) {
@@ -67,21 +67,21 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
             protocol: 'camera-events',
         };
         this.ws = new WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             this.wsConnected = true;
             this.emit('open');
-        });
-        this.ws.on('message', (msgData) => this.incomingWsMessageHandler(msgData));
-        this.ws.on('error', (error) => {
+        };
+        this.ws.onMessage = (data) => this.incomingWsMessageHandler(data.toString());
+        this.ws.onError = (error) => {
             this.reportErr(error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             this.wsConnected = false;
             this.reportClose();
-        });
+        };
     }
     incomingWsMessageHandler(msgData) {
-        const dataJSON = JSON.parse(msgData.toString());
+        const dataJSON = JSON.parse(msgData);
         let errorResponse;
         if ('error' in dataJSON) {
             errorResponse = dataJSON;

package/esm/node/DefaultClient.js

@@ -22,31 +22,27 @@ export class DefaultClient {
         }
         this.httpRequestSender = new HttpRequestSender(agentOptions);
     }
-    get url() {
-        return `${this.tls ? 'https' : 'http'}://${this.user}:${this.pass}@${this.ip}:${this.port}`;
-    }
-    get = (...params) => {
-        const [path, parameters, headers] = params;
-        const options = this.getBaseConnectionParams('GET', path, parameters ?? {});
-        options.headers = headers;
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const options = this.getBaseConnectionParams('GET', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options);
-    };
-    post = (...params) => {
-        const [path, data, parameters, headers] = params;
-        const options = this.getBaseConnectionParams('POST', path, parameters ?? {});
-        options.headers = headers;
+    }
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const options = this.getBaseConnectionParams('POST', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options, data);
-    };
-    getBaseConnectionParams(method, path, params) {
-        const pathName = addParametersToPath(path, params);
+    }
+    getBaseConnectionParams(method, path, params, headers, timeout) {
         return {
             method: method,
             protocol: this.tls ? 'https:' : 'http:',
             host: this.ip,
             port: this.port,
-            path: pathName,
+            path: addParametersToPath(path, params),
             user: this.user,
             pass: this.pass,
+            headers,
+            timeout,
         };
     }
 }

package/esm/node/Digest.test.js

@@ -0,0 +1,11 @@
+import { Digest } from './Digest';
+import { describe, test, expect } from '@jest/globals';
+describe('Digest', () => {
+    describe('getAuthHeader', () => {
+        test('Checks, that Digest.getAuthHeader() returns correct value.', () => {
+            const testString = 'Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41"';
+            const value = 'Digest username="root",realm="testrealm@host.com",nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",uri="www.cz",response="63f54af3ce5cf193a7435d5c68625472",qop=auth,nc=00000001,cnonce="162d50aa594e9648"';
+            expect(new Digest().getAuthHeader('root', 'pass', 'GET', 'www.cz', testString)).toBe(value);
+        });
+    });
+});

package/esm/node/HttpRequestSender.js

@@ -1,4 +1,4 @@
-import { Digest } from '../internal/Digest';
+import { Digest } from './Digest';
 import { Agent, fetch as undiciFetch, Request as UndiciRequest, } from 'undici';
 export class HttpRequestSender {
     agent;
@@ -8,8 +8,18 @@ export class HttpRequestSender {
             connect: { rejectUnauthorized: agentOptions?.rejectUnaurhorized, keepAlive: agentOptions?.keepAlive },
         });
     }
-    sendRequest(options, postData) {
-        return this.sendRequestWithAuth(options, postData);
+    async sendRequest(options, postData) {
+        const stackHolder = { stack: '' };
+        Error.captureStackTrace(stackHolder, this.sendRequest);
+        try {
+            return await this.sendRequestWithAuth(options, postData);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                err.stack = `${err.stack}\nCaptured at:\n${stackHolder.stack}`;
+            }
+            throw err;
+        }
     }
     async sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
         options.timeout ??= 10000;
@@ -79,7 +89,7 @@ export class HttpRequestSender {
             return authData.digest.getAuthHeader(options.user, options.pass, options.method ?? 'GET', options.path, authData.wwwAuthenticateHeader);
         }
         else {
-            return `Basic ${btoa(options.user + ':' + options.pass)}`;
+            return `Basic ${Buffer.from(`${options.user}:${options.pass}`).toString('base64')}`;
         }
     }
 }

package/esm/node/HttpServer.js

@@ -2,7 +2,7 @@ import * as http from 'http';
 import * as url from 'url';
 import * as fs from 'fs';
 import * as path from 'path';
-import * as EventEmitter from 'events';
+import { EventEmitter } from 'events';
 export class HttpServer extends EventEmitter {
     host;
     port;

package/esm/node/TimeZoneDaemon.js

@@ -0,0 +1,25 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execPromise = promisify(exec);
+export class TimeZoneDaemon {
+    checkTimer;
+    constructor(checkInterval = 60000) {
+        this.checkTimer = setInterval(() => this.checkAndUpdateTimeZone(), checkInterval);
+    }
+    stop() {
+        clearInterval(this.checkTimer);
+    }
+    async checkAndUpdateTimeZone() {
+        try {
+            const { stdout } = await execPromise('timedatectl show -p Timezone --value');
+            const systemTimezone = stdout.toString().trim();
+            const nodeTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (systemTimezone !== nodeTimezone) {
+                process.env.TZ = systemTimezone;
+            }
+        }
+        catch (error) {
+            console.error('Error checking/updating timezone:', error);
+        }
+    }
+}

package/esm/{VapixEvents.js → node/VapixEvents.js}

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsClient } from './node/WsClient';
+import { WsClient } from './WsClient';
 export class VapixEvents extends EventEmitter {
     tls;
     tlsInsecure;
@@ -23,7 +23,7 @@ export class VapixEvents extends EventEmitter {
         this.ws.open();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
     }
     createWsClient() {
         const options = {
@@ -36,7 +36,7 @@ export class VapixEvents extends EventEmitter {
             address: '/vapix/ws-data-stream?sources=events',
         };
         this.ws = new WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             const topics = [];
             const eventNames = this.eventNames();
             for (const eventName of eventNames) {
@@ -55,8 +55,8 @@ export class VapixEvents extends EventEmitter {
                 },
             };
             this.ws.send(JSON.stringify(topicFilter));
-        });
-        this.ws.on('message', (data) => {
+        };
+        this.ws.onMessage = (data) => {
             const dataJSON = JSON.parse(data.toString());
             if (dataJSON.method === 'events:configure') {
                 if (dataJSON.error === undefined) {
@@ -70,13 +70,13 @@ export class VapixEvents extends EventEmitter {
             }
             const eventName = dataJSON.params.notification.topic;
             this.emit(eventName, dataJSON);
-        });
-        this.ws.on('error', (error) => {
+        };
+        this.ws.onError = (error) => {
             this.emit('error', error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             this.emit('close');
-        });
+        };
     }
     isReservedEventName(eventName) {
         return eventName === 'open' || eventName === 'close' || eventName === 'error';

package/esm/node/WsClient.js

@@ -1,7 +1,6 @@
-import * as EventEmitter from 'events';
-import * as WebSocket from 'ws';
-import { Digest } from '../internal/Digest';
-export class WsClient extends EventEmitter {
+import { WebSocket } from 'ws';
+import { Digest } from './Digest';
+export class WsClient {
     user;
     pass;
     address;
@@ -14,7 +13,6 @@ export class WsClient extends EventEmitter {
     ws;
     isClosed = false;
     constructor(options) {
-        super();
         const tls = options.tls ?? false;
         const tlsInsecure = options.tlsInsecure ?? false;
         const ip = options.ip ?? '127.0.0.1';
@@ -46,10 +44,10 @@ export class WsClient extends EventEmitter {
             }
             this.ws.binaryType = 'arraybuffer';
             this.isAlive = true;
-            this.pingTimer = setInterval(async () => {
+            this.pingTimer = setInterval(() => {
                 if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
-                    this.emit('error', new Error('Connection timeout'));
-                    await this.closeWsConnection();
+                    this.onError(new Error('Connection timeout'));
+                    this.closeWsConnection();
                 }
                 else {
                     this.isAlive = false;
@@ -72,23 +70,32 @@ export class WsClient extends EventEmitter {
                     this.open(res.headers['www-authenticate']);
                 }
                 else {
-                    this.emit('error', new Error('Status code: ' + res.statusCode));
+                    this.onError(new Error('Status code: ' + res.statusCode));
                     this.closeWsConnection();
                 }
             });
-            this.ws.on('open', () => this.emit('open'));
-            this.ws.on('message', (data) => this.emit('message', data));
+            this.ws.on('open', () => this.onOpen());
+            this.ws.on('message', (data, isBinary) => {
+                const message = isBinary ? data : data.toString();
+                this.onMessage(message);
+            });
             this.ws.on('error', (error) => {
-                this.emit('error', error);
+                this.onError(error);
                 this.closeWsConnection();
             });
             this.ws.on('close', () => this.closeWsConnection());
         }
         catch (error) {
-            this.emit('error', error instanceof Error ? error : new Error('Unknown error'));
+            this.onError(error instanceof Error ? error : new Error('Unknown error'));
             this.closeWsConnection();
         }
     }
+    onMessage = (_) => { };
+    onOpen = () => { };
+    onClose = () => { };
+    onError = (error) => {
+        console.error(error);
+    };
     send(data) {
         if (this.ws === undefined) {
             throw new Error("This websocket hasn't been opened yet.");
@@ -97,7 +104,7 @@ export class WsClient extends EventEmitter {
             this.ws.send(data);
         }
     }
-    close() {
+    destroy() {
         if (this.isClosed) {
             return;
         }
@@ -127,7 +134,7 @@ export class WsClient extends EventEmitter {
                     wsCopy.terminate();
                 }
             }, 5000);
-            this.emit('close');
+            this.onClose();
         }
         catch (err) {
             console.error(err);

package/esm/{events → node/events}/AxisCameraStationEvents.js

@@ -1,18 +1,17 @@
-import { DefaultClient } from '../node/DefaultClient';
-import { isClient, pad } from '../internal/utils';
+import { pad } from '../../internal/utils';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { DefaultClient } from '../DefaultClient';
 export class AxisCameraStationEvents {
     sourceKey;
     client;
-    constructor(sourceKey, opt = {}) {
+    constructor(clientOptions, sourceKey) {
         this.sourceKey = sourceKey;
-        if (isClient(opt)) {
-            this.client = opt;
-        }
-        else {
-            this.client = new DefaultClient(opt);
-        }
+        this.client = new DefaultClient(clientOptions);
     }
-    async sendEvent(data, eventType) {
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async sendEvent(data, eventType, options) {
         const dateString = this.getDate();
         const event = {
             addExternalDataRequest: {
@@ -23,9 +22,15 @@ export class AxisCameraStationEvents {
             },
         };
         const eventData = JSON.stringify(event);
-        const res = await this.client.post('/Acs/Api/ExternalDataFacade/AddExternalData', eventData, undefined, {
-            'Content-Type': 'application/json',
-            'Content-Length': eventData.length.toString(),
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/Acs/Api/ExternalDataFacade/AddExternalData',
+            data: eventData,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': eventData.length.toString(),
+            },
+            timeout: options?.timeout,
         });
         if (!res.ok) {
             throw new Error(`ACS status code: ${res.status}`);