camstreamerlib 4.0.0-beta.3 → 4.0.0-beta.31

package/esm/VapixAPI.js

@@ -1,55 +1,65 @@
 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, getPortsResponseSchema, } 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);
+    constructor(client) {
+        this.client = client;
     }
-    async getUrlEncoded(proxy = null, path, parameters, headers = {}) {
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async postUrlEncoded(path, parameters, headers, options) {
         const data = paramToUrl(parameters);
         const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
-        const res = await this.client.post(proxy, path, data, {}, head);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
         return res;
     }
-    async postJson(proxy = null, path, jsonData, headers = {}) {
+    async postJson(path, jsonData, headers, options) {
         const data = JSON.stringify(jsonData);
         const head = { ...headers, 'Content-Type': 'application/json' };
-        const res = await this.client.post(proxy, path, data, {}, head);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
         return res;
     }
-    async getCameraImage(params, proxy = null) {
-        return await this.client.get(proxy, '/axis-cgi/jpg/image.cgi', params);
+    async getCameraImage(parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({ path: '/axis-cgi/jpg/image.cgi', parameters, timeout: options?.timeout });
     }
-    async getEventDeclarations(proxy = null) {
+    async getEventDeclarations(options) {
         const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
             '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
             'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
             '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
             '</s:Body>' +
             '</s:Envelope>';
-        const res = await this.client.post(proxy, '/vapix/services', data, { 'Content-Type': 'application/soap+xml' });
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/vapix/services',
+            data,
+            headers: { 'Content-Type': 'application/soap+xml' },
+        });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
         const declarations = await res.text();
         return prettifyXml(declarations);
     }
-    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);
+    async getSupportedAudioSampleRate(options) {
+        const path = '/axis-cgi/audio/streamingcapabilities.cgi';
+        const jsonData = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(path, jsonData, undefined, options);
         const encoders = audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
         const data = encoders.aac ?? encoders.AAC ?? [];
         return data.map((item) => {
@@ -59,7 +69,7 @@ export class VapixAPI {
             };
         });
     }
-    async performAutofocus(proxy = null) {
+    async performAutofocus(options) {
         try {
             const data = {
                 apiVersion: '1',
@@ -72,24 +82,26 @@ export class VapixAPI {
                     ],
                 },
             };
-            await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
+            await this.postJson('/axis-cgi/opticscontrol.cgi', data, undefined, options);
         }
         catch (err) {
-            await this.postJson(proxy, '/axis-cgi/opticssetup.cgi', {
+            await this.postUrlEncoded('/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',
-            });
+            }, undefined, options);
         }
     }
-    async checkSDCard(proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/list.cgi', {
+    async checkSDCard(options) {
+        const res = await this.postUrlEncoded('/axis-cgi/disks/list.cgi', {
             diskid: 'SD_DISK',
+        }, undefined, options);
+        const xmlText = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
         });
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
-        });
+        const result = parser.parse(xmlText);
         const data = result.root.disks.disk;
         return {
             totalSize: parseInt(data.totalsize),
@@ -97,53 +109,56 @@ export class VapixAPI {
             status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
         };
     }
-    mountSDCard(proxy = null) {
-        return this._doSDCardMountAction('MOUNT', proxy);
+    mountSDCard(options) {
+        return this._doSDCardMountAction('MOUNT', options);
     }
-    unmountSDCard(proxy = null) {
-        return this._doSDCardMountAction('UNMOUNT', proxy);
+    unmountSDCard(options) {
+        return this._doSDCardMountAction('UNMOUNT', options);
     }
-    async _doSDCardMountAction(action, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/mount.cgi', {
+    async _doSDCardMountAction(action, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/disks/mount.cgi', {
             action: action,
             diskid: 'SD_DISK',
+        }, undefined, options);
+        const textXml = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
         });
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
-        });
+        const result = parser.parse(textXml);
         const job = result.root.job;
         if (job.result !== 'OK') {
             throw new SDCardActionError(action, await responseStringify(res));
         }
         return Number(job.jobid);
     }
-    async fetchSDCardJobProgress(jobId, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/disks/job.cgi', {
+    async fetchSDCardJobProgress(jobId, options) {
+        const res = await this.postUrlEncoded('/disks/job.cgi', {
             jobid: String(jobId),
             diskid: 'SD_DISK',
+        }, undefined, options);
+        const textXml = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
         });
