camstreamerlib 4.0.0-beta.3 → 4.0.0-beta.30

package/README.md

@@ -21,19 +21,25 @@ npm install camstreamerlib
 
 -   [VapixAPI](doc/VapixAPI.md) is a module to access Axis camera VAPIX interface.
 
+-   [VapixEvents](doc/VapixEvents.md) is a module which allows receiving camera events from the VAPIX API.
+
 -   [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.
+-   [CamOverlayAPI](doc/CamOverlayAPI.md) is a module to access CamOverlay API.
 
 -   [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
 
 -   [CamOverlayPainter/](doc/CamOverlayPainter.md) contains three modules which makes easier to use CamOverlayDrawingAPI.
 
+-   [CamScripterAPI](doc/CamScripterAPI.md) is a module to access CamScripter API.
+
 -   [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.
 
+-   [CamSwitcherAPI](doc/CamSwitcherAPI.md) is a module to access CamSwitcher API.
+
 -   [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.
+-   [PlaneTrackerAPI](doc/PlaneTrackerAPI.md) is a module to access PlaneTracker API.
 
 -   [GenetecAgent](doc/GenetecAgent.md) is a module which allows receiving and sending data to Genetec VMS.
 

package/cjs/CamOverlayAPI.d.ts

@@ -1,31 +1,52 @@
 /// <reference types="node" />
-import { IClient } from './internal/common';
-import { CamOverlayOptions, ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TService, TServiceList, TStorage } from './types/CamOverlayAPI';
-import { TNetworkCamera } from './types/common';
-export declare class CamOverlayAPI {
+/// <reference types="node" />
+import { IClient, TBlobResponse, TResponse } from './internal/types';
+import { THttpRequestOptions, TNetworkCamera } from './types/common';
+import { ImageType, TCoordinates, TFile, TFileList, TFileType, TStorage, TStorageDataList, TWidget } from './types/CamOverlayAPI/CamOverlayAPI';
+import { TField } from './types/CamOverlayAPI';
+export declare const allowedWidgetNames: {
+    readonly accuweather: "accuweather";
+    readonly infoticker: "infoticker";
+    readonly customGraphics: "customGraphics";
+    readonly ptzCompass: "ptzCompass";
+    readonly images: "images";
+    readonly ptz: "ptz";
+    readonly pip: "pip";
+    readonly screenSharing: "screenSharing";
+    readonly web_camera: "web_camera";
+};
+export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     private client;
-    constructor(options?: CamOverlayOptions | IClient);
-    checkCameraTime(): Promise<boolean>;
-    getNetworkCameraList(): Promise<TNetworkCamera[]>;
-    wsAutoratization(): Promise<string>;
-    getMjpegStreamImage(mjpegUrl: string): Promise<Blob>;
-    listFiles(fileType: TFileType): Promise<TFileList>;
-    uploadFile(fileType: TFileType, file: Blob, fileName: string): Promise<void>;
-    removeFile(fileType: TFileType, file: TFile): Promise<void>;
-    getFileStorage(fileType: TFileType): Promise<TStorage>;
-    updateInfoticker(serviceID: number, text: string): Promise<void>;
-    setEnabled(serviceID: number, enabled: boolean): Promise<void>;
-    isEnabled(serviceID: number): Promise<boolean>;
-    getSingleService(serviceId: number): Promise<TService>;
-    getServices(): Promise<TService[]>;
-    updateSingleService(serviceId: number, serviceJson: TService): Promise<void>;
-    updateServices(servicesJson: TServiceList): Promise<void>;
-    updateCGText(serviceID: number, fields: TField[]): Promise<void>;
-    updateCGImagePos(serviceID: number, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
-    updateCGImage(serviceID: number, path: string, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
-    updateCGImageFromData(serviceID: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    constructor(client: Client);
+    static getBasePath: () => string;
+    static getProxyPath: () => string;
+    static getFilePreviewPath: (path: string) => string;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getMjpegStreamImage(mjpegUrl: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<TFileList>;
+    uploadFile(fileType: TFileType, formData: FormData, storage: TStorage, options?: THttpRequestOptions): Promise<void>;
+    removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
+    getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<TStorageDataList>;
+    getFilePreviewFromCamera(path: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    updateInfoticker(serviceId: number, text: string, options?: THttpRequestOptions): Promise<void>;
+    setEnabled(serviceId: number, enabled: boolean, options?: THttpRequestOptions): Promise<void>;
+    isEnabled(serviceId: number, options?: THttpRequestOptions): Promise<boolean>;
+    getSingleWidget(serviceId: number, options?: THttpRequestOptions): Promise<TWidget>;
+    getWidgets(options?: THttpRequestOptions): Promise<TWidget[]>;
+    updateSingleWidget(widget: TWidget, options?: THttpRequestOptions): Promise<void>;
+    updateWidgets(widgets: TWidget[], options?: THttpRequestOptions): Promise<void>;
+    updateCGText(serviceId: number, fields: TField[], options?: THttpRequestOptions): Promise<void>;
+    updateCGImagePos(serviceId: number, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
+    updateCGImage(serviceId: number, path: string, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
+    updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     private promiseCGUpdate;
-    private get;
-    private post;
+    private _get;
+    private _post;
+    private _getBlob;
     private parseBlobResponse;
+    private _postUrlEncoded;
+    private _postJsonEncoded;
+    private getAgent;
 }

package/cjs/CamOverlayAPI.js

@@ -1,100 +1,152 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamOverlayAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
-const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+exports.CamOverlayAPI = exports.allowedWidgetNames = void 0;
+const utils_1 = require("./internal/utils");
 const errors_1 = require("./errors/errors");
-const common_2 = require("./types/common");
+const common_1 = require("./types/common");
+const zod_1 = require("zod");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const CamOverlayAPI_1 = require("./types/CamOverlayAPI/CamOverlayAPI");
+exports.allowedWidgetNames = {
+    accuweather: 'accuweather',
+    infoticker: 'infoticker',
+    customGraphics: 'customGraphics',
+    ptzCompass: 'ptzCompass',
+    images: 'images',
+    ptz: 'ptz',
+    pip: 'pip',
+    screenSharing: 'screenSharing',
+    web_camera: 'web_camera',
+};
+const BASE_PATH = '/local/camoverlay/api';
 class CamOverlayAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
-    async checkCameraTime() {
-        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
-        return cameraTime.state;
+    static getBasePath = () => BASE_PATH;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${BASE_PATH}/image.cgi?path=${encodeURIComponent(path)}`;
+    async checkCameraTime(options) {
+        const response = await this._get({ path: `${BASE_PATH}/camera_time.cgi` }, options);
+        return zod_1.z.boolean().parse(response.state);
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
-        return common_2.networkCameraListSchema.parse(response.camera_list);
+    async getNetworkCameraList(options) {
+        const response = await this._get({ path: `${BASE_PATH}/network_camera_list.cgi` }, options);
+        return common_1.networkCameraListSchema.parse(response.camera_list);
     }
-    async wsAutoratization() {
-        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
-        return response.data;
+    async wsAuthorization(options) {
+        const response = await this._get({ path: `${BASE_PATH}/ws_authorization.cgi` }, options);
+        return CamOverlayAPI_1.WSResponseSchema.parse(response).data;
     }
-    async getMjpegStreamImage(mjpegUrl) {
-        const res = await this.get(`/local/camoverlay/api/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
-        return await this.parseBlobResponse(res);
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob({
+            path: `${BASE_PATH}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`,
+        }, options);
     }
-    async listFiles(fileType) {
-        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
+    async listFiles(fileType, options) {
+        const files = await this._get({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            parameters: {
+                action: 'list',
+            },
+        }, options);
         return CamOverlayAPI_1.fileListSchema.parse(files.list);
     }
-    async uploadFile(fileType, file, fileName) {
-        const formData = new FormData();
-        formData.append('target', 'SD0');
-        formData.append('uploadedFile[]', file, fileName);
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=upload`;
-        await this.post(path, formData);
+    async uploadFile(fileType, formData, storage, options) {
+        await this._post({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            data: formData,
+            parameters: {
+                action: 'upload',
+                storage: storage,
+            },
+        }, options);
     }
-    async removeFile(fileType, file) {
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
-        await this.post(path, JSON.stringify(file));
+    async removeFile(fileType, fileParams, options) {
+        const path = `${BASE_PATH}/upload_${fileType}.cgi`;
+        await this._postUrlEncoded(path, {
+            action: 'remove',
+            ...fileParams,
+        }, undefined, options);
+    }
+    async getFileStorage(fileType, options) {
+        const data = await this._get({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            parameters: {
+                action: 'get_storage',
+            },
+        }, options);
+        if (data.code !== 200) {
+            throw new Error('Error occured while fetching file storage data');
+        }
+        return CamOverlayAPI_1.storageDataListSchema.parse(data.list);
     }
-    async getFileStorage(fileType) {
-        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
-        return CamOverlayAPI_1.storageSchema.parse(data);
+    async getFilePreviewFromCamera(path, options) {
+        return await this._getBlob({ path: CamOverlayAPI.getFilePreviewPath(path) }, options);
     }
-    async updateInfoticker(serviceID, text) {
-        await this.get(`/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+    async updateInfoticker(serviceId, text, options) {
+        await this._get({ path: `${BASE_PATH}/infoticker.cgi?service_id=${serviceId}&text=${text}` }, options);
     }
-    async setEnabled(serviceID, enabled) {
-        await this.post(`/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+    async setEnabled(serviceId, enabled, options) {
+        await this._post({ path: `${BASE_PATH}/enabled.cgi?id_${serviceId}=${enabled ? 1 : 0}`, data: '' }, options);
     }
-    async isEnabled(serviceID) {
-        const res = await this.client.get('/local/camoverlay/api/services.cgi?action=get');
+    async isEnabled(serviceId, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ path: `${BASE_PATH}/services.cgi?action=get`, timeout: options?.timeout });
         if (res.ok) {
             const data = JSON.parse(await res.text());
             for (const service of data.services) {
-                if (service.id === serviceID) {
+                if (service.id === serviceId) {
                     return service.enabled === 1;
                 }
             }
             throw new errors_1.ServiceNotFoundError();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async getSingleService(serviceId) {
-        const data = await this.get('/local/camoverlay/api/services.cgi', {
-            action: 'get',
-            service_id: serviceId.toString(),
-        });
-        return CamOverlayAPI_1.serviceSchema.parse(data);
+    async getSingleWidget(serviceId, options) {
+        const data = await this._get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: {
+                action: 'get',
+                service_id: serviceId.toString(),
+            },
+        }, options);
+        return CamOverlayAPI_1.widgetsSchema.parse(data);
     }
-    async getServices() {
-        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
-        return CamOverlayAPI_1.serviceSchema.parse(serviceList).services;
+    async getWidgets(options) {
+        const widgetList = await this._get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: {
+                action: 'get',
+            },
+        }, options);
+        const widgets = widgetList.services;
+        widgets.forEach((widget) => {
+            const parsedWidget = CamOverlayAPI_1.widgetsSchema.safeParse(widget);
+            if (!parsedWidget.success) {
+                console.warn(`[SERVICE SCHEMA MISMATCH]: Service ${widget.name} (${widget.id}) does not match the current schema, or is a hidden service.`);
+            }
+        });
+        return widgets;
     }
-    async updateSingleService(serviceId, serviceJson) {
-        const path = '/local/camoverlay/api/services.cgi';
-        await this.post(path, JSON.stringify(serviceJson), {
+    async updateSingleWidget(widget, options) {
+        const path = `${BASE_PATH}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify(widget), {
             action: 'set',
-            service_id: serviceId.toString(),
-        });
+            service_id: widget.id.toString(),
+        }, undefined, options);
     }
-    async updateServices(servicesJson) {
-        const path = '/local/camoverlay/api/services.cgi?action=set';
-        await this.post(path, JSON.stringify(servicesJson));
+    async updateWidgets(widgets, options) {
+        const path = `${BASE_PATH}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify({ services: widgets }), {
+            action: 'set',
+        }, undefined, options);
     }
-    updateCGText(serviceID, fields) {
+    updateCGText(serviceId, fields, options) {
         const params = {};
         for (const field of fields) {
             const name = field.field_name;
@@ -103,74 +155,105 @@ class CamOverlayAPI {
                 params[`${name}_color`] = field.color;
             }
         }
-        return this.promiseCGUpdate(serviceID, 'update_text', params);
+        return this.promiseCGUpdate(serviceId, 'update_text', params, undefined, undefined, options);
     }
-    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+    updateCGImagePos(serviceId, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+    updateCGImage(serviceId, path, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
             image: path,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
+    updateCGImageFromData(serviceId, imageType, imageData, coordinates = '', x = 0, y = 0, options) {
         const contentType = imageType === CamOverlayAPI_1.ImageType.PNG ? 'image/png' : 'image/jpeg';
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, contentType, imageData, options);
     }
-    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
-        const path = `/local/camoverlay/api/customGraphics.cgi`;
+    async promiseCGUpdate(serviceId, action, params = {}, contentType, data, options) {
+        const path = `${BASE_PATH}/customGraphics.cgi`;
         let headers = {};
         if (contentType !== undefined && data) {
             headers = { 'Content-Type': contentType };
         }
-        const res = await this.client.post(path, data ?? '', {
-            action: action,
-            service_id: serviceID.toString(),
-            ...params,
-        }, headers);
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: data ?? '',
+            parameters: {
+                action: action,
+                service_id: serviceId.toString(),
+                ...params,
+            },
+            headers,
+            timeout: options?.timeout,
+        });
         if (!res.ok) {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async _get(params, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ ...params, timeout: options?.timeout });
         if (res.ok) {
-            return await res.json();
+            return (await res.json());
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    async _post(params, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ ...params, timeout: options?.timeout });
         if (res.ok) {
-            return await res.json();
+            return (await res.json());
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async _getBlob(params, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ ...params, timeout: options?.timeout });
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
     async parseBlobResponse(response) {
         try {
-            return await response.blob();
+            return (await response.blob());
         }
         catch (err) {
             throw new errors_1.ParsingBlobError(err);
         }
     }
+    async _postUrlEncoded(path, params, headers, options) {
+        const data = (0, utils_1.paramToUrl)(params);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post({ path, data, headers: { ...baseHeaders, ...headers } }, options);
+    }
+    async _postJsonEncoded(path, data, parameters, headers, options) {
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return this._post({ path, data, parameters, headers: { ...baseHeaders, ...headers } }, options);
+    }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
 }
 exports.CamOverlayAPI = CamOverlayAPI;

package/cjs/CamOverlayDrawingAPI.d.ts

@@ -1,53 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import * as EventEmitter from 'events';
-import { WsOptions } from './internal/common';
-export type CamOverlayDrawingOptions = WsOptions & {
-    camera?: number | number[];
-    zIndex?: number;
-};
-export type TCairoResponse = {
-    message: string;
-    call_id: number;
-};
-export type TCairoCreateResponse = {
-    var: string;
-    call_id: number;
-};
-export type TUploadImageResponse = {
-    var: string;
-    width: number;
-    height: number;
-    call_id: number;
-};
-export type TErrorResponse = {
-    error: string;
-    call_id?: number;
-};
-export type TService = {
-    id: number;
-    enabled: number;
-    schedule: string;
-    name: string;
-    identifier: string;
-    cameraList: number[];
-};
-export type TServiceList = {
-    services: TService[];
-};
-export type TAlign = 'A_RIGHT' | 'A_LEFT' | 'A_CENTER';
-export type TextFit = 'TFM_SCALE' | 'TFM_TRUNCATE' | 'TFM_OVERFLOW';
-export type TWriteTextParams = [string, string, number, number, number, number, TAlign, TextFit?];
-export interface CamOverlayDrawingAPI {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    on(event: 'message', listener: (msg: string) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'error', err: Error): boolean;
-    emit(event: 'message', msg: string): boolean;
-}
+import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from './types/CamOverlayDrawingAPI';
 export declare class CamOverlayDrawingAPI extends EventEmitter {
     private tls;
     private tlsInsecure;

package/cjs/CamOverlayDrawingAPI.js

@@ -124,10 +124,10 @@ class CamOverlayDrawingAPI extends EventEmitter {
         }
         if (dataJSON.call_id !== undefined) {
             if (errorResponse !== undefined) {
-                this.sendMessages[dataJSON.call_id].reject(new Error(errorResponse.error));
+                this.sendMessages[dataJSON.call_id]?.reject(new Error(errorResponse.error));
             }
             else {
-                this.sendMessages[dataJSON.call_id].resolve(dataJSON);
+                this.sendMessages[dataJSON.call_id]?.resolve(dataJSON);
             }
             delete this.sendMessages[dataJSON.call_id];
         }
@@ -197,6 +197,9 @@ class CamOverlayDrawingAPI extends EventEmitter {
             const now = Date.now();
             for (const callId in this.sendMessages) {
                 const msg = this.sendMessages[callId];
+                if (!msg) {
+                    continue;
+                }
                 if (now - msg.sentTimestamp > 10000) {
                     reconnect = true;
                     msg.reject(new Error('Message timeout'));
@@ -223,7 +226,7 @@ class CamOverlayDrawingAPI extends EventEmitter {
     }
     reportClose() {
         for (const callId in this.sendMessages) {
-            this.sendMessages[callId].reject(new Error('Connection lost'));
+            this.sendMessages[callId]?.reject(new Error('Connection lost'));
         }
         this.sendMessages = {};
         this.emit('close');

package/cjs/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;