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

package/esm/CamOverlayAPI.js

@@ -1,65 +1,100 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { fileListSchema, ImageType, serviceSchema, storageSchema, } from './types/CamOverlayAPI';
+import { paramToUrl, responseStringify } from './internal/utils';
 import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
+import { z } from 'zod';
+import { ProxyClient } from './internal/ProxyClient';
+import { fileListSchema, ImageType, storageDataListSchema, widgetsSchema, WSResponseSchema, } from './types/CamOverlayAPI/CamOverlayAPI';
+export const 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';
 export class CamOverlayAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
-    }
-    async checkCameraTime() {
-        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
-        return cameraTime.state;
-    }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
+    constructor(client) {
+        this.client = client;
+    }
+    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 z.boolean().parse(response.state);
+    }
+    async getNetworkCameraList(options) {
+        const response = await this._get({ path: `${BASE_PATH}/network_camera_list.cgi` }, options);
         return networkCameraListSchema.parse(response.camera_list);
     }
-    async wsAutoratization() {
-        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
-        return 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 listFiles(fileType) {
-        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
+    async wsAuthorization(options) {
+        const response = await this._get({ path: `${BASE_PATH}/ws_authorization.cgi` }, options);
+        return WSResponseSchema.parse(response).data;
+    }
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob({
+            path: `${BASE_PATH}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`,
+        }, options);
+    }
+    async listFiles(fileType, options) {
+        const files = await this._get({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            parameters: {
+                action: 'list',
+            },
+        }, options);
         return 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 removeFile(fileType, file) {
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
-        await this.post(path, JSON.stringify(file));
+    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, 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 storageDataListSchema.parse(data.list);
     }
-    async getFileStorage(fileType) {
-        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
-        return 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;
                 }
             }
@@ -69,29 +104,46 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async getSingleService(serviceId) {
-        const data = await this.get('/local/camoverlay/api/services.cgi', {
-            action: 'get',
-            service_id: serviceId.toString(),
+    async getSingleWidget(serviceId, options) {
+        const data = await this._get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: {
+                action: 'get',
+                service_id: serviceId.toString(),
+            },
+        }, options);
+        return widgetsSchema.parse(data);
+    }
+    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 = 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 serviceSchema.parse(data);
-    }
-    async getServices() {
-        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
-        return serviceSchema.parse(serviceList).services;
+        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;
@@ -100,62 +152,81 @@ export 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 === 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 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 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 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 responseStringify(res));
@@ -163,10 +234,22 @@ export class CamOverlayAPI {
     }
     async parseBlobResponse(response) {
         try {
-            return await response.blob();
+            return (await response.blob());
         }
         catch (err) {
             throw new ParsingBlobError(err);
         }
     }
+    async _postUrlEncoded(path, params, headers, options) {
+        const data = 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(this.client, proxyParams) : this.client;
+    }
 }

package/esm/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/esm/CamOverlayDrawingAPI.js

@@ -121,10 +121,10 @@ export 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];
         }
@@ -194,6 +194,9 @@ export 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'));
@@ -220,7 +223,7 @@ export 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/esm/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/esm/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/Painter.d.ts

@@ -1,11 +1,18 @@
-import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-import { Frame, TFrameOptions } from './Frame';
-export declare const COORD: Record<string, [number, number]>;
-export type TPainterOptions = TFrameOptions & {
-    screenWidth: number;
-    screenHeight: number;
-    coAlignment: string;
+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 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];
 };
 export declare class Painter extends Frame {
     private screenWidth;
@@ -24,7 +31,7 @@ export declare class Painter extends Frame {
     registerImage(moniker: string, fileName: string): void;
     registerFont(moniker: string, fileName: string): void;
     setScreenSize(sw: number, sh: number): void;
-    setCoAlignment(coAlignment: string): void;
+    setCoAlignment(coAlignment: TCoAlignment): void;
     protected layoutChanged(): void;
     display(scale?: number): Promise<void>;
     hide(): Promise<void>;
@@ -34,4 +41,3 @@ export declare class Painter extends Frame {
     private cleanupSurface;
     private positionConvertor;
 }
-export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/esm/CamOverlayPainter/Painter.js

@@ -1,5 +1,5 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
+import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
 export const COORD = {
     top_left: [-1, -1],
@@ -82,6 +82,9 @@ export class Painter extends Frame {
             let lastCachedLayer;
             for (let i = 0; i < this.layers.length; i++) {
                 const layer = this.layers[i];
+                if (layer === undefined) {
+                    continue;
+                }
                 if (layer.cairoCache !== undefined &&
                     layer.surfaceCache !== undefined &&
                     surface === undefined &&
@@ -115,7 +118,7 @@ export class Painter extends Frame {
         }
         for (let i = layerIdx; i < this.layers.length; i++) {
             const currentLayer = this.layers[i];
-            if (currentLayer.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
+            if (currentLayer?.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
                 await this.cleanupSurface(currentLayer.surfaceCache, currentLayer.cairoCache);
                 currentLayer.surfaceCache = undefined;
                 currentLayer.cairoCache = undefined;
@@ -160,4 +163,3 @@ export class Painter extends Frame {
         }
     }
 }
-export { Frame, ResourceManager };

package/esm/CamOverlayPainter/ResourceManager.d.ts

@@ -1,5 +1,6 @@
-import { CamOverlayDrawingAPI, TUploadImageResponse, TCairoCreateResponse } from '../CamOverlayDrawingAPI';
-export default class ResourceManager {
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TUploadImageResponse, TCairoCreateResponse } from '../types/CamOverlayDrawingAPI';
+export declare class ResourceManager {
     private co;
     private imgFileNames;
     private fontFileNames;