-        const result = await parseStringPromise(await res.text(), {
-            ignoreAttrs: false,
-            mergeAttrs: true,
-            explicitArray: false,
-        });
-        const job = result.root.job;
+        const job = parser.parse(textXml).root.job;
         if (job.result !== 'OK') {
             throw new SDCardJobError();
         }
         return Number(job.progress);
     }
-    downloadCameraReport(proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/serverreport.cgi', { mode: 'text' });
+    downloadCameraReport(options) {
+        return this.postUrlEncoded('/axis-cgi/serverreport.cgi', { mode: 'text' }, undefined, options);
     }
-    getSystemLog(proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/admin/systemlog.cgi');
+    getSystemLog(options) {
+        return this.postUrlEncoded('/axis-cgi/admin/systemlog.cgi', undefined, undefined, options);
     }
-    async getMaxFps(channel, proxy = null) {
+    async getMaxFps(channel, options) {
         const data = { apiVersion: '1.0', method: 'getCaptureModes' };
-        const res = await this.postJson(proxy, '/axis-cgi/capturemode.cgi', data);
+        const res = await this.postJson('/axis-cgi/capturemode.cgi', data, undefined, options);
         const response = maxFpsResponseSchema.parse(await res.json());
         const channels = response.data;
         if (channels === undefined) {
@@ -163,77 +178,92 @@ 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';
+    async getTimezone(options) {
+        try {
+            const agent = this.getClient(options?.proxyParams);
+            const resV2 = await agent.get({ path: '/config/rest/time/v2/timeZone', timeout: options?.timeout });
+            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(options);
+        if (data.data.timeZone === undefined) {
+            throw new Error('Time zone not setup on the device');
+        }
+        return data.data.timeZone;
     }
-    async getDateTimeInfo(proxy = null) {
+    async getDateTimeInfo(options) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
-        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
+        const res = await this.postJson('/axis-cgi/time.cgi', data, undefined, options);
         return dateTimeinfoSchema.parse(await res.json());
     }
-    async getDevicesSettings(proxy = null) {
+    async getDevicesSettings(options) {
         const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
-        const res = await this.postJson(proxy, '/axis-cgi/audiodevicecontrol.cgi', data);
+        const res = await this.postJson('/axis-cgi/audiodevicecontrol.cgi', data, undefined, options);
         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)),
         }));
     }
-    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)) {
+    async fetchRemoteDeviceInfo(payload, options) {
+        const res = await this.postJson('/axis-cgi/basicdeviceinfo.cgi', payload, undefined, options);
+        const json = await res.json();
+        if (isNullish(json.data)) {
             throw new NoDeviceInfoError();
         }
-        return result.data;
+        return json.data;
     }
-    async getHeaders(proxy = null) {
+    async getHeaders(options) {
         const data = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        const res = await this.postJson('/axis-cgi/customhttpheader.cgi', data, undefined, options);
         return z.object({ data: z.record(z.string()) }).parse(await res.json()).data;
     }
-    async setHeaders(headers, proxy = null) {
+    async setHeaders(headers, options) {
         const data = { apiVersion: '1.0', method: 'set', params: headers };
-        return this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        return this.postJson('/axis-cgi/customhttpheader.cgi', data, undefined, options);
     }
-    async getParameter(paramNames, proxy = null) {
-        const response = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+    async getParameter(paramNames, options) {
+        const response = await this.postUrlEncoded('/axis-cgi/param.cgi', {
             action: 'list',
             group: arrayToUrl(paramNames),
-        });
-        return parseParameters(await response.text());
+        }, undefined, options);
+        return VapixAPI.parseParameters(await response.text());
     }
-    async setParameter(params, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+    async setParameter(params, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/param.cgi', {
             ...params,
             action: 'update',
-        });
+        }, undefined, options);
         const responseText = await res.text();
         if (responseText.startsWith('# Error')) {
             throw new Error(responseText);
         }
         return true;
     }
