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

package/cjs/internal/ProxyClient.js

@@ -4,43 +4,37 @@ exports.ProxyClient = void 0;
 const utils_1 = require("./utils");
 class ProxyClient {
     client;
-    getProxyUrl;
-    constructor(client, getProxyUrl) {
+    proxyParams;
+    constructor(client, proxyParams) {
         this.client = client;
-        this.getProxyUrl = getProxyUrl;
+        this.proxyParams = proxyParams;
     }
-    get = (proxy, ...args) => {
-        const [path, parameters, headers] = args;
-        const url = (0, utils_1.addParametersToPath)(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.get(realUrl, {}, realHeaders);
-    };
-    post = (proxy, ...args) => {
-        const [path, data, parameters, headers] = args;
-        const url = (0, utils_1.addParametersToPath)(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.post(realUrl, data, {}, realHeaders);
-    };
-    getReal = (proxy, url, headers) => {
-        if (proxy !== null) {
-            return {
-                realUrl: this.getProxyUrl(),
-                realHeaders: {
-                    ...(headers ?? {}),
-                    'x-target-camera-protocol': proxy.port === 443 ? 'https' : 'http',
-                    'x-target-camera-path': url,
-                    'x-target-camera-ip': proxy.ip,
-                    'x-target-camera-mdns': proxy.mdnsName,
-                    'x-target-camera-port': String(proxy.port),
-                    'x-target-camera-pass': encodeURIComponent(proxy.pass),
-                    'x-target-camera-user': encodeURIComponent(proxy.user),
-                },
-            };
-        }
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const targetPath = (0, utils_1.addParametersToPath)(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.get({ path: realPath, headers: realHeaders, timeout });
+    }
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const targetPath = (0, utils_1.addParametersToPath)(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.post({ path: realPath, data, headers: realHeaders, timeout });
+    }
+    getReal(targetPath, headers) {
         return {
-            realUrl: url,
-            realHeaders: headers,
+            realPath: this.proxyParams.path,
+            realHeaders: {
+                ...(headers ?? {}),
+                'x-target-camera-protocol': this.proxyParams.target.port === 443 ? 'https' : 'http',
+                'x-target-camera-path': targetPath,
+                'x-target-camera-ip': this.proxyParams.target.ip,
+                'x-target-camera-mdns': this.proxyParams.target.mdnsName,
+                'x-target-camera-port': String(this.proxyParams.target.port),
+                'x-target-camera-pass': this.proxyParams.target.pass,
+                'x-target-camera-user': this.proxyParams.target.user,
+            },
         };
-    };
+    }
 }
 exports.ProxyClient = ProxyClient;

package/cjs/internal/WsEvents.d.ts

@@ -0,0 +1,38 @@
+import { IWsClient } from './types';
+type TEventType<T extends {
+    type: string;
+}> = T extends {
+    type: infer Type;
+} ? Type : never;
+type TEvent<T extends {
+    type: string;
+}, Type extends TEventType<T>> = T extends {
+    type: Type;
+} ? T : never;
+type TValidate<T extends {
+    type: string;
+}> = (data: string) => {
+    type: 'init';
+    data: TEvent<T, TEventType<T>>;
+} | TEvent<T, TEventType<T>>;
+type TListenerFunction<T extends {
+    type: string;
+}, Type extends TEventType<T>> = (data: TEvent<T, Type>, isInit: boolean) => void;
+export declare class WsEvents<T extends {
+    type: string;
+}> {
+    private validate;
+    ws: IWsClient;
+    private _isDestroyed;
+    private listeners;
+    constructor(validate: TValidate<T>, ws: IWsClient);
+    get isDestroyed(): boolean;
+    resendInitData(): void;
+    addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;
+    removeListener<Type extends TEventType<T>>(type: Type, id: string): void;
+    removeAllListenersForId(id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};

package/cjs/{CamSwitcherEvents.js → internal/WsEvents.js}

@@ -1,23 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamSwitcherEvents = void 0;
-const CamSwitcherEvents_1 = require("./types/CamSwitcherEvents");
-class CamSwitcherEvents {
-    isDestroyed = false;
-    ws = null;
+exports.WsEvents = void 0;
+class WsEvents {
+    validate;
+    ws;
+    _isDestroyed = false;
     listeners = {};
-    setWebsocket(ws) {
-        if (this.ws) {
-            this.ws.destroy();
-        }
+    constructor(validate, ws) {
+        this.validate = validate;
         this.ws = ws;
-        this.ws.onmessage = (e) => this.onMessage(e);
+        this.ws.onMessage = (e) => this.onMessage(e);
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
     }
     resendInitData() {
         const request = {
             command: 'sendInitData',
         };
-        this.ws?.send(JSON.stringify(request));
+        this.ws.send(JSON.stringify(request));
     }
     addListener(type, listener, id) {
         const typeList = this.listeners[type];
@@ -31,23 +32,31 @@ class CamSwitcherEvents {
         const typeList = this.listeners[type];
         if (typeList) {
             delete typeList[id];
+            if (Object.keys(typeList).length === 0) {
+                delete this.listeners[type];
+            }
         }
     }
-    onMessage(evt) {
+    removeAllListenersForId(id) {
+        for (const type in this.listeners) {
+            this.removeListener(type, id);
+        }
+    }
+    onMessage(incomeData) {
         if (this.isDestroyed) {
             return;
         }
         try {
-            const eventData = JSON.parse(evt.data);
-            const data = CamSwitcherEvents_1.cswEventsSchema.parse(eventData);
-            if (data.type === 'init') {
+            const eventData = JSON.parse(incomeData.toString());
+            const data = this.validate(eventData);
+            if (isInitEvent(data)) {
                 this.processMessage(data.data, true);
                 return;
             }
             this.processMessage(data, false);
         }
         catch (error) {
-            console.error('Error parsing event data:', evt.data, error);
+            console.error('Error parsing event data:', incomeData.toString(), error);
         }
     }
     processMessage(event, isInit) {
@@ -56,12 +65,14 @@ class CamSwitcherEvents {
         list.forEach((listener) => listener(event, isInit));
     }
     destroy() {
-        this.isDestroyed = true;
-        if (this.ws) {
-            this.ws.destroy();
-            this.ws = null;
-        }
+        this._isDestroyed = true;
+        this.ws.onMessage = () => { };
+        this.ws.onOpen = () => Promise.reject(new Error('Websocket is destroyed'));
+        this.ws.destroy();
         this.listeners = {};
     }
 }
-exports.CamSwitcherEvents = CamSwitcherEvents;
+exports.WsEvents = WsEvents;
+const isInitEvent = (event) => {
+    return event.type === 'init';
+};

package/cjs/internal/constants.d.ts

@@ -1 +1,2 @@
 export declare const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = "11.11.73";
+export declare const FIRMWARE_WITH_OVERLAYS_SUPPORT = "10.7.0";

package/cjs/internal/constants.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = void 0;
+exports.FIRMWARE_WITH_OVERLAYS_SUPPORT = exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = void 0;
 exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = '11.11.73';
+exports.FIRMWARE_WITH_OVERLAYS_SUPPORT = '10.7.0';

package/cjs/internal/convertors.d.ts

@@ -0,0 +1,6 @@
+import { TInternalVapixParameters } from '../types/CamStreamerAPI';
+import { TBitrateMode, TBitrateVapixParams } from '../types/common';
+export declare const parseBitrateOptionsToVapixParams: (firmWareVersion: string, bitrateMode: TBitrateMode | undefined, cameraOptions: Partial<TBitrateVapixParams>) => string;
+export declare const parseVapixParamsToBitrateOptions: (bitrateVapixParams: string) => TBitrateVapixParams;
+export declare const parseVideoOptionsToVapixParams: (firmWareVersion: string, video: TInternalVapixParameters) => string;
+export declare const parseVapixParamsToVideoOptions: (internalVapixParams: string) => TInternalVapixParameters;

package/cjs/internal/convertors.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVapixParamsToVideoOptions = exports.parseVideoOptionsToVapixParams = exports.parseVapixParamsToBitrateOptions = exports.parseBitrateOptionsToVapixParams = void 0;
+const constants_1 = require("./constants");
+const versionCompare_1 = require("./versionCompare");
+const parseBitrateOptionsToVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
+    if (!(0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
+        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
+    }
+    if (bitrateMode === undefined) {
+        return '';
+    }
+    const data = {
+        VBR: 'videobitratemode=vbr',
+        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}&videobitratepriority=framerate`,
+        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
+    };
+    return data[bitrateMode];
+};
+exports.parseBitrateOptionsToVapixParams = parseBitrateOptionsToVapixParams;
+const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
+    const params = {};
+    const searchParams = new URLSearchParams(bitrateVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
+    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
+    if (hasLowerFw) {
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: 'MBR',
+            maximumBitRate: maximumBitRate,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate * 1.1),
+        };
+    }
+    if (bitrateMode === 'ABR') {
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
+        };
+    }
+    else if (bitrateMode === 'MBR') {
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: bitrateMode,
+            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
+        };
+    }
+    return {
+        bitrateMode: bitrateMode,
+        retentionTime: 1,
+        maximumBitRate: 0,
+        bitRateLimit: 0,
+    };
+};
+exports.parseVapixParamsToBitrateOptions = parseVapixParamsToBitrateOptions;
+const parseVideoOptionsToVapixParams = (firmWareVersion, video) => {
+    const bitrateParams = (0, exports.parseBitrateOptionsToVapixParams)(firmWareVersion, video.bitrateMode, {
+        maximumBitRate: video.maximumBitRate,
+        retentionTime: video.retentionTime,
+        bitRateLimit: video.bitRateLimit,
+    });
+    let overlaysParams = '';
+    if ((0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.FIRMWARE_WITH_OVERLAYS_SUPPORT)) {
+        overlaysParams = `&overlays=${video.overlays}`;
+    }
+    const nbrOfChannels = video.audio === 1 ? `&nbrOfChannels=${video.nbrOfChannels}` : '';
+    const audioParams = `audio=${video.audio}${nbrOfChannels}`;
+    const videoCodecParams = video.videoCodec === 'h264'
+        ? `videoCodec=${video.videoCodec}&h264Profile=${video.h264Profile}`
+        : `videoCodec=${video.videoCodec}`;
+    const videoParams = `camera=${video.camera}&resolution=${video.resolution}&fps=${video.fps}&compression=${video.compression}&videokeyframeinterval=${video.govLength}&${videoCodecParams}${overlaysParams}`;
+    return [videoParams, bitrateParams, audioParams].join('&');
+};
+exports.parseVideoOptionsToVapixParams = parseVideoOptionsToVapixParams;
+const parseVapixParamsToVideoOptions = (internalVapixParams) => {
+    const bitrateOptions = (0, exports.parseVapixParamsToBitrateOptions)(internalVapixParams);
+    const params = {};
+    const searchParams = new URLSearchParams(internalVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    let h264Profile = undefined;
+    if (params['videoCodec'] === 'h264') {
+        h264Profile = (params['h264Profile'] ?? 'high');
+    }
+    let nbrOfChannels = undefined;
+    if (params['audio'] === '1') {
+        nbrOfChannels = parseInt(params['nbrOfChannels'] ?? '1');
+    }
+    return {
+        ...bitrateOptions,
+        camera: params['camera'] ?? '1',
+        resolution: params['resolution'] ?? '',
+        fps: parseInt(params['fps'] ?? '0', 10),
+        compression: parseInt(params['compression'] ?? '0', 10),
+        govLength: parseInt(params['videokeyframeinterval'] ?? '0', 10),
+        videoCodec: (params['videoCodec'] ?? 'h264'),
+        h264Profile,
+        audio: parseInt(params['audio'] ?? '0'),
+        nbrOfChannels,
+        overlays: params['overlays'],
+    };
+};
+exports.parseVapixParamsToVideoOptions = parseVapixParamsToVideoOptions;

package/cjs/internal/types.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-import { Response as UndiciResponse } from 'undici';
 export type Options = {
     ip?: string;
     port?: number;
@@ -11,25 +9,39 @@ export type Options = {
 export type HttpOptions = Options & {
     keepAlive?: boolean;
 };
-export type WsOptions = Options;
 export type TParameters = Record<string, string | number | boolean | null | undefined>;
-export type TResponse = Response | UndiciResponse;
-export type TGetParams = [url: string, parameters?: TParameters, headers?: Record<string, string>];
-export type TPostParams = [
-    url: string,
-    data: string | Buffer | FormData,
-    parameters?: TParameters,
-    headers?: Record<string, string>
-];
-export interface IClient<TRes extends TResponse> {
-    get: (...params: TGetParams) => Promise<TRes>;
-    post: (...params: TPostParams) => Promise<TRes>;
+export type TResponse = {
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    blob: () => Promise<unknown>;
+    status: number;
+    ok: boolean;
+    statusText: string;
+};
+export type TGetParams = {
+    path: string;
+    parameters?: TParameters;
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+export type TPostParams<Data> = {
+    path: string;
+    data: string | Data;
+    parameters?: TParameters;
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+export interface IClient<TRes extends TResponse, Data> {
+    get: (params: TGetParams) => Promise<TRes>;
+    post: (params: TPostParams<Data>) => Promise<TRes>;
 }
-export type TBlobResponse<Client extends IClient<TResponse>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
-export interface IWebsocket<Event extends {
-    readonly data: string;
-}> {
+export type TBlobResponse<Client extends IClient<TResponse, any>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
+export interface IWsClient {
+    onMessage: null | ((data: ArrayBuffer | string) => void);
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send: (data: ArrayBuffer | string) => void;
+    reconnect: () => void;
     destroy: () => void;
-    onmessage: null | ((event: Event) => void);
-    send: (data: string) => void;
 }

package/cjs/internal/utils.d.ts

@@ -1,5 +1,5 @@
 import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
-import { IClient, Options, TParameters, TResponse } from './types';
+import { TParameters } from './types';
 export declare const addParametersToPath: (path: string, params?: TParameters) => string;
 export declare const paramToUrl: (params?: TParameters) => string;
 export declare const arrayToUrl: (arr: string | string[]) => string;
@@ -9,7 +9,5 @@ export declare const isClip: (id?: string) => boolean;
 export declare const isTracker: (id?: string) => boolean;
 export declare const isPlaylist: (id?: string) => boolean;
 export declare const isLoopPlayType: (playType: TPlaylistPlayType) => boolean;
-export declare function isClient(arg?: Options | IClient<TResponse>): arg is IClient<TResponse>;
-export declare function responseStringify(res: TResponse): Promise<string>;
 export declare function pad(num: number, size: number): string;
 export declare function isNullish<T>(value: T | undefined | null): value is undefined | null;

package/cjs/internal/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNullish = exports.pad = exports.responseStringify = exports.isClient = exports.isLoopPlayType = exports.isPlaylist = exports.isTracker = exports.isClip = exports.isStream = exports.isCamera = exports.arrayToUrl = exports.paramToUrl = exports.addParametersToPath = void 0;
+exports.isNullish = exports.pad = exports.isLoopPlayType = exports.isPlaylist = exports.isTracker = exports.isClip = exports.isStream = exports.isCamera = exports.arrayToUrl = exports.paramToUrl = exports.addParametersToPath = void 0;
 const addParametersToPath = (path, params) => {
     if (params === undefined || Object.keys(params).length === 0) {
         return path;
@@ -43,17 +43,6 @@ const isPlaylist = (id) => id?.charAt(0) === 'p';
 exports.isPlaylist = isPlaylist;
 const isLoopPlayType = (playType) => playType.includes('LOOP');
 exports.isLoopPlayType = isLoopPlayType;
-function isClient(arg = {}) {
-    return 'get' in arg && 'post' in arg;
-}
-exports.isClient = isClient;
-async function responseStringify(res) {
-    return JSON.stringify({
-        status: res.status,
-        body: await res.text(),
-    });
-}
-exports.responseStringify = responseStringify;
 function pad(num, size) {
     const sign = Math.sign(num) === -1 ? '-' : '';
     return (sign +

package/cjs/internal/versionCompare.d.ts

@@ -1,6 +1,6 @@
 export declare const assertVersionString: (s: string, msg?: string) => void;
 export declare const isFirmwareVersionAtLeast: (version: string, compareVersion: string) => boolean;
 export declare const isVersionAtLeast: (version: string, compareVersion: string) => boolean;
-export declare const firmwareVersionCompare: (a: string, b: string) => 0 | 1 | -1;
-export declare const versionCompare: (a: string, b: string) => 0 | 1 | -1;
+export declare const firmwareVersionCompare: (a: string, b: string) => 1 | 0 | -1;
+export declare const versionCompare: (a: string, b: string) => 1 | 0 | -1;
 export declare const fixVersionToDots: (version: string) => string;

package/cjs/node/CamOverlayDrawingAPI.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from '../types/CamOverlayDrawingAPI';
+export declare class CamOverlayDrawingAPI extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private cameraList;
+    private zIndex;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: CamOverlayDrawingOptions);
+    connect(): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    cairo(command: string, ...params: unknown[]): Promise<TCairoResponse | TCairoCreateResponse>;
+    writeText(...params: TWriteTextParams): Promise<TCairoResponse>;
+    uploadImageData(imgBuffer: Buffer): Promise<TUploadImageResponse>;
+    uploadFontData(fontBuffer: Buffer): Promise<TCairoCreateResponse>;
+    showCairoImage(cairoImage: string, posX: number, posY: number): Promise<TCairoResponse>;
+    showCairoImageAbsolute(cairoImage: string, posX: number, posY: number, width: number, height: number): Promise<TCairoResponse>;
+    removeImage(): Promise<TCairoResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private sendBinaryMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportMessage;
+    private reportError;
+    private reportClose;
+}

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamOverlayDrawingAPI = void 0;
-const EventEmitter = require("events");
-const WsClient_1 = require("./node/WsClient");
-class CamOverlayDrawingAPI extends EventEmitter {
+const events_1 = require("events");
+const WsClient_1 = require("./WsClient");
+class CamOverlayDrawingAPI extends events_1.EventEmitter {
     tls;
     tlsInsecure;
     ip;
@@ -37,14 +37,14 @@ class CamOverlayDrawingAPI 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();
     }
     isConnected() {
@@ -101,23 +101,23 @@ class CamOverlayDrawingAPI extends EventEmitter {
             tlsInsecure: this.tlsInsecure,
         };
         this.ws = new WsClient_1.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;
@@ -168,13 +168,21 @@ 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 → 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;