camstreamerlib 4.0.0-beta.16 → 4.0.0-beta.161

package/{esm → cjs/node}/CamOverlayPainter/Frame.d.ts

@@ -1,42 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { CamOverlayDrawingAPI, TAlign, TCairoCreateResponse, TUploadImageResponse } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-export type TRgb = [number, number, number];
-export type TRgba = [number, number, number, number];
-export type TTmf = 'TFM_OVERFLOW' | 'TFM_SCALE' | 'TFM_TRUNCATE';
-export type TObjectFitType = 'fill' | 'fit' | 'none';
-export type TFrameOptions = {
-    enabled?: boolean;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    text?: string;
-    fontColor?: TRgb;
-    font?: string;
-    bgColor?: TRgba;
-    bgImage?: string;
-    bgType?: TObjectFitType;
-    borderRadius?: number;
-    borderWidth?: number;
-    borderColor?: TRgba;
-    customDraw?: TDrawingCallback;
-    layer?: number;
-};
-export type TFrameInfo = {
-    width: number;
-    height: number;
-};
-export type TDrawingCallback = (cod: CamOverlayDrawingAPI, cairo: string, info: TFrameInfo) => Promise<void>;
-export interface Frame {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'layoutChanged', listener: () => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'layoutChanged'): boolean;
-}
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TAlign, TCairoCreateResponse, TUploadImageResponse } from '../../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { TBg, TBorder, TDrawingCallback, TFrame, TFrameOptions, TObjectFitType, TRgb, TRgba, TText, TTmf } from '../../types/CamOverlayPainter';
 export declare class Frame extends EventEmitter {
     protected enabled: boolean;
     protected posX: number;
@@ -64,17 +31,21 @@ export declare class Frame extends EventEmitter {
     disable(): void;
     setFramePosition(x: number, y: number): void;
     setFrameSize(width: number, height: number): void;
+    getFrameInfo(): TFrame;
     setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
     setFontColor(fontColor: TRgb): void;
     setFont(fontName: string): void;
     setFontData(fontData: TCairoCreateResponse): void;
+    getTextInfo(): TText;
     setBgColor(color: TRgba): void;
     setBgImage(imageName: string, type?: TObjectFitType): void;
     setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
     setBgType(type: TObjectFitType): void;
+    getBgInfo(): TBg;
     setBorderRadius(radius: number): void;
     setBorderWidth(width: number): void;
     setBorderColor(color: TRgba): void;
+    getBorderInfo(): TBorder;
     setCustomDraw(customDraw: TDrawingCallback): void;
     resetFont(): void;
     resetBgColor(): void;

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

@@ -57,6 +57,14 @@ class Frame extends events_1.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;
@@ -76,6 +84,16 @@ class Frame extends events_1.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;
     }
@@ -92,6 +110,14 @@ class Frame extends events_1.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;
     }
