camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.21

package/esm/CamOverlayAPI.js

@@ -0,0 +1,251 @@
+import { paramToUrl, responseStringify } from './internal/utils';
+import { ImageType, } from './types/CamOverlayAPI';
+import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
+import { networkCameraListSchema } from './types/common';
+import { z } from 'zod';
+import { widgetsSchema } from './models/CamOverlayAPI/widgetsSchema';
+import { fileListSchema, storageSchema } from './models/CamOverlayAPI/fileSchema';
+export const BASE_URL = '/local/camoverlay/api';
+export class CamOverlayAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${BASE_URL}/image.cgi?path=${encodeURIComponent(path)}`;
+    async checkCameraTime() {
+        const responseSchema = z.discriminatedUnion('state', [
+            z.object({
+                state: z.literal(true),
+                code: z.number(),
+            }),
+            z.object({
+                state: z.literal(false),
+                code: z.number(),
+                reason: z.union([
+                    z.literal('INVALID_TIME'),
+                    z.literal('COULDNT_RESOLVE_HOST'),
+                    z.literal('CONNECTION_ERROR'),
+                ]),
+                message: z.string(),
+            }),
+        ]);
+        const response = await this._get(`${BASE_URL}/camera_time.cgi`);
+        const cameraTime = responseSchema.parse(response);
+        if (!cameraTime.state) {
+            console.error(`Camera time check failed: ${cameraTime.reason} - ${cameraTime.message}`);
+        }
+        return cameraTime.state;
+    }
+    async getNetworkCameraList() {
+        const response = await this._get(`${BASE_URL}/network_camera_list.cgi`);
+        return networkCameraListSchema.parse(response.camera_list);
+    }
+    async wsAuthorization() {
+        const responseSchema = z.object({
+            status: z.number(),
+            message: z.string(),
+            data: z.string(),
+        });
+        const response = await this._get(`${BASE_URL}/ws_authorization.cgi`);
+        return responseSchema.parse(response).data;
+    }
+    async getMjpegStreamImage(mjpegUrl) {
+        return await this._getBlob(`${BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
+    }
+    async listFiles(fileType) {
+        const fileDataSchema = z.object({
+            code: z.number(),
+            list: fileListSchema,
+        });
+        const files = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
+            action: 'list',
+        });
+        return fileListSchema.parse(files.list);
+    }
+    async uploadFile(fileType, formData, storage) {
+        const path = `${BASE_URL}/upload_${fileType}.cgi`;
+        await this._post(path, formData, {
+            action: 'upload',
+            storage: storage,
+        });
+    }
+    async removeFile(fileType, fileParams) {
+        const path = `${BASE_URL}/upload_${fileType}.cgi`;
+        await this._postUrlEncoded(path, {
+            action: 'remove',
+            ...fileParams,
+        });
+    }
+    async getFileStorage(fileType) {
+        const storageDataListSchema = z.array(z.object({
+            type: storageSchema,
+            state: z.string(),
+        }));
+        const responseSchema = z.object({
+            code: z.number(),
+            list: storageDataListSchema,
+        });
+        const data = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
+            action: 'get_storage',
+        });
+        if (data.code !== 200) {
+            throw new Error('Error occured while fetching file storage data');
+        }
+        return storageDataListSchema.parse(data.list);
+    }
+    async getFilePreviewFromCamera(path) {
+        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path));
+    }
+    async updateInfoticker(serviceID, text) {
+        await this._get(`${BASE_URL}/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+    }
+    async setEnabled(serviceID, enabled) {
+        await this._post(`${BASE_URL}/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+    }
+    async isEnabled(serviceID) {
+        const res = await this.client.get(`${BASE_URL}/services.cgi?action=get`);
+        if (res.ok) {
+            const data = JSON.parse(await res.text());
+            for (const service of data.services) {
+                if (service.id === serviceID) {
+                    return service.enabled === 1;
+                }
+            }
+            throw new ServiceNotFoundError();
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async getSingleWidget(serviceId) {
+        const data = await this._get(`${BASE_URL}/services.cgi`, {
+            action: 'get',
+            service_id: serviceId.toString(),
+        });
+        return widgetsSchema.parse(data);
+    }
+    async getWidgets() {
+        const widgetList = await this._get(`${BASE_URL}/services.cgi`, {
+            action: 'get',
+        });
+        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 widgets;
+    }
+    async updateSingleWidget(widget) {
+        const path = `${BASE_URL}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify(widget), {
+            action: 'set',
+            service_id: widget.id.toString(),
+        });
+    }
+    async updateWidgets(widgets) {
+        const path = `${BASE_URL}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify({ services: widgets }), {
+            action: 'set',
+        });
+    }
+    updateCGText(serviceID, fields) {
+        const params = {};
+        for (const field of fields) {
+            const name = field.field_name;
+            params[name] = field.text;
+            if (field.color !== undefined) {
+                params[`${name}_color`] = field.color;
+            }
+        }
+        return this.promiseCGUpdate(serviceID, 'update_text', params);
+    }
+    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params);
+    }
+    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+            image: path,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params);
+    }
+    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
+        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);
+    }
+    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
+        const path = `${BASE_URL}/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);
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _get(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return (await res.json());
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _post(...args) {
+        const res = await this.client.post(...args);
+        if (res.ok) {
+            return (await res.json());
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _getBlob(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new ParsingBlobError(err);
+        }
+    }
+    async _postUrlEncoded(path, params, headers) {
+        const data = paramToUrl(params);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post(path, data, {}, { ...baseHeaders, ...headers });
+    }
+    async _postJsonEncoded(...args) {
+        const [path, data, params, headers] = args;
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return this._post(path, data, params, { ...baseHeaders, ...headers });
+    }
+}

package/esm/CamOverlayDrawingAPI.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from './internal/types';
+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;
+}
+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/{CamOverlayDrawingAPI.js → 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

@@ -0,0 +1,96 @@
+/// <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;
+}
+export declare class Frame extends EventEmitter {
+    protected enabled: boolean;
+    protected posX: number;
+    protected posY: number;
+    protected width: number;
+    protected height: number;
+    private text;
+    private fontColor;
+    private fontName?;
+    private font?;
+    private align;
+    private textType;
+    private bgColor?;
+    private bgImageName?;
+    private bgImage?;
+    private bgType?;
+    private borderRadius;
+    private borderWidth;
+    private borderColor;
+    private customDraw?;
+    private layer;
+    protected children: Frame[];
+    constructor(opt: TFrameOptions);
+    enable(): void;
+    disable(): void;
+    setFramePosition(x: number, y: number): void;
+    setFrameSize(width: number, height: number): void;
+    setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
+    setFontColor(fontColor: TRgb): void;
+    setFont(fontName: string): void;
+    setFontData(fontData: TCairoCreateResponse): void;
+    setBgColor(color: TRgba): void;
+    setBgImage(imageName: string, type?: TObjectFitType): void;
+    setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
+    setBgType(type: TObjectFitType): void;
+    setBorderRadius(radius: number): void;
+    setBorderWidth(width: number): void;
+    setBorderColor(color: TRgba): void;
+    setCustomDraw(customDraw: TDrawingCallback): void;
+    resetFont(): void;
+    resetBgColor(): void;
+    resetBgImage(): void;
+    resetCustomDraw(): void;
+    clear(): void;
+    insert(...frames: Frame[]): void;
+    getLayers(): Set<number>;
+    protected layoutChanged(): void;
+    displayImage(cod: CamOverlayDrawingAPI, resourceManager: ResourceManager, cairo: string, ppX: number, ppY: number, scale: number, layer: number): Promise<void>;
+    private prepareResources;
+    protected displayOwnImage(cod: CamOverlayDrawingAPI, cairo: string, ppX: number, ppY: number, scale: number): Promise<void>;
+    private clipDrawing;
+    private drawFrame;
+    private drawImage;
+    private drawText;
+    private drawBorder;
+    private drawRectPath;
+}

package/esm/CamOverlayPainter/Painter.d.ts

@@ -0,0 +1,48 @@
+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;
+};
+export declare class Painter extends Frame {
+    private screenWidth;
+    private screenHeight;
+    private coAlignment;
+    private cod;
+    private rm;
+    private refreshLayers;
+    private layers;
+    constructor(opt: TPainterOptions, coopt: CamOverlayDrawingOptions);
+    get camOverlayDrawingAPI(): CamOverlayDrawingAPI;
+    get resourceManager(): ResourceManager;
+    connect(): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    setScreenSize(sw: number, sh: number): void;
+    setCoAlignment(coAlignment: TCoAlignment): void;
+    protected layoutChanged(): void;
+    display(scale?: number): Promise<void>;
+    hide(): Promise<void>;
+    invalidateLayer(layer: number): Promise<void>;
+    private prepareLayers;
+    private prepareSurface;
+    private cleanupSurface;
+    private positionConvertor;
+}
+export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/{CamOverlayPainter → esm/CamOverlayPainter}/Painter.js

@@ -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;

package/esm/CamOverlayPainter/ResourceManager.d.ts

@@ -0,0 +1,14 @@
+import { CamOverlayDrawingAPI, TUploadImageResponse, TCairoCreateResponse } from '../CamOverlayDrawingAPI';
+export default 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>;
+    font(moniker: string): Promise<TCairoCreateResponse>;
+    clear(): void;
+}

package/{CamOverlayPainter → esm/CamOverlayPainter}/ResourceManager.js

@@ -15,30 +15,26 @@ export default class ResourceManager {
         this.fontFileNames[moniker] = process.env.INSTALL_PATH + '/fonts/' + fileName;
     }
     async image(moniker) {
-        if (moniker in this.images) {
+        if (this.images[moniker] !== undefined) {
             return this.images[moniker];
         }
-        else if (moniker in this.imgFileNames) {
+        if (this.imgFileNames[moniker] !== undefined) {
             const imgData = await fs.readFile(this.imgFileNames[moniker]);
             this.images[moniker] = await this.co.uploadImageData(imgData);
             return this.images[moniker];
         }
-        else {
-            throw new Error('Error! Unknown image requested!');
-        }
+        throw new Error('Error! Unknown image requested!');
     }
     async font(moniker) {
-        if (moniker in this.fonts) {
+        if (this.fonts[moniker] !== undefined) {
             return this.fonts[moniker];
         }
-        else if (moniker in this.fontFileNames) {
+        if (this.fontFileNames[moniker] !== undefined) {
             const fontData = await fs.readFile(this.fontFileNames[moniker]);
             this.fonts[moniker] = await this.co.uploadFontData(fontData);
             return this.fonts[moniker];
         }
-        else {
-            throw new Error('Error! Unknown font requested!');
-        }
+        throw new Error('Error! Unknown font requested!');
     }
     clear() {
         this.images = {};

package/esm/CamScripterAPI.d.ts

@@ -0,0 +1,36 @@
+import { IClient, TResponse } from './internal/types';
+import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
+import { TNetworkCamera } from './types/common';
+export declare const BASE_URL = "/local/camscripter/package";
+export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: Client;
+    constructor(client: Client);
+    static getProxyUrlPath: () => string;
+    checkCameraTime(): Promise<boolean>;
+    getStorageInfo(): Promise<TStorage>;
+    getNetworkCameraList(): Promise<TNetworkCamera[]>;
+    getPackageList(): Promise<TPackageInfoList>;
+    installPackages(formData: FormData, storage: TStorageType): Promise<{
+        status: number;
+        message: string;
+    }>;
+    uninstallPackage(packageId: string): Promise<{
+        status: number;
+        message: string;
+    }>;
+    importSettings(packageId: string, formData: FormData): Promise<{
+        status: number;
+        message: string;
+    }>;
+    exportSettings(packageId: string, formData: FormData): Promise<{
+        status: number;
+        message: string;
+    }>;
+    getNodejsStatus(): Promise<TNodeState>;
+    installNodejs(storage: TStorageType): Promise<{
+        status: number;
+        message: string;
+    }>;
+    private get;
+    private post;
+}