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

package/esm/VapixAPI.d.ts

@@ -0,0 +1,78 @@
+import { IClient, TParameters, TResponse } from './internal/types';
+import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
+import { ProxyClient } from './internal/ProxyClient';
+import { TCameraImageConfig, TProxyParam } from './types/common';
+export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: ProxyClient<Client>;
+    constructor(client: Client, getProxyUrl: () => string);
+    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
+    postJson(proxy: TProxyParam, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
+    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<TResponse>;
+    getEventDeclarations(proxy?: TProxyParam): Promise<string>;
+    getSupportedAudioSampleRate(proxy?: TProxyParam): Promise<TAudioSampleRates[]>;
+    performAutofocus(proxy?: TProxyParam): Promise<void>;
+    checkSDCard(proxy?: TProxyParam): Promise<TSDCardInfo>;
+    mountSDCard(proxy?: TProxyParam): Promise<number>;
+    unmountSDCard(proxy?: TProxyParam): Promise<number>;
+    private _doSDCardMountAction;
+    fetchSDCardJobProgress(jobId: number, proxy?: TProxyParam): Promise<number>;
+    downloadCameraReport(proxy?: TProxyParam): Promise<TResponse>;
+    getSystemLog(proxy?: TProxyParam): Promise<TResponse>;
+    getMaxFps(channel: number, proxy?: TProxyParam): Promise<number>;
+    getTimezone(proxy?: TProxyParam): Promise<string>;
+    getDateTimeInfo(proxy?: TProxyParam): Promise<{
+        data: {
+            dateTime: string;
+            dstEnabled: boolean;
+            localDateTime: string;
+            posixTimeZone: string;
+            timeZone?: string | undefined;
+        };
+    }>;
+    getDevicesSettings(proxy?: TProxyParam): Promise<TAudioDevice[]>;
+    fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, proxy?: TProxyParam): Promise<any>;
+    getHeaders(proxy?: TProxyParam): Promise<Record<string, string>>;
+    setHeaders(headers: Record<string, string>, proxy?: TProxyParam): Promise<TResponse>;
+    getParameter(paramNames: string | string[], proxy?: TProxyParam): Promise<Record<string, string>>;
+    setParameter(params: Record<string, string | number | boolean>, proxy?: TProxyParam): Promise<boolean>;
+    getGuardTourList(proxy?: TProxyParam): Promise<{
+        name: string;
+        id: string;
+        running: string;
+        tour: {
+            moveSpeed?: unknown;
+            position?: unknown;
+            presetNbr?: unknown;
+            waitTime?: unknown;
+            waitTimeViewType?: unknown;
+        }[];
+        camNbr?: unknown;
+        randomEnabled?: unknown;
+        timeBetweenSequences?: unknown;
+    }[]>;
+    setGuardTourEnabled(guardTourID: string, enable: boolean, proxy?: TProxyParam): Promise<boolean>;
+    getPTZPresetList(channel: number, proxy?: TProxyParam): Promise<string[]>;
+    listPTZ(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItem[]>;
+    listPtzVideoSourceOverview(proxy?: TProxyParam): Promise<TPtzOverview>;
+    goToPreset(channel: number, presetName: string, proxy?: TProxyParam): Promise<TResponse>;
+    getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
+    getInputState(port: number, proxy?: TProxyParam): Promise<boolean>;
+    setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<TResponse>;
+    getApplicationList(proxy?: TProxyParam): Promise<{
+        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
+        Name: string;
+        NiceName: string;
+        Vendor: string;
+        Version: string;
+        License: string;
+        Status: string;
+        ApplicationID?: string | undefined;
+        ConfigurationPage?: string | undefined;
+        VendorHomePage?: string | undefined;
+        LicenseName?: string | undefined;
+    }[]>;
+    startApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    restartApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    stopApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    installApplication(data: Blob, fileName: string): Promise<void>;
+}

package/{VapixAPI.js → esm/VapixAPI.js}

@@ -1,17 +1,16 @@
 import * as prettifyXml from 'prettify-xml';
-import { parseStringPromise } from 'xml2js';
-import { isNullish, responseStringify } from './internal/common';
-import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, } from './types/VapixAPI';
-import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, SDCardActionError, SDCardJobError, } from './errors/errors';
+import { arrayToUrl, isNullish, paramToUrl, responseStringify } from './internal/utils';
+import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, } from './types/VapixAPI';
+import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, } from './errors/errors';
 import { ProxyClient } from './internal/ProxyClient';
