camstreamerlib 4.0.0-beta.32 → 4.0.0-beta.34

package/esm/PlaneTrackerAPI.js

@@ -18,49 +18,49 @@ export class PlaneTrackerAPI {
         const response = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         return z.boolean().parse(response.state);
     }
-    resetPtzCalibration = async (options) => {
+    async resetPtzCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/resetPtzCalibration.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
         });
-    };
-    resetFocusCalibration = async (options) => {
+    }
+    async resetFocusCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/resetFocusCalibration.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
         });
-    };
-    serverRunCheck = async (options) => {
+    }
+    async serverRunCheck(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
-    };
-    getLiveViewAlias = async (rtspUrl, options) => {
+    }
+    async getLiveViewAlias(rtspUrl, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/getLiveViewAlias.cgi`,
             parameters: { rtsp_url: rtspUrl },
             timeout: options?.timeout,
         });
-    };
-    fetchCameraSettings = async (options) => {
+    }
+    async fetchCameraSettings(options) {
         return await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
-    };
-    setCameraSettings = async (settingsJsonString, options) => {
+    }
+    async setCameraSettings(settingsJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settingsJsonString, {
             action: 'set',
         }, options);
-    };
-    fetchServerSettings = async (options) => {
+    }
+    async fetchServerSettings(options) {
         return await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
-    };
-    exportAppSettings = async (dataType, options) => {
+    }
+    async exportAppSettings(dataType, options) {
         return await this._getBlob(`${BASE_PATH}/package_data.cgi`, { action: 'EXPORT', dataType }, options);
-    };
-    importAppSettings = async (dataType, formData, options) => {
+    }
+    async importAppSettings(dataType, formData, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.post({
             path: `${BASE_PATH}/package_data.cgi`,
@@ -68,74 +68,74 @@ export class PlaneTrackerAPI {
             parameters: { action: 'IMPORT', dataType },
             timeout: options?.timeout,
         });
-    };
-    fetchFlightInfo = async (icao, options) => {
+    }
+    async fetchFlightInfo(icao, options) {
         return await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) }, options);
-    };
-    getTrackingMode = async (options) => {
+    }
+    async getTrackingMode(options) {
         return await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
-    };
-    setTrackingMode = async (modeJsonString, options) => {
+    }
+    async setTrackingMode(modeJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, modeJsonString, this.apiUser, options);
-    };
-    startTrackingPlane = async (icao, options) => {
+    }
+    async startTrackingPlane(icao, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/trackIcao.cgi`,
             parameters: { icao, ...this.apiUser },
             timeout: options?.timeout,
         });
-    };
-    stopTrackingPlane = async (options) => {
+    }
+    async stopTrackingPlane(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/resetIcao.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
         });