-    async getGuardTourList(proxy = null) {
+    async getGuardTourList(options) {
         const gTourList = new Array();
-        const response = await this.getParameter('GuardTour', proxy);
+        const response = await this.getParameter('GuardTour', options);
         for (let i = 0; i < 20; i++) {
             const gTourBaseName = 'root.GuardTour.G' + i;
             if (gTourBaseName + '.CamNbr' in response) {
                 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: [],
                 };
@@ -258,16 +288,16 @@ export class VapixAPI {
         }
         return gTourList;
     }
-    setGuardTourEnabled(guardTourID, enable, proxy = null) {
-        const options = {};
-        options[guardTourID + '.Running'] = enable ? 'yes' : 'no';
-        return this.setParameter(options, proxy);
+    setGuardTourEnabled(guardTourID, enable, options) {
+        const params = {};
+        params[guardTourID + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(params, options);
     }
-    async getPTZPresetList(channel, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async getPTZPresetList(channel, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposcam',
             camera: channel.toString(),
-        });
+        }, undefined, options);
         const text = await res.text();
         const lines = text.split(/[\r\n]/);
         const positions = [];
@@ -282,100 +312,159 @@ export class VapixAPI {
         }
         return positions;
     }
-    async listPTZ(camera, proxy = null) {
+    async listPTZ(camera, options) {
         const url = `/axis-cgi/com/ptz.cgi`;
-        const response = await this.getUrlEncoded(proxy, url, {
+        const response = await this.postUrlEncoded(url, {
             camera,
             query: 'presetposcamdata',
             format: 'json',
-        });
-        return parseCameraPtzResponse(await response.text())[camera] ?? [];
+        }, undefined, options);
+        const text = await response.text();
+        if (text === '') {
+            throw new PtzNotSupportedError();
+        }
+        return VapixAPI.parseCameraPtzResponse(text)[camera] ?? [];
     }
-    async listPtzVideoSourceOverview(proxy = null) {
-        const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async listPtzVideoSourceOverview(options) {
+        const response = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposall',
             format: 'json',
-        });
-        const data = parseCameraPtzResponse(await response.text());
+        }, undefined, options);
+        const text = await response.text();
+        if (text === '') {
+            throw new PtzNotSupportedError();
+        }
+        const data = VapixAPI.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;
     }
-    goToPreset(channel, presetName, proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    goToPreset(channel, presetName, options) {
+        return this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             camera: channel.toString(),
             gotoserverpresetname: presetName,
-        });
+        }, undefined, options);
     }
-    async getPtzPosition(camera, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async getPtzPosition(camera, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'position',
             camera: camera.toString(),
-        });
-        const params = parseParameters(await res.text());
+        }, undefined, options);
+        const params = VapixAPI.parseParameters(await res.text());
         return {
             pan: Number(params.pan),
             tilt: Number(params.tilt),
             zoom: Number(params.zoom),
         };
     }
-    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;
-    }
-    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');
+    async getPorts(options) {
+        const res = await this.postJson('/axis-cgi/io/portmanagement.cgi', {
+            apiVersion: '1.0',
+            context: '',
+            method: 'getPorts',
+        }, undefined, options);
+        const portResponseParsed = await getPortsResponseSchema.parse(res.json());
+        return portResponseParsed.data.items;
+    }
+    async setPorts(ports, options) {
+        await this.postJson('/axis-cgi/io/portmanagement.cgi', {
+            apiVersion: '1.0',
+            context: '',
+            method: 'setPorts',
+            params: { ports },
+        }, undefined, options);
+    }
+    async setPortStateSequence(port, sequence, options) {
+        await this.postJson('/axis-cgi/io/portmanagement.cgi', {
+            apiVersion: '1.0',
+            context: '',
+            method: 'setStateSequence',
+            params: { port, sequence },
+        }, undefined, options);
+    }
+    async getApplicationList(options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path: '/axis-cgi/applications/list.cgi', timeout: options?.timeout });
         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,
-            });
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(xml);
+        let apps = result.reply.application ?? [];
+        if (!Array.isArray(apps)) {
+            apps = [apps];
         }
-        return apps;
+        return apps.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', {
-            package: applicationID.toLowerCase(),
-            action: 'start',
+    async startApplication(applicationID, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationID.toLowerCase(),
+                action: 'start',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
             throw new ApplicationAPIError('START', await responseStringify(res));
         }
     }
-    async restartApplication(applicationID, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'restart',
+    async restartApplication(applicationID, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationID.toLowerCase(),
+                action: 'restart',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok') {
             throw new ApplicationAPIError('RESTART', await responseStringify(res));
         }
     }
-    async stopApplication(applicationID, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'stop',
+    async stopApplication(applicationID, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationID.toLowerCase(),
+                action: 'stop',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
             throw new ApplicationAPIError('STOP', await responseStringify(res));
         }
     }