-import { arrayToUrl, paramToUrl } from './internal/utils';
 import { z } from 'zod';
+import { XMLParser } from 'fast-xml-parser';
 export class VapixAPI {
     client;
     constructor(client, getProxyUrl) {
         this.client = new ProxyClient(client, getProxyUrl);
     }
-    async getUrlEncoded(proxy = null, path, parameters, headers = {}) {
+    async getUrlEncoded(proxy, path, parameters, headers = {}) {
         const data = paramToUrl(parameters);
         const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
         const res = await this.client.post(proxy, path, data, {}, head);
@@ -20,7 +19,7 @@ export class VapixAPI {
         }
         return res;
     }
-    async postJson(proxy = null, path, jsonData, headers = {}) {
+    async postJson(proxy, path, jsonData, headers = {}) {
         const data = JSON.stringify(jsonData);
         const head = { ...headers, 'Content-Type': 'application/json' };
         const res = await this.client.post(proxy, path, data, {}, head);
@@ -48,8 +47,8 @@ export class VapixAPI {
     }
     async getSupportedAudioSampleRate(proxy = null) {
         const url = '/axis-cgi/audio/streamingcapabilities.cgi';
-        const formData = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, url, formData);
+        const jsonData = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, url, jsonData);
         const encoders = audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
         const data = encoders.aac ?? encoders.AAC ?? [];
         return data.map((item) => {
@@ -75,7 +74,7 @@ export class VapixAPI {
             await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
         }
         catch (err) {
-            await this.postJson(proxy, '/axis-cgi/opticssetup.cgi', {
+            await this.getUrlEncoded(proxy, '/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',
             });
@@ -85,11 +84,13 @@ export class VapixAPI {
         const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/list.cgi', {
             diskid: 'SD_DISK',
         });
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
+        const xmlText = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
         });
+        const result = parser.parse(xmlText);
         const data = result.root.disks.disk;
         return {
             totalSize: parseInt(data.totalsize),
@@ -108,11 +109,13 @@ export class VapixAPI {
             action: action,
             diskid: 'SD_DISK',
         });
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
+        const textXml = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
         });
+        const result = parser.parse(textXml);
         const job = result.root.job;
         if (job.result !== 'OK') {
             throw new SDCardActionError(action, await responseStringify(res));
@@ -124,12 +127,13 @@ export class VapixAPI {
             jobid: String(jobId),
             diskid: 'SD_DISK',
         });
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
+        const textXml = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
         });
-        const job = result.root.job;
+        const job = parser.parse(textXml).root.job;
         if (job.result !== 'OK') {
             throw new SDCardJobError();
         }
@@ -164,9 +168,27 @@ export class VapixAPI {
         return captureMode.maxFPS;
     }
     async getTimezone(proxy = null) {
-        const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
-        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
-        return (await res.json())?.timeZone ?? 'Europe/Prague';
+        try {
+            const resV2 = await this.client.get(proxy, '/config/rest/time/v2/timeZone');
+            if (!resV2.ok) {
+                throw new Error(await responseStringify(resV2));
+            }
+            const json = await resV2.json();
+            const data = timeZoneSchema.parse(json);
+            if (data.status === 'error') {
+                throw new Error(data.error.message);
+            }
+            return data.data.activeTimeZone;
+        }
+        catch (error) {
+            console.warn('Failed to fetch time zone data from time API v2:', error instanceof Error ? error.message : JSON.stringify(error));
+            console.warn('Falling back to deprecated time API v1');
+        }
+        const data = await this.getDateTimeInfo(proxy);
+        if (data.data.timeZone === undefined) {
+            throw new Error('Time zone not setup on the device');
+        }
+        return data.data.timeZone;
     }
     async getDateTimeInfo(proxy = null) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
