camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.20

package/cjs/CamOverlayAPI.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamOverlayAPI = exports.BASE_URL = void 0;
+const utils_1 = require("./internal/utils");
+const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+const errors_1 = require("./errors/errors");
+const common_1 = require("./types/common");
+const zod_1 = require("zod");
+const widgetsSchema_1 = require("./models/CamOverlayAPI/widgetsSchema");
+const fileSchema_1 = require("./models/CamOverlayAPI/fileSchema");
+exports.BASE_URL = '/local/camoverlay/api';
+class CamOverlayAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    static getProxyUrlPath = () => `${exports.BASE_URL}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${exports.BASE_URL}/image.cgi?path=${encodeURIComponent(path)}`;
+    async checkCameraTime() {
+        const responseSchema = zod_1.z.discriminatedUnion('state', [
+            zod_1.z.object({
+                state: zod_1.z.literal(true),
+                code: zod_1.z.number(),
+            }),
+            zod_1.z.object({
+                state: zod_1.z.literal(false),
+                code: zod_1.z.number(),
+                reason: zod_1.z.union([
+                    zod_1.z.literal('INVALID_TIME'),
+                    zod_1.z.literal('COULDNT_RESOLVE_HOST'),
+                    zod_1.z.literal('CONNECTION_ERROR'),
+                ]),
+                message: zod_1.z.string(),
+            }),
+        ]);
+        const response = await this._get(`${exports.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(`${exports.BASE_URL}/network_camera_list.cgi`);
+        return common_1.networkCameraListSchema.parse(response.camera_list);
+    }
+    async wsAuthorization() {
+        const responseSchema = zod_1.z.object({
+            status: zod_1.z.number(),
+            message: zod_1.z.string(),
+            data: zod_1.z.string(),
+        });
+        const response = await this._get(`${exports.BASE_URL}/ws_authorization.cgi`);
+        return responseSchema.parse(response).data;
+    }
+    async getMjpegStreamImage(mjpegUrl) {
+        return await this._getBlob(`${exports.BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
+    }
+    async listFiles(fileType) {
+        const fileDataSchema = zod_1.z.object({
+            code: zod_1.z.number(),
+            list: fileSchema_1.fileListSchema,
+        });
+        const files = await this._get(`${exports.BASE_URL}/upload_${fileType}.cgi`, {
+            action: 'list',
+        });
+        return fileSchema_1.fileListSchema.parse(files.list);
+    }
+    async uploadFile(fileType, formData, storage) {
+        const path = `${exports.BASE_URL}/upload_${fileType}.cgi`;
+        await this._post(path, formData, {
+            action: 'upload',
+            storage: storage,
+        });
+    }
+    async removeFile(fileType, fileParams) {
+        const path = `${exports.BASE_URL}/upload_${fileType}.cgi`;
+        await this._postUrlEncoded(path, {
+            action: 'remove',
+            ...fileParams,
+        });
+    }
+    async getFileStorage(fileType) {
+        const storageDataListSchema = zod_1.z.array(zod_1.z.object({
+            type: fileSchema_1.storageSchema,
+            state: zod_1.z.string(),
+        }));
+        const responseSchema = zod_1.z.object({
+            code: zod_1.z.number(),
+            list: storageDataListSchema,
+        });
+        const data = await this._get(`${exports.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(`${exports.BASE_URL}/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+    }
+    async setEnabled(serviceID, enabled) {
+        await this._post(`${exports.BASE_URL}/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+    }
+    async isEnabled(serviceID) {
+        const res = await this.client.get(`${exports.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 errors_1.ServiceNotFoundError();
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async getSingleWidget(serviceId) {
+        const data = await this._get(`${exports.BASE_URL}/services.cgi`, {
+            action: 'get',
+            service_id: serviceId.toString(),
+        });
+        return widgetsSchema_1.widgetsSchema.parse(data);
+    }
+    async getWidgets() {
+        const widgetList = await this._get(`${exports.BASE_URL}/services.cgi`, {
+            action: 'get',
+        });
+        const widgets = widgetList.services;
+        widgets.forEach((widget) => {
+            const parsedWidget = widgetsSchema_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 updateSingleWidget(widget) {
+        const path = `${exports.BASE_URL}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify(widget), {
+            action: 'set',
+            service_id: widget.id.toString(),
+        });
+    }
+    async updateWidgets(widgets) {
+        const path = `${exports.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 === 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);
+    }
+    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
+        const path = `${exports.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 (0, utils_1.responseStringify)(res));
+        }
+    }
+    async _get(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return (await res.json());
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async _post(...args) {
+        const res = await this.client.post(...args);
+        if (res.ok) {
+            return (await res.json());
+        }
+        else {
+            throw new Error(await (0, utils_1.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 (0, utils_1.responseStringify)(res));
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new errors_1.ParsingBlobError(err);
+        }
+    }
+    async _postUrlEncoded(path, params, headers) {
+        const data = (0, utils_1.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 });
+    }
+}
+exports.CamOverlayAPI = CamOverlayAPI;

package/{CamOverlayDrawingAPI.d.ts → cjs/CamOverlayDrawingAPI.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as EventEmitter from 'events';
-import { WsOptions } from './internal/common';
+import { WsOptions } from './internal/types';
 export type CamOverlayDrawingOptions = WsOptions & {
     camera?: number | number[];
     zIndex?: number;

package/cjs/CamOverlayDrawingAPI.js

@@ -0,0 +1,235 @@
+"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 {
+    tls;
+    tlsInsecure;
+    ip;
+    port;
+    user;
+    pass;
+    cameraList;
+    zIndex;
+    callId;
+    sendMessages;
+    timeoutCheckTimer;
+    wsConnected;
+    ws;
+    constructor(options) {
+        super();
+        this.tls = options?.tls ?? false;
+        this.tlsInsecure = options?.tlsInsecure ?? false;
+        this.ip = options?.ip ?? '127.0.0.1';
+        this.port = options?.port ?? (this.tls ? 443 : 80);
+        this.user = options?.user ?? '';
+        this.pass = options?.pass ?? '';
+        this.zIndex = options?.zIndex ?? 0;
+        this.cameraList = [0];
+        if (options && Array.isArray(options.camera)) {
+            this.cameraList = options.camera;
+        }
+        else if (typeof options?.camera === 'number') {
+            this.cameraList = [options.camera];
+        }
+        this.callId = 0;
+        this.sendMessages = {};
+        this.wsConnected = false;
+        this.createWsClient();
+        EventEmitter.call(this);
+    }
+    connect() {
+        this.ws.open();
+        this.startMsgsTimeoutCheck();
+    }
+    disconnect() {
+        this.ws.close();
+        this.stopMsgsTimeoutCheck();
+    }
+    isConnected() {
+        return this.wsConnected;
+    }
+    cairo(command, ...params) {
+        return this.sendMessage({ command: command, params: params });
+    }
+    writeText(...params) {
+        return this.sendMessage({ command: 'write_text', params: params });
+    }
+    uploadImageData(imgBuffer) {
+        return this.sendBinaryMessage({
+            command: 'upload_image_data',
+            params: [],
+        }, imgBuffer);
+    }
+    uploadFontData(fontBuffer) {
+        return this.sendBinaryMessage({
+            command: 'upload_font_data',
+            params: [fontBuffer.toString('base64')],
+        }, fontBuffer);
+    }
+    showCairoImage(cairoImage, posX, posY) {
+        return this.sendMessage({
+            command: 'show_cairo_image_v2',
+            params: [cairoImage, posX, posY, this.cameraList, this.zIndex],
+        });
+    }
+    showCairoImageAbsolute(cairoImage, posX, posY, width, height) {
+        return this.sendMessage({
+            command: 'show_cairo_image_v2',
+            params: [
+                cairoImage,
+                -1.0 + (2.0 / width) * posX,
+                -1.0 + (2.0 / height) * posY,
+                this.cameraList,
+                this.zIndex,
+            ],
+        });
+    }
+    removeImage() {
+        return this.sendMessage({ command: 'remove_image_v2', params: [] });
+    }
+    createWsClient() {
+        const options = {
+            ip: this.ip,
+            port: this.port,
+            address: '/local/camoverlay/ws',
+            protocol: 'cairo-api',
+            user: this.user,
+            pass: this.pass,
+            tls: this.tls,
+            tlsInsecure: this.tlsInsecure,
+        };
+        this.ws = new WsClient_1.WsClient(options);
+        this.ws.on('open', () => {
+            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.reportError(error);
+        });
+        this.ws.on('close', () => {
+            console.log('CamOverlay connection closed');
+            this.wsConnected = false;
+            this.reportClose();
+        });
+    }
+    incomingWsMessageHandler(msgData) {
+        const dataJSON = JSON.parse(msgData.toString());
+        let errorResponse;
+        if ('error' in dataJSON) {
+            errorResponse = dataJSON;
+        }
+        if (dataJSON.call_id !== undefined) {
+            if (errorResponse !== undefined) {
+                this.sendMessages[dataJSON.call_id]?.reject(new Error(errorResponse.error));
+            }
+            else {
+                this.sendMessages[dataJSON.call_id]?.resolve(dataJSON);
+            }
+            delete this.sendMessages[dataJSON.call_id];
+        }
+        if (errorResponse !== undefined) {
+            this.reconnectWithError(new Error(errorResponse.error));
+        }
+        else {
+            this.reportMessage(msgData.toString());
+        }
+    }
+    sendMessage(msgJson) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (!this.wsConnected) {
+                    throw new Error('No CamOverlay connection');
+                }
+                msgJson.call_id = ++this.callId;
+                this.ws.send(JSON.stringify(msgJson));
+                this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                const error = new Error(`Send message error: ${errorMessage}`);
+                reject(error);
+                if (!this.wsConnected) {
+                    this.reportError(error);
+                }
+                else {
+                    this.reconnectWithError(error);
+                }
+            }
+        });
+    }
+    sendBinaryMessage(msgJson, data) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (!this.wsConnected) {
+                    throw new Error('No CamOverlay connection');
+                }
+                msgJson.call_id = ++this.callId;
+                const jsonBuffer = Buffer.from(JSON.stringify(msgJson));
+                const header = new ArrayBuffer(5);
+                const headerView = new DataView(header);
+                headerView.setInt8(0, 1);
+                headerView.setInt32(1, jsonBuffer.byteLength);
+                const msgBuffer = Buffer.concat([Buffer.from(header), jsonBuffer, data]);
+                this.ws.send(msgBuffer);
+                this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                const error = new Error(`Send binary message error: ${errorMessage}`);
+                reject(error);
+                if (!this.wsConnected) {
+                    this.reportError(error);
+                }
+                else {
+                    this.reconnectWithError(error);
+                }
+            }
+        });
+    }
+    startMsgsTimeoutCheck() {
+        clearInterval(this.timeoutCheckTimer);
+        this.timeoutCheckTimer = setInterval(() => {
+            let reconnect = false;
+            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'));
+                    delete this.sendMessages[callId];
+                }
+            }
+            if (reconnect) {
+                this.reconnectWithError(new Error('Message timeout'));
+            }
+        }, 5000);
+    }
+    stopMsgsTimeoutCheck() {
+        clearInterval(this.timeoutCheckTimer);
+    }
+    reconnectWithError(err) {
+        this.reportError(err);
+        this.ws.reconnect();
+    }
+    reportMessage(msg) {
+        this.emit('message', msg);
+    }
+    reportError(err) {
+        this.emit('error', err);
+    }
+    reportClose() {
+        for (const callId in this.sendMessages) {
+            this.sendMessages[callId]?.reject(new Error('Connection lost'));
+        }
+        this.sendMessages = {};
+        this.emit('close');
+    }
+}
+exports.CamOverlayDrawingAPI = CamOverlayDrawingAPI;