-    async installApplication(data, fileName) {
+    async installApplication(data, fileName, options) {
         const formData = new FormData();
         formData.append('packfil', data, fileName);
-        const res = await this.client.post(null, '/axis-cgi/applications/upload.cgi', formData, {}, {
-            contentType: 'application/octet-stream',
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/axis-cgi/applications/upload.cgi',
+            data: formData,
+            headers: {
+                contentType: 'application/octet-stream',
+            },
+            timeout: options?.timeout ?? 120000,
         });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
@@ -385,70 +474,70 @@ export class VapixAPI {
             throw new Error('installing error: ' + text);
         }
     }
-}
-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') {
-            continue;
-        }
-        const delimiterPos = lines[i].indexOf('=');
-        if (delimiterPos !== -1) {
-            const paramName = lines[i].substring(0, delimiterPos);
-            const paramValue = lines[i].substring(delimiterPos + 1);
-            params[paramName] = paramValue;
-        }
-    }
-    return params;
-};
-const parseCameraPtzResponse = (response) => {
-    const json = JSON.parse(response);
-    const parsed = {};
-    Object.keys(json).forEach((key) => {
-        if (!key.startsWith('Camera ')) {
-            return;
-        }
-        const camera = Number(key.replace('Camera ', ''));
-        if (json[key].presets !== undefined) {
-            parsed[camera] = parsePtz(json[key].presets);
-        }
-    });
-    return parsed;
-};
-const parsePtz = (parsed) => {
-    const res = [];
-    parsed.forEach((value) => {
-        const delimiterPos = value.indexOf('=');
-        if (delimiterPos === -1) {
-            return;
-        }
-        if (!value.startsWith('presetposno')) {
-            return;
-        }
-        const id = Number(value.substring(11, delimiterPos));
-        if (Number.isNaN(id)) {
-            return;
+    static parseParameters = (response) => {
+        const params = {};
+        const lines = response.split(/[\r\n]/);
+        for (const line of lines) {
+            if (line.length === 0 || line.substring(0, 7) === '# Error') {
+                continue;
+            }
+            const delimiterPos = line.indexOf('=');
+            if (delimiterPos !== -1) {
+                const paramName = line.substring(0, delimiterPos).replace('root.', '');
+                const paramValue = line.substring(delimiterPos + 1);
+                params[paramName] = paramValue;
+            }
         }
-        const data = value.substring(delimiterPos + 1).split(':');
-        const getValue = (valueName) => {
-            for (const d of data) {
-                const p = d.split('=');
-                if (p[0] === valueName) {
-                    return Number(p[1]);
-                }
+        return params;
+    };
+    static parseCameraPtzResponse = (response) => {
+        const json = JSON.parse(response);
+        const parsed = {};
+        Object.keys(json).forEach((key) => {
+            if (!key.startsWith('Camera ')) {
+                return;
+            }
+            const camera = Number(key.replace('Camera ', ''));
+            if (json[key].presets !== undefined) {
+                parsed[camera] = VapixAPI.parsePtz(json[key].presets);
             }
-            return 0;
-        };
-        res.push({
-            id,
-            name: data[0],
-            data: {
-                pan: getValue('pan'),
-                tilt: getValue('tilt'),
-                zoom: getValue('zoom'),
-            },
         });
-    });
-    return res;
-};
+        return parsed;
+    };
+    static parsePtz = (parsed) => {
+        const res = [];
+        parsed.forEach((value) => {
+            const delimiterPos = value.indexOf('=');
+            if (delimiterPos === -1) {
+                return;
+            }
+            if (!value.startsWith('presetposno')) {
+                return;
+            }
+            const id = Number(value.substring(11, delimiterPos));
+            if (Number.isNaN(id)) {
+                return;
+            }
+            const data = value.substring(delimiterPos + 1).split(':');
+            const getValue = (valueName) => {
+                for (const d of data) {
+                    const p = d.split('=');
+                    if (p[0] === valueName) {
+                        return Number(p[1]);
+                    }
+                }
+                return 0;
+            };
+            res.push({
+                id,
+                name: data[0] ?? 'Preset ' + id,
+                data: {
+                    pan: getValue('pan'),
+                    tilt: getValue('tilt'),
+                    zoom: getValue('zoom'),
+                },
+            });
+        });
+        return res;
+    };
+}