camstreamerlib 4.0.0-beta.4 → 4.0.0-beta.41

package/esm/{CreatePackage.js → bin/CreatePackage.js}

@@ -1,6 +1,6 @@
-import * as AdmZip from 'adm-zip';
-import * as Path from 'path';
-import * as fs from 'fs';
+import AdmZip from 'adm-zip';
+import Path from 'path';
+import fs from 'fs';
 import { execSync } from 'child_process';
 const productionModulesFolder = 'production_modules';
 function isDirectory(path) {

package/esm/errors/errors.js

@@ -16,6 +16,24 @@ export class ParsingBlobError extends Error {
         this.name = 'ParsingBlobError';
     }
 }
+export class JsonParseError extends Error {
+    constructor(paramName, data) {
+        super(`Error: in JSON parsing of ${paramName}. Cannot parse: ${data}`);
+        this.name = 'JsonParseError';
+    }
+}
+export class ParameterNotFoundError extends Error {
+    constructor(paramName) {
+        super(`Error: no parameter '${paramName}' was found`);
+        this.name = 'ParameterNotFoundError';
+    }
+}
+export class SettingParameterError extends Error {
+    constructor(message) {
+        super(`Error setting parameter to camera: ${message}`);
+        this.name = 'SettingParameterError';
+    }
+}
 export class ApplicationAPIError extends Error {
     constructor(action, res) {
         super(`[APP ${action}] Error: ` + res);
@@ -64,3 +82,51 @@ export class AddNewClipError extends Error {
         this.name = 'AddNewClipError';
     }
 }
+export class PtzNotSupportedError extends Error {
+    constructor() {
+        super('Ptz not supported.');
+        this.name = 'PtzNotSupportedError';
+    }
+}
+export class StorageDataFetchError extends Error {
+    constructor(err) {
+        super('Error fetching storage data: ' + err);
+        this.name = 'StorageDataFetchError';
+    }
+}
+export class WsAuthorizationError extends Error {
+    constructor(message) {
+        super('Server error on ws authorization: ' + message);
+        this.name = 'WsAuthorizationError';
+    }
+}
+export class UtcTimeFetchError extends Error {
+    constructor(message) {
+        super('Server error on get UTC time: ' + message);
+        this.name = 'UtcTimeFetchError';
+    }
+}
+export class TimezoneNotSetupError extends Error {
+    constructor() {
+        super('Time zone not setup on the device');
+        this.name = 'TimezoneNotSetupError';
+    }
+}
+export class TimezoneFetchError extends Error {
+    constructor(err) {
+        super('Error fetching time zone information: ' + err);
+        this.name = 'TimezoneFetchError';
+    }
+}
+export class ResetCalibrationError extends Error {
+    constructor(type, err) {
+        super('Error resetting ' + type.toLowerCase() + ' calibration: ' + err);
+        this.name = 'ResetCalibrationError';
+    }
+}
+export class ImportSettingsError extends Error {
+    constructor(err) {
+        super('Error importing settings: ' + err);
+        this.name = 'ImportSettingsError';
+    }
+}

package/esm/index.js

@@ -1,11 +1,20 @@
-export * from './internal/common';
+export * from './internal/types';
 export * from './internal/constants';
 export * from './internal/utils';
 export * from './internal/versionCompare';
+export * from './internal/ProxyClient';
 export * from './types/common';
+export { CamOverlayAPI } from './CamOverlayAPI';
+export * from './types/CamOverlayAPI';
+export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
+export { CamStreamerAPI } from './CamStreamerAPI';
+export * from './types/CamStreamerAPI';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
+export * from './types/CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
-export { VapixAPI } from './VapixAPI';
 export * from './types/CamSwitcherEvents';
-export * from './types/CamSwitcherAPI';
+export { PlaneTrackerAPI } from './PlaneTrackerAPI';
+export * from './types/PlaneTrackerAPI';
+export { VapixAPI } from './VapixAPI';
 export * from './types/VapixAPI';

package/esm/internal/ProxyClient.js

@@ -1,40 +1,36 @@
 import { addParametersToPath } from './utils';
 export class ProxyClient {
     client;
-    getProxyUrl;
-    constructor(client, getProxyUrl) {
+    proxyParams;
+    constructor(client, proxyParams) {
         this.client = client;
-        this.getProxyUrl = getProxyUrl;
+        this.proxyParams = proxyParams;
     }
-    get = (proxy, path, parameters, headers = {}) => {
-        const url = addParametersToPath(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.get(realUrl, {}, realHeaders);
-    };
-    post = (proxy, path, data, parameters, headers) => {
-        const url = addParametersToPath(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.post(realUrl, data, {}, realHeaders);
-    };
-    getReal = (proxy, url, headers) => {
-        if (proxy !== null) {
-            return {
-                realUrl: this.getProxyUrl(),
-                realHeaders: {
-                    ...(headers ?? {}),
-                    'x-target-camera-protocol': proxy.port === 443 ? 'https' : 'http',
-                    'x-target-camera-path': url,
-                    'x-target-camera-ip': proxy.ip,
-                    'x-target-camera-mdns': proxy.mdnsName,
-                    'x-target-camera-port': String(proxy.port),
-                    'x-target-camera-pass': encodeURIComponent(proxy.pass),
-                    'x-target-camera-user': encodeURIComponent(proxy.user),
-                },
-            };
-        }
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const targetPath = addParametersToPath(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.get({ path: realPath, headers: realHeaders, timeout });
+    }
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const targetPath = addParametersToPath(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.post({ path: realPath, data, headers: realHeaders, timeout });
+    }
+    getReal(targetPath, headers) {
         return {
-            realUrl: url,
-            realHeaders: headers,
+            realPath: this.proxyParams.path,
+            realHeaders: {
+                ...(headers ?? {}),
+                'x-target-camera-protocol': this.proxyParams.target.port === 443 ? 'https' : 'http',
+                'x-target-camera-path': targetPath,
+                'x-target-camera-ip': this.proxyParams.target.ip,
+                'x-target-camera-mdns': this.proxyParams.target.mdnsName,
+                'x-target-camera-port': String(this.proxyParams.target.port),
+                'x-target-camera-pass': this.proxyParams.target.pass,
+                'x-target-camera-user': this.proxyParams.target.user,
+            },
         };
-    };
+    }
 }

package/esm/internal/WsEvents.js

@@ -0,0 +1,68 @@
+export class WsEvents {
+    zodSchema;
+    ws;
+    _isDestroyed = false;
+    listeners = {};
+    constructor(zodSchema, ws) {
+        this.zodSchema = zodSchema;
+        this.ws = ws;
+        this.ws.onmessage = (e) => this.onMessage(e);
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    resendInitData() {
+        const request = {
+            command: 'sendInitData',
+        };
+        this.ws.send(JSON.stringify(request));
+    }
+    addListener(type, listener, id) {
+        const typeList = this.listeners[type];
+        if (typeList === undefined) {
+            this.listeners[type] = { [id]: listener };
+            return;
+        }
+        typeList[id] = listener;
+    }
+    removeListener(type, id) {
+        const typeList = this.listeners[type];
+        if (typeList) {
+            delete typeList[id];
+            if (Object.keys(typeList).length === 0) {
+                delete this.listeners[type];
+            }
+        }
+    }
+    onMessage(evt) {
+        if (this.isDestroyed) {
+            return;
+        }
+        try {
+            const eventData = JSON.parse(evt.data);
+            const data = this.zodSchema.parse(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);
+        }
+    }
+    processMessage(event, isInit) {
+        const listeners = this.listeners[event.type];
+        const list = Object.values(listeners ?? {});
+        list.forEach((listener) => listener(event, isInit));
+    }
+    destroy() {
+        this._isDestroyed = true;
+        this.ws.onmessage = () => { };
+        this.ws.destroy();
+        this.listeners = {};
+    }
+}
+const isInitEvent = (event) => {
+    return event.type === 'init';
+};

package/esm/internal/utils.js

@@ -1,4 +1,3 @@
-import { isNullish } from './common';
 export const addParametersToPath = (path, params) => {
     if (params === undefined || Object.keys(params).length === 0) {
         return path;
@@ -32,3 +31,20 @@ export const isClip = (id) => id?.charAt(0) === 's';
 export const isTracker = (id) => id?.charAt(0) === 't';
 export const isPlaylist = (id) => id?.charAt(0) === 'p';
 export const isLoopPlayType = (playType) => playType.includes('LOOP');
+export async function responseStringify(res) {
+    return JSON.stringify({
+        status: res.status,
+        body: await res.text(),
+    });
+}
+export function pad(num, size) {
+    const sign = Math.sign(num) === -1 ? '-' : '';
+    return (sign +
+        new Array(size)
+            .concat([Math.abs(num)])
+            .join('0')
+            .slice(-size));
+}
+export function isNullish(value) {
+    return value === null || value === undefined;
+}

package/esm/{CamOverlayDrawingAPI.js → node/CamOverlayDrawingAPI.js}

@@ -1,5 +1,5 @@
-import * as EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import EventEmitter from 'events';
+import { WsClient } from './WsClient';
 export class CamOverlayDrawingAPI extends EventEmitter {
     tls;
     tlsInsecure;

package/esm/{CamOverlayPainter → node/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 → node/CamOverlayPainter}/Painter.js

@@ -1,17 +1,7 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
+import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
-export const 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],
-};
+import { COORD } from '../../types/CamOverlayPainter';
 export class Painter extends Frame {
     screenWidth;
     screenHeight;
@@ -163,4 +153,3 @@ export class Painter extends Frame {
         }
     }
 }
-export { Frame, ResourceManager };

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

@@ -1,5 +1,5 @@
 import * as fs from 'fs/promises';
-export default class ResourceManager {
+export class ResourceManager {
     co;
     imgFileNames = {};
     fontFileNames = {};
@@ -18,8 +18,9 @@ export default class ResourceManager {
         if (this.images[moniker] !== undefined) {
             return this.images[moniker];
         }
-        if (this.imgFileNames[moniker] !== undefined) {
-            const imgData = await fs.readFile(this.imgFileNames[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];
         }
@@ -29,8 +30,9 @@ export default class ResourceManager {
         if (this.fonts[moniker] !== undefined) {
             return this.fonts[moniker];
         }
-        if (this.fontFileNames[moniker] !== undefined) {
-            const fontData = await fs.readFile(this.fontFileNames[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];
         }

package/esm/{CamScripterAPICameraEventsGenerator.js → node/CamScripterAPICameraEventsGenerator.js}

@@ -1,5 +1,5 @@
-import * as EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import EventEmitter from 'events';
+import { WsClient } from './WsClient';
 export class CamScripterAPICameraEventsGenerator extends EventEmitter {
     tls;
     tlsInsecure;

package/esm/node/DefaultClient.js

@@ -22,29 +22,27 @@ export class DefaultClient {
         }
         this.httpRequestSender = new HttpRequestSender(agentOptions);
     }
-    get url() {
-        return `${this.tls ? 'https' : 'http'}://${this.user}:${this.pass}@${this.ip}:${this.port}`;
-    }
-    async get(path, parameters = {}, headers) {
-        const options = this.getBaseConnectionParams('GET', path, parameters);
-        options.headers = headers;
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const options = this.getBaseConnectionParams('GET', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options);
     }
-    async post(path, data, parameters = {}, headers) {
-        const options = this.getBaseConnectionParams('POST', path, parameters);
-        options.headers = headers;
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const options = this.getBaseConnectionParams('POST', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options, data);
     }
-    getBaseConnectionParams(method, path, params) {
-        const pathName = addParametersToPath(path, params);
+    getBaseConnectionParams(method, path, params, headers, timeout) {
         return {
             method: method,
             protocol: this.tls ? 'https:' : 'http:',
             host: this.ip,
             port: this.port,
-            path: pathName,
+            path: addParametersToPath(path, params),
             user: this.user,
             pass: this.pass,
+            headers,
+            timeout,
         };
     }
 }

package/esm/{internal → node}/Digest.js

@@ -1,4 +1,4 @@
-import * as crypto from 'crypto';
+import crypto from 'crypto';
 export class Digest {
     nonceCount = 1;
     getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {

package/esm/node/HttpRequestSender.js

@@ -1,4 +1,4 @@
-import { Digest } from '../internal/Digest';
+import { Digest } from './Digest';
 import { Agent, fetch as undiciFetch, Request as UndiciRequest, } from 'undici';
 export class HttpRequestSender {
     agent;
@@ -8,8 +8,18 @@ export class HttpRequestSender {
             connect: { rejectUnauthorized: agentOptions?.rejectUnaurhorized, keepAlive: agentOptions?.keepAlive },
         });
     }
-    sendRequest(options, postData) {
-        return this.sendRequestWithAuth(options, postData);
+    async sendRequest(options, postData) {
+        const stackHolder = { stack: '' };
+        Error.captureStackTrace(stackHolder, this.sendRequest);
+        try {
+            return await this.sendRequestWithAuth(options, postData);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                err.stack = `${err.stack}\nCaptured at:\n${stackHolder.stack}`;
+            }
+            throw err;
+        }
     }
     async sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
         options.timeout ??= 10000;
@@ -79,7 +89,7 @@ export class HttpRequestSender {
             return authData.digest.getAuthHeader(options.user, options.pass, options.method ?? 'GET', options.path, authData.wwwAuthenticateHeader);
         }
         else {
-            return `Basic ${btoa(options.user + ':' + options.pass)}`;
+            return `Basic ${Buffer.from(`${options.user}:${options.pass}`).toString('base64')}`;
         }
     }
 }

package/esm/node/HttpServer.js

@@ -1,8 +1,8 @@
-import * as http from 'http';
-import * as url from 'url';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as EventEmitter from 'events';
+import http from 'http';
+import url from 'url';
+import fs from 'fs';
+import path from 'path';
+import EventEmitter from 'events';
 export class HttpServer extends EventEmitter {
     host;
     port;

package/esm/{VapixEvents.js → node/VapixEvents.js}

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsClient } from './node/WsClient';
+import { WsClient } from './WsClient';
 export class VapixEvents extends EventEmitter {
     tls;
     tlsInsecure;

package/esm/node/WsClient.js

@@ -1,6 +1,6 @@
-import * as EventEmitter from 'events';
-import * as WebSocket from 'ws';
-import { Digest } from '../internal/Digest';
+import EventEmitter from 'events';
+import WebSocket from 'ws';
+import { Digest } from './Digest';
 export class WsClient extends EventEmitter {
     user;
     pass;

package/esm/{events → node/events}/AxisCameraStationEvents.js

@@ -1,18 +1,17 @@
-import { DefaultClient } from '../node/DefaultClient';
-import { isClient, pad } from '../internal/common';
+import { pad } from '../../internal/utils';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { DefaultClient } from '../DefaultClient';
 export class AxisCameraStationEvents {
     sourceKey;
     client;
-    constructor(sourceKey, opt = {}) {
+    constructor(clientOptions, sourceKey) {
         this.sourceKey = sourceKey;
-        if (isClient(opt)) {
-            this.client = opt;
-        }
-        else {
-            this.client = new DefaultClient(opt);
-        }
+        this.client = new DefaultClient(clientOptions);
     }
-    async sendEvent(data, eventType) {
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async sendEvent(data, eventType, options) {
         const dateString = this.getDate();
         const event = {
             addExternalDataRequest: {
@@ -23,9 +22,15 @@ export class AxisCameraStationEvents {
             },
         };
         const eventData = JSON.stringify(event);
-        const res = await this.client.post('/Acs/Api/ExternalDataFacade/AddExternalData', eventData, undefined, {
-            'Content-Type': 'application/json',
-            'Content-Length': eventData.length.toString(),
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/Acs/Api/ExternalDataFacade/AddExternalData',
+            data: eventData,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': eventData.length.toString(),
+            },
+            timeout: options?.timeout,
         });
         if (!res.ok) {
             throw new Error(`ACS status code: ${res.status}`);