-    };
-    getPriorityList = async (options) => {
+    }
+    async getPriorityList(options) {
         return await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
-    };
-    setPriorityList = async (priorityListJsonString, options) => {
+    }
+    async setPriorityList(priorityListJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, priorityListJsonString, this.apiUser, options);
-    };
-    getWhiteList = async (options) => {
+    }
+    async getWhiteList(options) {
         return await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
-    };
-    setWhiteList = async (whiteListJsonString, options) => {
+    }
+    async setWhiteList(whiteListJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, whiteListJsonString, this.apiUser, options);
-    };
-    getBlackList = async (options) => {
+    }
+    async getBlackList(options) {
         return await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
-    };
-    setBlackList = async (blackListJsonString, options) => {
+    }
+    async setBlackList(blackListJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, blackListJsonString, this.apiUser, options);
-    };
-    fetchMapInfo = async (options) => {
+    }
+    async fetchMapInfo(options) {
         return await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
-    };
-    getZones = async (options) => {
+    }
+    async getZones(options) {
         return await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
-    };
-    setZones = async (zonesJsonString, options) => {
+    }
+    async setZones(zonesJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, zonesJsonString, this.apiUser, options);
-    };
-    goToCoordinates = async (lat, lon, alt, options) => {
+    }
+    async goToCoordinates(lat, lon, alt, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/goToCoordinates.cgi`,
             parameters: { lat, lon, alt, ...this.apiUser },
             timeout: options?.timeout,
         });
-    };
-    checkGenetecConnection = async (params, options) => {
+    }
+    async checkGenetecConnection(params, options) {
         return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
-    };
-    getGenetecCameraList = async (params, options) => {
+    }
+    async getGenetecCameraList(params, options) {
         const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
         return await res.json();
-    };
+    }
     async _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({

package/esm/VapixAPI.js

@@ -1,4 +1,3 @@
-import * as prettifyXml from 'prettify-xml';
 import { arrayToUrl, isNullish, paramToUrl, responseStringify } from './internal/utils';
 import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, } from './types/VapixAPI';
 import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, } from './errors/errors';
@@ -7,8 +6,10 @@ import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
 export class VapixAPI {
     client;
-    constructor(client) {
+    CustomFormData;
+    constructor(client, CustomFormData = FormData) {
         this.client = client;
+        this.CustomFormData = CustomFormData;
     }
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
@@ -35,7 +36,11 @@ export class VapixAPI {
     }
     async getCameraImage(parameters, options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({ path: '/axis-cgi/jpg/image.cgi', parameters, timeout: options?.timeout });
+        return (await agent.get({
+            path: '/axis-cgi/jpg/image.cgi',
+            parameters,
+            timeout: options?.timeout,
+        }));
     }
     async getEventDeclarations(options) {
         const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
@@ -53,8 +58,7 @@ export class VapixAPI {
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
-        const declarations = await res.text();
-        return prettifyXml(declarations);
+        return await res.text();
     }
     async getSupportedAudioSampleRate(options) {
         const path = '/axis-cgi/audio/streamingcapabilities.cgi';
@@ -250,7 +254,6 @@ export class VapixAPI {
         if (responseText.startsWith('# Error')) {
             throw new Error(responseText);
         }
-        return true;
     }
     async getGuardTourList(options) {
         const gTourList = new Array();
@@ -455,7 +458,7 @@ export class VapixAPI {
         }
     }
     async installApplication(data, fileName, options) {
-        const formData = new FormData();
+        const formData = new this.CustomFormData();
         formData.append('packfil', data, fileName);
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({

package/esm/index.js

@@ -2,6 +2,7 @@ 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 { CamSwitcherAPI } from './CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
@@ -15,9 +16,3 @@ export * from './types/CamSwitcherAPI';
 export * from './types/VapixAPI';
 export * from './types/CamOverlayAPI';
 export * from './types/PlaneTrackerAPI';
-export { Frame } from './CamOverlayPainter/Frame';
-export { Painter } from './CamOverlayPainter/Painter';
-export { ResourceManager } from './CamOverlayPainter/ResourceManager';
-export * from './types/CamOverlayPainter';
-export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
-export * from './types/CamOverlayDrawingAPI';

package/esm/internal/ProxyClient.js

@@ -6,19 +6,19 @@ export class ProxyClient {
         this.client = client;
         this.proxyParams = proxyParams;
     }
-    get = (params) => {
+    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) => {
+    }
+    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) => {
+    }
+    getReal(targetPath, headers) {
         return {
             realPath: this.proxyParams.path,
             realHeaders: {
@@ -32,5 +32,5 @@ export class ProxyClient {
                 '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/node/DefaultClient.js

@@ -22,16 +22,16 @@ export class DefaultClient {
         }
         this.httpRequestSender = new HttpRequestSender(agentOptions);
     }
-    get = (params) => {
+    get(params) {
         const { path, parameters, headers, timeout } = params;
         const options = this.getBaseConnectionParams('GET', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options);
-    };
-    post = (params) => {
+    }
+    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, headers, timeout) {
         return {
             method: method,

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;

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 { Digest } from './Digest';
 export class WsClient extends EventEmitter {
     user;
     pass;

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

@@ -1,6 +1,6 @@
-import { pad } from '../internal/utils';
-import { ProxyClient } from '../internal/ProxyClient';
-import { DefaultClient } from '../node';
+import { pad } from '../../internal/utils';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { DefaultClient } from '../DefaultClient';
 export class AxisCameraStationEvents {
     sourceKey;
     client;

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

@@ -1,27 +1,24 @@
 import { z } from 'zod';
-import { responseStringify, pad } from '../internal/utils';
-const ACTION = 'AddCameraBookmark';
-const GET_CAMERAS_URL = 'report/EntityConfiguration?q=EntityTypes@Camera';
-const GET_CAMERAS_DETAILS_URL = '/entity?q=';
-const cameraGuidsResponseSchema = z.object({
+import { responseStringify, pad } from '../../internal/utils';
+const successResponseSchema = z.object({
     Rsp: z.object({
-        Status: z.string(),
-        Result: z.array(z.object({ Guid: z.string() })),
+        Status: z.literal('Ok'),
     }),
 });
-const connectionResponseSchema = z.object({
+const cameraGuidsResponseSchema = z.object({
     Rsp: z.object({
-        Status: z.string(),
+        Status: z.literal('Ok'),
+        Result: z.array(z.object({ Guid: z.string() })),
     }),
 });
-export const cameraDetailSchema = z.object({
+const cameraDetailSchema = z.object({
     Guid: z.string().optional(),
     Name: z.string().optional(),
     EntityType: z.string().optional(),
 });
-export const cameraDetailsResponseSchema = z.object({
+const cameraDetailsResponseSchema = z.object({
     Rsp: z.object({
-        Status: z.string(),
+        Status: z.literal('Ok'),
         Result: z.union([z.array(cameraDetailSchema), cameraDetailSchema]),
     }),
 });
@@ -45,56 +42,70 @@ export class GenetecAgent {
     }
     async checkConnection() {
         const requestOptions = this.getRequestOptions('GET');
-        const res = await this.fetchWithTimeout(`${this.baseUrl}/`, requestOptions);
+        const res = await this.fetchWithTimeout(new URL(this.baseUrl), requestOptions);
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
-        return connectionResponseSchema.parse(await res.json());
+        const responseBody = await res.text();
+        const result = await successResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Genetec connection test failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
     }
     async getAllCameraGuids() {
         const requestOptions = this.getRequestOptions('GET');
-        const res = await this.fetchWithTimeout(`${this.baseUrl}/${GET_CAMERAS_URL}`, requestOptions);
+        const url = new URL(`${this.baseUrl}/report/EntityConfiguration`);
+        url.searchParams.set('q', 'EntityTypes@Camera');
+        const res = await this.fetchWithTimeout(url, requestOptions);
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
-        return cameraGuidsResponseSchema.parse(await res.json());
+        const responseBody = await res.text();
+        const result = await cameraGuidsResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Genetec get camera guids failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
+        return result.data;
     }
     async getCameraDetails(guids, parameters) {
         const params = parameters.join(',');
-        let camerasGuids = [];
         const requestOptions = this.getRequestOptions('GET');
         const allCameras = [];
         const chunkSize = 10;
         while (guids.length > 0) {
             const chunk = guids.slice(0, chunkSize);
             guids.splice(0, chunkSize);
-            camerasGuids = chunk.map((item) => item.Guid);
-            const camerasDetailsUrl = [];
-            for (const guid of camerasGuids) {
-                camerasDetailsUrl.push(`entity=${guid},${params}`);
-            }
-            const res = await this.fetchWithTimeout(`${this.baseUrl}/${GET_CAMERAS_DETAILS_URL}${camerasDetailsUrl.join(',')}`, requestOptions);
+            const url = new URL(`${this.baseUrl}/entity`);
+            url.searchParams.set('q', chunk.map((item) => `entity=${item.Guid},${params}`).join(','));
+            const res = await this.fetchWithTimeout(url, requestOptions);
             if (!res.ok) {
                 throw new Error(await responseStringify(res));
             }
-            const data = cameraDetailsResponseSchema.parse(await res.json());
+            const responseBody = await res.text();
+            const result = await cameraDetailsResponseSchema.safeParseAsync(JSON.parse(responseBody));
+            if (!result.success) {
+                throw new Error('Genetec get camera details failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+            }
+            const data = result.data;
             const resultArray = Array.isArray(data.Rsp.Result) ? data.Rsp.Result : [data.Rsp.Result];
             allCameras.push(...resultArray);
         }
         return allCameras;
     }
     async sendBookmark(guids, bookmarkText) {
-        const cameraEntitiesUrl = [];
         const timeStamp = this.getTimeStamp();
         const requestOptions = this.getRequestOptions('POST');
-        for (const guid of guids) {
-            cameraEntitiesUrl.push(`${ACTION}(${guid},${timeStamp},${bookmarkText})`);
-        }
-        const res = await this.fetchWithTimeout(`${this.baseUrl}/action?q=${cameraEntitiesUrl.join(',')}`, requestOptions);
+        const url = new URL(`${this.baseUrl}/action`);
+        url.searchParams.set('q', guids.map((guid) => `AddCameraBookmark(${guid},${timeStamp},${bookmarkText})`).join(','));
+        const res = await this.fetchWithTimeout(url, requestOptions);
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
-        return res;
+        const responseBody = await res.text();
+        const result = await successResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Genetec send bookmark failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
     }
     getRequestOptions(method) {
         return {

package/esm/node/index.js

@@ -1,4 +1,5 @@
-export { DefaultClient } from './DefaultClient';
-export { WsClient } from './WsClient';
-export { AxisCameraStationEvents } from '../events/AxisCameraStationEvents';
-export * from '../events/GenetecAgent';
+export * from './DefaultClient';
+export * from './WsClient';
+export * from './HttpServer';
+export * from './events/AxisCameraStationEvents';
+export * from './events/GenetecAgent';

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -8,6 +8,7 @@ import { pipSchema } from './pipSchema';
 import { customGraphicsSchema } from './customGraphicsSchema';
 import { screenSharingSchema } from './screenSharingSchema';
 import { webCameraSharingSchema } from './webCameraSharingSchema';
+import { baseballScoreBoardAutomaticSchema, baseballScoreBoardSchema, scoreBoardSchema, scoreOverviewSchema, } from './scoreBoardSchema';
 export const WSResponseSchema = z.object({
     status: z.number(),
     message: z.string(),
@@ -23,6 +24,10 @@ export const widgetsSchema = z.discriminatedUnion('name', [
     customGraphicsSchema,
     screenSharingSchema,
     webCameraSharingSchema,
+    scoreBoardSchema,
+    baseballScoreBoardSchema,
+    baseballScoreBoardAutomaticSchema,
+    scoreOverviewSchema,
 ]);
 export const widgetListSchema = z.object({
     services: z.array(widgetsSchema),
@@ -36,6 +41,10 @@ export const isPtzCompass = (widget) => widget.name === 'ptzCompass';
 export const isPtz = (widget) => widget.name === 'ptz';
 export const isScreenSharing = (widget) => widget.name === 'screenSharing';
 export const isWebCameraSharing = (widget) => widget.name === 'web_camera';
+export const isScoreBoard = (widget) => widget.name === 'scoreBoard';
+export const isBaseballScoreBoard = (widget) => widget.name === 'baseballScoreBoard';
+export const isBaseballScoreBoardAutomatic = (widget) => widget.name === 'myBallBaseballWidgets';
+export const isScoreOverview = (widget) => widget.name === 'scoreOverview';
 export var ImageType;
 (function (ImageType) {
     ImageType[ImageType["PNG"] = 0] = "PNG";