@@ -177,7 +199,7 @@ export class VapixAPI {
         const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
         const res = await this.postJson(proxy, '/axis-cgi/audiodevicecontrol.cgi', data);
         const result = audioDeviceRequestSchema.parse(await res.json());
-        return result.devices.map((device) => ({
+        return result.data.devices.map((device) => ({
             ...device,
             inputs: (device.inputs || []).sort((a, b) => a.id.localeCompare(b.id)),
             outputs: (device.outputs || []).sort((a, b) => a.id.localeCompare(b.id)),
@@ -185,15 +207,11 @@ export class VapixAPI {
     }
     async fetchRemoteDeviceInfo(payload, proxy = null) {
         const res = await this.postJson(proxy, '/axis-cgi/basicdeviceinfo.cgi', payload);
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
-        });
-        if (isNullish(result.body.data)) {
+        const json = await res.json();
+        if (isNullish(json.data)) {
             throw new NoDeviceInfoError();
         }
-        return result.data;
+        return json.data;
     }
     async getHeaders(proxy = null) {
         const data = { apiVersion: '1.0', method: 'list' };
@@ -231,9 +249,9 @@ export class VapixAPI {
                 const gTour = {
                     id: gTourBaseName,
                     camNbr: response[gTourBaseName + '.CamNbr'],
-                    name: response[gTourBaseName + '.Name'],
+                    name: response[gTourBaseName + '.Name'] ?? 'Guard Tour ' + (i + 1),
                     randomEnabled: response[gTourBaseName + '.RandomEnabled'],
-                    running: response[gTourBaseName + '.Running'],
+                    running: response[gTourBaseName + '.Running'] ?? 'no',
                     timeBetweenSequences: response[gTourBaseName + '.TimeBetweenSequences'],
                     tour: [],
                 };
@@ -289,17 +307,29 @@ export class VapixAPI {
             query: 'presetposcamdata',
             format: 'json',
         });
-        return parseCameraPtzResponse(await response.text())[camera] ?? [];
+        const text = await response.text();
+        if (text === '') {
+            throw new PtzNotSupportedError();
+        }
+        return parseCameraPtzResponse(text)[camera] ?? [];
     }
     async listPtzVideoSourceOverview(proxy = null) {
         const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
             query: 'presetposall',
             format: 'json',
         });
-        const data = parseCameraPtzResponse(await response.text());
+        const text = await response.text();
+        if (text === '') {
+            throw new PtzNotSupportedError();
+        }
+        const data = parseCameraPtzResponse(text);
         const res = {};
-        Object.keys(data).forEach((camera) => {
-            res[Number(camera) - 1] = data[Number(camera)].map(({ data: itemData, ...d }) => d);
+        Object.keys(data)
+            .map(Number)
+            .forEach((camera) => {
+            if (data[camera] !== undefined) {
+                res[camera - 1] = data[camera]?.map(({ data: itemData, ...d }) => d);
+            }
         });
         return res;
     }
@@ -323,26 +353,29 @@ export class VapixAPI {
     }
     async getInputState(port, proxy = null) {
         const response = await (await this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { checkactive: port.toString() })).text();
-        return response.split('=')[1].indexOf('active') === 0;
+        return response.split('=')[1]?.indexOf('active') === 0;
     }
     async setOutputState(port, active, proxy = null) {
         return this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { action: active ? `${port}:/` : `${port}:\\` });
     }
     async getApplicationList(proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/list.cgi');
+        const res = await this.client.get(proxy, '/axis-cgi/applications/list.cgi');
         const xml = await res.text();
-        const result = (await parseStringPromise(xml));
-        const apps = [];
-        for (let i = 0; i < result.reply.application.length; i++) {
-            apps.push({
-                ...result.reply.application[i].$,
-                appId: APP_IDS.find((id) => id.toLowerCase() === result.reply.application[i].$.Name.toLowerCase()) ?? null,
-            });
-        }
-        return apps;
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(xml);
+        return result.reply.application.map((app) => {
+            return {
+                ...app,
+                appId: APP_IDS.find((id) => id.toLowerCase() === app.Name.toLowerCase()) ?? null,
+            };
+        });
     }
     async startApplication(applicationID, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
             package: applicationID.toLowerCase(),
             action: 'start',
         });
@@ -352,7 +385,7 @@ export class VapixAPI {
         }
     }
     async restartApplication(applicationID, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
             package: applicationID.toLowerCase(),
             action: 'restart',
         });
@@ -362,7 +395,7 @@ export class VapixAPI {
         }
     }
     async stopApplication(applicationID, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
             package: applicationID.toLowerCase(),
             action: 'stop',
         });