@@ -101,6 +127,13 @@ class Frame extends events_1.EventEmitter {
     setBorderColor(color) {
         this.borderColor = color;
     }
+    getBorderInfo() {
+        return {
+            borderRadius: this.borderRadius,
+            borderWidth: this.borderWidth,
+            borderColor: this.borderColor,
+        };
+    }
     setCustomDraw(customDraw) {
         this.customDraw = customDraw;
     }

package/cjs/{CamOverlayPainter → node/CamOverlayPainter}/Painter.d.ts

@@ -1,23 +1,8 @@
-import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-import { Frame, TFrameOptions } from './Frame';
-export declare const COORD: {
-    readonly top_left: readonly [-1, -1];
-    readonly center_left: readonly [-1, 0];
-    readonly bottom_left: readonly [-1, 1];
-    readonly top_center: readonly [0, -1];
-    readonly center: readonly [0, 0];
-    readonly bottom_center: readonly [0, 1];
-    readonly top_right: readonly [1, -1];
-    readonly center_right: readonly [1, 0];
-    readonly bottom_right: readonly [1, 1];
-};
-type TCoAlignment = keyof typeof COORD;
-export type TPainterOptions = TFrameOptions & {
-    screenWidth: number;
-    screenHeight: number;
-    coAlignment: TCoAlignment;
-};
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { CamOverlayDrawingOptions } from '../../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { Frame } from './Frame';
+import { TCoAlignment, TPainterOptions } from '../../types/CamOverlayPainter';
 export declare class Painter extends Frame {
     private screenWidth;
     private screenHeight;
@@ -45,4 +30,3 @@ export declare class Painter extends Frame {
     private cleanupSurface;
     private positionConvertor;
 }
-export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

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

@@ -1,22 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceManager = exports.Frame = exports.Painter = exports.COORD = void 0;
+exports.Painter = void 0;
 const CamOverlayDrawingAPI_1 = require("../CamOverlayDrawingAPI");
 const ResourceManager_1 = require("./ResourceManager");
-exports.ResourceManager = ResourceManager_1.default;
 const Frame_1 = require("./Frame");
-Object.defineProperty(exports, "Frame", { enumerable: true, get: function () { return Frame_1.Frame; } });
-exports.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],
-};
+const CamOverlayPainter_1 = require("../../types/CamOverlayPainter");
 class Painter extends Frame_1.Frame {
     screenWidth;
     screenHeight;
@@ -27,11 +15,11 @@ class Painter extends Frame_1.Frame {
     layers = [];
     constructor(opt, coopt) {
         super(opt);
-        this.coAlignment = exports.COORD[opt.coAlignment];
+        this.coAlignment = CamOverlayPainter_1.COORD[opt.coAlignment];
         this.screenWidth = opt.screenWidth;
         this.screenHeight = opt.screenHeight;
         this.cod = new CamOverlayDrawingAPI_1.CamOverlayDrawingAPI(coopt);
-        this.rm = new ResourceManager_1.default(this.cod);
+        this.rm = new ResourceManager_1.ResourceManager(this.cod);
     }
     get camOverlayDrawingAPI() {
         return this.cod;
@@ -71,7 +59,7 @@ class Painter extends Frame_1.Frame {
         this.screenHeight = sh;
     }
     setCoAlignment(coAlignment) {
-        this.coAlignment = exports.COORD[coAlignment];
+        this.coAlignment = CamOverlayPainter_1.COORD[coAlignment];
     }
     layoutChanged() {
         this.refreshLayers = true;

package/cjs/node/CamOverlayPainter/ResourceManager.d.ts

@@ -0,0 +1,15 @@
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TUploadImageResponse, TCairoCreateResponse } from '../../types/CamOverlayDrawingAPI';
+export declare class ResourceManager {
+    private co;
+    private imgFileNames;
+    private fontFileNames;
+    private images;
+    private fonts;
+    constructor(co: CamOverlayDrawingAPI);
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    image(moniker: string): Promise<TUploadImageResponse | undefined>;
+    font(moniker: string): Promise<TCairoCreateResponse | undefined>;
+    clear(): void;
+}

package/cjs/node/CamOverlayPainter/ResourceManager.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceManager = void 0;
+const fs = __importStar(require("fs/promises"));
+class ResourceManager {
+    co;
+    imgFileNames = {};
+    fontFileNames = {};
+    images = {};
+    fonts = {};
+    constructor(co) {
+        this.co = co;
+    }
+    registerImage(moniker, fileName) {
+        this.imgFileNames[moniker] = process.env.INSTALL_PATH + '/images/' + fileName;
+    }
+    registerFont(moniker, fileName) {
+        this.fontFileNames[moniker] = process.env.INSTALL_PATH + '/fonts/' + fileName;
+    }
+    async image(moniker) {
+        if (this.images[moniker] !== undefined) {
+            return this.images[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];
+        }
+        throw new Error('Error! Unknown image requested!');
+    }
+    async font(moniker) {
+        if (this.fonts[moniker] !== undefined) {
+            return this.fonts[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];
+        }
+        throw new Error('Error! Unknown font requested!');
+    }
+    clear() {
+        this.images = {};
+        this.fonts = {};
+    }
+}
+exports.ResourceManager = ResourceManager;

package/cjs/node/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Options } from '../internal/types';
+import { TCamScripterEvent, TEventDeclaration, TEventUndeclaration, TCamScripterResponse } from '../types/CamScripterAPICameraEventsGenerator';
+export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: Options);
+    connect(): void;
+    disconnect(): void;
+    declareEvent(eventDeclaration: TEventDeclaration): Promise<TCamScripterResponse>;
+    undeclareEvent(eventUndeclaration: TEventUndeclaration): Promise<TCamScripterResponse>;
+    sendEvent(event: TCamScripterEvent): Promise<TCamScripterResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportErr;
+    private reportClose;
+}

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamScripterAPICameraEventsGenerator = void 0;
-const EventEmitter = require("events");
-const WsClient_1 = require("./node/WsClient");
-class CamScripterAPICameraEventsGenerator extends EventEmitter {
+const events_1 = require("events");
+const WsClient_1 = require("./WsClient");
+class CamScripterAPICameraEventsGenerator extends events_1.EventEmitter {
     tls;
     tlsInsecure;
     ip;
@@ -27,14 +27,14 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
         this.sendMessages = {};
         this.wsConnected = false;
         this.createWsClient();
-        EventEmitter.call(this);
+        events_1.EventEmitter.call(this);
     }
     connect() {
         this.ws.open();
         this.startMsgsTimeoutCheck();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
         this.stopMsgsTimeoutCheck();
     }
     declareEvent(eventDeclaration) {
@@ -70,21 +70,21 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
             protocol: 'camera-events',
         };
         this.ws = new WsClient_1.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/cjs/node/DefaultClient.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
-import { IClient, HttpOptions, TParameters } from '../internal/types';
-import { Response as UndiciResponse } from 'undici';
-export declare class DefaultClient implements IClient<UndiciResponse> {
+/// <reference types="node" />
+import { IClient, HttpOptions, TGetParams, TPostParams } from '../internal/types';
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export declare class DefaultClient implements IClient<UndiciResponse, UndiciFormData | Buffer> {
     private tls;
     private ip;
     private port;
@@ -9,8 +10,7 @@ export declare class DefaultClient implements IClient<UndiciResponse> {
     private pass;
     private httpRequestSender;
     constructor(opt?: HttpOptions);
-    get url(): string;
-    get: (url: string, parameters?: TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<UndiciResponse>;
-    post: (url: string, data: string | Buffer | FormData, parameters?: TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<UndiciResponse>;
+    get(params: TGetParams): Promise<UndiciResponse>;
+    post(params: TPostParams<UndiciFormData | Buffer>): Promise<UndiciResponse>;
     private getBaseConnectionParams;
 }

package/cjs/node/DefaultClient.js

@@ -25,31 +25,27 @@ class DefaultClient {
         }
         this.httpRequestSender = new HttpRequestSender_1.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 = (0, utils_1.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: (0, utils_1.addParametersToPath)(path, params),
             user: this.user,
             pass: this.pass,
+            headers,
+            timeout,
         };
     }
 }

package/cjs/{internal → node}/Digest.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Digest = void 0;
-const crypto = require("crypto");
+const crypto = __importStar(require("crypto"));
 class Digest {
     nonceCount = 1;
     getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {

package/cjs/node/Digest.test.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Digest_1 = require("./Digest");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)('Digest', () => {
+    (0, globals_1.describe)('getAuthHeader', () => {
+        (0, globals_1.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"';
+            (0, globals_1.expect)(new Digest_1.Digest().getAuthHeader('root', 'pass', 'GET', 'www.cz', testString)).toBe(value);
+        });
+    });
+});

package/cjs/node/HttpRequestSender.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
 export type HttpRequestOptions = {
     method?: string;

package/cjs/node/HttpRequestSender.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpRequestSender = void 0;
-const Digest_1 = require("../internal/Digest");
+const Digest_1 = require("./Digest");
 const undici_1 = require("undici");
 class HttpRequestSender {
     agent;
@@ -11,8 +11,18 @@ 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;
@@ -82,7 +92,7 @@ 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/cjs/node/HttpServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as http from 'http';
-import * as EventEmitter from 'events';
+import { EventEmitter } from 'events';
 export type HttpServerOptions = {
     host?: string;
     port?: number;

package/cjs/node/HttpServer.js

@@ -1,12 +1,35 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpServer = void 0;
-const http = require("http");
-const url = require("url");
-const fs = require("fs");
-const path = require("path");
-const EventEmitter = require("events");
-class HttpServer extends EventEmitter {
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+class HttpServer extends events_1.EventEmitter {
     host;
     port;
     registeredPaths;

package/cjs/node/TimeZoneDaemon.d.ts

@@ -0,0 +1,6 @@
+export declare class TimeZoneDaemon {
+    private checkTimer?;
+    constructor(checkInterval?: number);
+    stop(): void;
+    private checkAndUpdateTimeZone;
+}

package/cjs/node/TimeZoneDaemon.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeZoneDaemon = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+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);
+        }
+    }
+}
+exports.TimeZoneDaemon = TimeZoneDaemon;

package/cjs/node/VapixEvents.d.ts

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