camstreamerlib 4.0.0-beta.7 → 4.0.0-beta.70

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,26 @@ class CamSwitcherEvents {
         const typeList = this.listeners[type];
         if (typeList) {
             delete typeList[id];
+            if (Object.keys(typeList).length === 0) {
+                delete this.listeners[type];
+            }
         }
     }
-    onMessage(evt) {
+    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 +60,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/types.d.ts

@@ -0,0 +1,47 @@
+export type Options = {
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+};
+export type HttpOptions = Options & {
+    keepAlive?: boolean;
+};
+export type TParameters = Record<string, string | number | boolean | null | undefined>;
+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, 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;
+}

package/cjs/internal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/internal/utils.d.ts

@@ -1,5 +1,5 @@
 import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
-import { TParameters } from './common';
+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,3 +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 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,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLoopPlayType = exports.isPlaylist = exports.isTracker = exports.isClip = exports.isStream = exports.isCamera = exports.arrayToUrl = exports.paramToUrl = exports.addParametersToPath = void 0;
-const common_1 = require("./common");
+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;
@@ -17,7 +16,7 @@ const paramToUrl = (params) => {
     let output = '';
     for (const key in params) {
         const value = params[key];
-        if ((0, common_1.isNullish)(value)) {
+        if (isNullish(value)) {
             continue;
         }
         output += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`;
@@ -44,3 +43,16 @@ const isPlaylist = (id) => id?.charAt(0) === 'p';
 exports.isPlaylist = isPlaylist;
 const isLoopPlayType = (playType) => playType.includes('LOOP');
 exports.isLoopPlayType = isLoopPlayType;
+function pad(num, size) {
+    const sign = Math.sign(num) === -1 ? '-' : '';
+    return (sign +
+        new Array(size)
+            .concat([Math.abs(num)])
+            .join('0')
+            .slice(-size));
+}
+exports.pad = pad;
+function isNullish(value) {
+    return value === null || value === undefined;
+}
+exports.isNullish = isNullish;

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) => 1 | -1 | 0;
-export declare const versionCompare: (a: string, b: string) => 1 | -1 | 0;
+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 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;
@@ -174,7 +174,8 @@ class CamOverlayDrawingAPI extends EventEmitter {
                 headerView.setInt8(0, 1);
                 headerView.setInt32(1, jsonBuffer.byteLength);
                 const msgBuffer = Buffer.concat([Buffer.from(header), jsonBuffer, data]);
-                this.ws.send(msgBuffer);
+                const arrayBuffer = msgBuffer.buffer.slice(msgBuffer.byteOffset, msgBuffer.byteOffset + msgBuffer.byteLength);
+                this.ws.send(arrayBuffer);
                 this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
             }
             catch (err) {

package/cjs/{CamOverlayPainter → 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;
+}