@@ -389,14 +422,14 @@ export class VapixAPI {
 const parseParameters = (response) => {
     const params = {};
     const lines = response.split(/[\r\n]/);
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].length === 0 || lines[i].substring(0, 7) === '# Error') {
+    for (const line of lines) {
+        if (line.length === 0 || line.substring(0, 7) === '# Error') {
             continue;
         }
-        const delimiterPos = lines[i].indexOf('=');
+        const delimiterPos = line.indexOf('=');
         if (delimiterPos !== -1) {
-            const paramName = lines[i].substring(0, delimiterPos);
-            const paramValue = lines[i].substring(delimiterPos + 1);
+            const paramName = line.substring(0, delimiterPos).replace('root.', '');
+            const paramValue = line.substring(delimiterPos + 1);
             params[paramName] = paramValue;
         }
     }
@@ -442,7 +475,7 @@ const parsePtz = (parsed) => {
         };
         res.push({
             id,
-            name: data[0],
+            name: data[0] ?? 'Preset ' + id,
             data: {
                 pan: getValue('pan'),
                 tilt: getValue('tilt'),

package/esm/VapixEvents.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { WsOptions } from './internal/types';
+export type VapixEventsOptions = WsOptions;
+type TEventMessage = {
+    apiVersion: string;
+    method: string;
+    params: {
+        notification: {
+            timestamp: number;
+            topic: string;
+            message: {
+                source: Record<string, string>;
+                data: Record<string, string>;
+                key: Record<string, string>;
+            };
+        };
+    };
+};
+export interface VapixEvents {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: string, listener: (data: TEventMessage) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: string, msg: TEventMessage): boolean;
+}
+export declare class VapixEvents extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private ws;
+    constructor(options?: VapixEventsOptions);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}
+export {};

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

@@ -39,10 +39,10 @@ export class VapixEvents extends EventEmitter {
         this.ws.on('open', () => {
             const topics = [];
             const eventNames = this.eventNames();
-            for (let i = 0; i < eventNames.length; i++) {
-                if (!this.isReservedEventName(eventNames[i])) {
+            for (const eventName of eventNames) {
+                if (!this.isReservedEventName(eventName)) {
                     const topic = {
-                        topicFilter: eventNames[i],
+                        topicFilter: eventName,
                     };
                     topics.push(topic);
                 }

package/esm/errors/errors.d.ts

@@ -0,0 +1,37 @@
+export declare class ServiceUnavailableError extends Error {
+    constructor();
+}
+export declare class ServiceNotFoundError extends Error {
+    constructor();
+}
+export declare class ParsingBlobError extends Error {
+    constructor(err: unknown);
+}
+type TApplicationAPIAction = 'START' | 'RESTART' | 'STOP';
+export declare class ApplicationAPIError extends Error {
+    constructor(action: TApplicationAPIAction, res: string);
+}
+type TSDCardAction = 'MOUNT' | 'UNMOUNT';
+export declare class SDCardActionError extends Error {
+    constructor(action: TSDCardAction, res: string);
+}
+export declare class SDCardJobError extends Error {
+    constructor();
+}
+type TMaxFPSErrorType = 'MALFORMED_REPLY' | 'CHANNEL_NOT_FOUND' | 'CAPTURE_MODE_NOT_FOUND' | 'FPS_NOT_SPECIFIED';
+export declare class MaxFPSError extends Error {
+    constructor(state: TMaxFPSErrorType);
+}
+export declare class NoDeviceInfoError extends Error {
+    constructor();
+}
+export declare class FetchDeviceInfoError extends Error {
+    constructor(err: unknown);
+}
+export declare class AddNewClipError extends Error {
+    constructor(message: string);
+}
+export declare class PtzNotSupportedError extends Error {
+    constructor();
+}
+export {};

package/{errors → esm/errors}/errors.js

@@ -64,3 +64,9 @@ export class AddNewClipError extends Error {
         this.name = 'AddNewClipError';
     }
 }
+export class PtzNotSupportedError extends Error {
+    constructor() {
+        super('Ptz not supported.');
+        this.name = 'PtzNotSupportedError';
+    }
+}

package/esm/events/AxisCameraStationEvents.d.ts

@@ -0,0 +1,10 @@
+import { IClient, HttpOptions } from '../internal/types';
+import { Response } from 'undici';
+export type AcsEventsOptions = HttpOptions;
+export declare class AxisCameraStationEvents {
+    private sourceKey;
+    private client;
+    constructor(sourceKey: string, opt?: AcsEventsOptions | IClient<Response>);
+    sendEvent(data: Record<string, string>, eventType: string): Promise<void>;
+    private getDate;
+}

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

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