camstreamerlib 4.0.0-beta.6 → 4.0.0-beta.60

package/README.md

@@ -15,31 +15,158 @@ Examples of CamScripter packages can be found at https://github.com/CamStreamer/
 npm install camstreamerlib
 ```
 
-# Documentation for Node.js modules
+## Documentation for ACAP and Camera API
+
+| API                                                | Description                                                                                                            |
+| -------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| [VapixAPI](doc/VapixAPI.md)                        | Module to access Axis camera VAPIX interface.                                                                          |
+| [CamStreamerAPI](doc/CamStreamerAPI.md)            | Module for easy control of video streaming in the CamStreamer ACAP application (RTMP, HLS, SRT and MPEG-TS protocols). |
+| [CamOverlayAPI](doc/CamOverlayAPI.md)              | Module to access CamOverlay API.                                                                                       |
+| [CamScripterAPI](doc/CamScripterAPI.md)            | Module to access CamScripter API.                                                                                      |
+| [CamSwitcherAPI](doc/CamSwitcherAPI.md)            | Module to access CamSwitcher API.                                                                                      |
+| [PlaneTrackerAPI](doc/PlaneTrackerAPI.md)          | Module to access PlaneTracker API.                                                                                     |
+| [CamStreamerEvents](doc/ws/CamStreamerEvents.md)   | Module which allows receiving events from CamStreamer ACAP application.                                                |
+| [OverlayEvents](doc/ws/OverlayEvents.md)           | Module which allows receiving events from Overlay ACAP application.                                                    |
+| [CamSwitcherEvents](doc/ws/CamSwitcherEvents.md)   | Module which allows receiving events from CamSwitcher ACAP application.                                                |
+| [PlaneTrackerEvents](doc/ws/PlaneTrackerEvents.md) | Module which allows receiving events from PlaneTracker ACAP application.                                               |
+
+## Documentation for Node.js modules
+
+| Module                                                                            | Description                                                                                                                                                                                                                                                       |
+| --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [HttpServer](doc/HttpServer.md)                                                   | Module for processing HTTP requests in your scripts. It also automatically serves up the content from html directory or you can register paths which you can process by your own (e.g. `http://$CAMERA_IP/local/camscripter/proxy/$MY_PACKAGE_NAME/control.cgi`). |
+| [VapixEvents](doc/ws/VapixEvents.md)                                              | Module which allows receiving camera events from the VAPIX API.                                                                                                                                                                                                   |
+| [CamOverlayDrawingAPI](doc/CamOverlayDrawingAPI.md)                               | Module for easy control of CamOverlay drawing API. For more details on supported video overlay drawing functions see https://camstreamer.com/camoverlay-api1                                                                                                      |
+| [CamOverlayPainter](doc/CamOverlayPainter.md)                                     | Contains three modules which makes easier to use CamOverlayDrawingAPI.                                                                                                                                                                                            |
+| [CamScripterAPICameraEventsGenerator](doc/CamScripterAPICameraEventsGenerator.md) | Module which allows generating events on an Axis camera. These events can be used for triggers in the Axis camera rule engine (events/actions). It is also an easy way how to integrate events and metadata in VMS systems which support Axis camera events.      |
+| [GenetecAgent](doc/GenetecAgent.md)                                               | Module which allows receiving and sending data to Genetec VMS.                                                                                                                                                                                                    |
+
+</br>
+
+# Breaking Changes
+
+<details open>
+
+<summary>from version 3.\*.\* to 4.\*.\* (latest)</summary>
+
+### Breaking changes when moving from version 3.\*.\* to 4.\*.\* (latest)
+
+<hr/>
+
+### ACAP API Class Constructors Updated
+
+All ACAP API classes now **require a client instance to be passed into their constructors** instead of options object.
+
+-   This change improves flexibility by allowing you to use either the Node or Web client, depending on your environment.
+
+Example (before → now):
+
+```typescript
+// Before
+const coApi = new CamOverlayAPI({
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+    keepAlive?: boolean
+});
+
+// Now
+import { DefaultClient } from 'camstreamerlib/web';
+import { CamOverlayAPI } from 'camstreamerlib';
+
+const coApi = new CamOverlayAPI(
+    new DefaultClient({
+        tls: false,
+        tlsInsecure: false,
+        ip: '127.0.0.1',
+        port: 80,
+        user: '',
+        pass: '',
+    })
+);
+```
+
+### Imports Simplified
+
+Importing from the camstreamerlib is now much easier -> all exports are now re-exported from the root index.js.
+You no longer need to import from subpaths.
+
+Example:
+
+```typescript
+// Before
+import { CamScripterAPI } from 'camstreamerlib/CamScripterAPI';
+import { Painter } from 'camstreamerlib/CamOverlayPainter/Painter';
+import { DefaultAgent } from 'camstreamerlib/DefaultAgent';
+
+// Now
+import { CamScripterAPI } from 'camstreamerlib';
+import { Painter } from 'camstreamerlib/node';
+import { DefaultClient } from 'camstreamerlib/web';
+```
+
+> Note: To ensure compatibility, set the module resolution in your projects tsconfig.json to `"moduleResolution": "bundler"`.
+
+### Class and Method Refactored
+
+-   **CameraVapix API** has been renamed to [**VapixAPI**](doc/VapixAPI.md).
+-   **DefaultAgent** has been refactored into two separate classes - one for node, one for web as [**DefaultClient**](doc/Client.md)
+-   Several method names and parameter names across the library have been updated for consistency and clarity.
+
+> Please refer to [the documentation](#documentation-for-acap-and-camera-api).
+
+-   New API modules and endpoints have been introduced, providing extended functionality and better coverage of the underlying service.
 
--   [HttpServer](doc/HttpServer.md) is a module for processing HTTP requests in your scripts. It also automatically serves up the content from html directory or you can register paths which you can process by your own (e.g. http://$CAMERA_IP/local/camscripter/proxy/$MY_PACKAGE_NAME/control.cgi).
+<hr/>
+</details>
 
--   [VapixAPI](doc/VapixAPI.md) is a module to access Axis camera VAPIX interface.
+<details>
 
--   [CamStreamerAPI](doc/CamStreamerAPI.md) is a module for easy control of video streaming in the CamStreamer ACAP application (RTMP, HLS, SRT and MPEG-TS protocols).
+<summary>from version 2.\*.\* to 3.\*.\*</summary>
 
--   [CamOverlayAPI](doc/CamOverlayAPI.md) is a module to access CamOverlay HTTP interface.
+### Breaking changes when moving from version 2.\*.\* to 3.\*.\*
+
+-   CamStreamerlib requiers Node.js version 18 or higher.
+-   CamOverlayDrawingAPI tries to reconnect when the websocket is closed. You don't have to do it manually.
+
+    > However, events `open` and `close` are still emitted in case you need to react to them.
 
--   [CamOverlayDrawingAPI](doc/CamOverlayDrawingAPI.md) is a module for easy control of CamOverlay drawing API. For more details on supported video overlay drawing functions see https://camstreamer.com/camoverlay-api1
+-   Files `common.ts`, `Digest.ts`, `HttpRequest.ts` and `WsClient.ts` moved to a folder internal.
+-   Removed function `httpRequest()`. Use `sendRequest()` instead. It uses the same interface except for the "noWaitForData" parameter.
 
--   [CamOverlayPainter/](doc/CamOverlayPainter.md) contains three modules which makes easier to use CamOverlayDrawingAPI.
+> It returns (Response object)[https://developer.mozilla.org/en-US/docs/Web/API/Response] which doesn't contain data by default.
+> If you need to wait for data, you can call for example the function `await res.text()`.
+> This change affects the function `vapixGet` from (CameraVapix)[doc/CameraVapix.md] too.
 
--   [CamScripterAPICameraEventsGenerator](doc/CamScripterAPICameraEventsGenerator.md) is a module which allows generating events on an Axis camera. These events can be used for triggers in the Axis camera rule engine (events/actions). It is also an easy way how to integrate events and metadata in VMS systems which support Axis camera events.
+<hr/>
+</details>
+
+<details>
+
+<summary>from version 1.\*.\* to 2.\*.\**</summary>
+
+### Breaking changes when moving from version 1.\*.\* to 2.\*.\*
+
+-   Renamed file HTTPRequest.ts to HttpRequest.ts
+-   Removed deprecated protocol attribute from all options objects (use tls instead).
+-   Removed RTSP
 
--   [CamSwitcherAPI](doc/CamSwitcherAPI.md) is a module to access CamSwitcher API.
+    > Previously CameraVapix.ts supported both WebSocket and RTSP.
+    > Starting with version 2.0.0, it supports WebSocket only.
 
--   [CamSwitcherEvents](doc/CamSwitcherEvents.md) is a module which allows receiving events from CamSwitcher ACAP application.
+-   ServiceID shouldn't be passed to CamOverlayAPI by the options object. Pass it as a parameter.
+-   Renamed CamOverlayDrawingAPI event msg to message.
+-   Drawing services extracted from CamOverlayAPI.ts to a separate file.
 
--   [VapixEvents](doc/VapixEvents.md) is a module which allows receiving camera events from the VAPIX API.
+> Please read [CamOverlayAPI](doc/CamOverlayAPI.md) and [CamOverlayDrawingAPI](doc/CamOverlayDrawingAPI.md) for more information.
 
--   [GenetecAgent](doc/GenetecAgent.md) is a module which allows receiving and sending data to Genetec VMS.
+</details>
+</br>
 
-## For Developers
+# For Developers
 
 ### Publishing to npm repository
 
@@ -61,7 +188,7 @@ If you want to create your own package and upload it to CamScripter App, you can
 
 ```json
 "scripts": {
-    "create-package": "node node_modules/camstreamerlib/CreatePackage.js"
+    "create-package": "node node_modules/camstreamerlib/bin/CreatePackage.js"
   }
 ```
 
@@ -73,29 +200,6 @@ The zip package is created in the current directory. You can choose different lo
 
 ```json
 "scripts": {
-    "create-package": "node node_modules/camstreamerlib/CreatePackage.js -i -e=react"
+    "create-package": "node node_modules/camstreamerlib/bin/CreatePackage.js -i -e=react"
 }
 ```
-
-### Breaking changes when moving from version 1.\*.\* to 2.\*.\*
-
--   Renamed file HTTPRequest.ts to HttpRequest.ts
--   Removed deprecated protocol attribute from all options objects (use tls instead).
--   Removed RTSP
-    > Previously CameraVapix.ts supported both WebSocket and RTSP.
-    > Starting with version 2.0.0, it supports WebSocket only.
--   ServiceID shouldn't be passed to CamOverlayAPI by the options object. Pass it as a parameter.
--   Renamed CamOverlayDrawingAPI event msg to message.
--   Drawing services extracted from CamOverlayAPI.ts to a separate file.
-    > Please read [CamOverlayAPI](doc/CamOverlayAPI.md) and [CamOverlayDrawingAPI](doc/CamOverlayDrawingAPI.md) for more information.
-
-### Breaking changes when moving from version 2.\*.\* to 3.\*.\*
-
--   CamStreamerlib requiers Node.js version 18 or higher.
--   CamOverlayDrawingAPI tries to reconnect when the websocket is closed. You don't have to do it manually.
-    > However, events `open` and `close` are still emitted in case you need to react to them.
--   Files common.ts, Digest.ts, HttpRequest.ts and WsClient.ts moved to a folder internal.
--   Removed function httpRequest(). Use sendRequest() instead. It uses the same interface except for the "noWaitForData" parameter.
-    > It returns (Response object)[https://developer.mozilla.org/en-US/docs/Web/API/Response] which doesn't contain data by default.
-    > If you need to wait for data, you can call for example the function `await res.text()`.
-    > This change affects the function `vapixGet` from (CameraVapix)[doc/CameraVapix.md] too.

package/cjs/CamOverlayAPI.js

@@ -1,100 +1,115 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamOverlayAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
-const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+const utils_1 = require("./internal/utils");
 const errors_1 = require("./errors/errors");
-const common_2 = require("./types/common");
+const common_1 = require("./types/common");
+const zod_1 = require("zod");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+const BASE_PATH = '/local/camoverlay/api';
 class CamOverlayAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
+    constructor(client) {
+        this.client = client;
+    }
+    static getBasePath = () => BASE_PATH;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${BASE_PATH}/image.cgi?path=${encodeURIComponent(path)}`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return zod_1.z.boolean().parse(res.state);
+    }
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(res.camera_list);
+    }
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return CamOverlayAPI_1.wsResponseSchema.parse(res).message;
+    }
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob(`${BASE_PATH}/fetch_mjpeg_image.cgi`, { mjpeg_url: decodeURIComponent(mjpegUrl) }, options);
+    }
+    async listFiles(fileType, options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'list' }, options);
+        return CamOverlayAPI_1.fileListSchema.parse(res.list);
+    }
+    async uploadFile(fileType, formData, storage, options) {
+        await this._post(`${BASE_PATH}/upload_${fileType}.cgi`, formData, {
+            action: 'upload',
+            storage: storage,
+        }, options);
+    }
+    async removeFile(fileType, fileParams, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/upload_${fileType}.cgi`, {
+            action: 'remove',
+            ...fileParams,
+        }, options, undefined);
+    }
+    async getFileStorage(fileType, options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
+        if (res.code !== 200) {
+            throw new errors_1.StorageDataFetchError(res);
         }
+        return CamOverlayAPI_1.storageDataListSchema.parse(res.list);
     }
-    async checkCameraTime() {
-        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
-        return cameraTime.state;
-    }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
-        return common_2.networkCameraListSchema.parse(response.camera_list);
-    }
-    async wsAutoratization() {
-        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
-        return response.data;
+    async getFilePreviewFromCamera(path, options) {
+        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path), undefined, options);
     }
-    async getMjpegStreamImage(mjpegUrl) {
-        const res = await this.get(`/local/camoverlay/api/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
-        return await this.parseBlobResponse(res);
+    async updateInfoticker(serviceId, text, options) {
+        await this._getJson(`${BASE_PATH}/infoticker.cgi`, { service_id: serviceId, text: text }, options);
     }
-    async listFiles(fileType) {
-        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
-        return CamOverlayAPI_1.fileListSchema.parse(files.list);
+    async setEnabled(serviceId, enabled, options) {
+        await this._post(`${BASE_PATH}/enabled.cgi`, '', { [`id_${serviceId}`]: enabled ? 1 : 0 }, options);
     }
-    async uploadFile(fileType, file, fileName) {
-        const formData = new FormData();
-        formData.append('target', 'SD0');
-        formData.append('uploadedFile[]', file, fileName);
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=upload`;
-        await this.post(path, formData);
-    }
-    async removeFile(fileType, file) {
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
-        await this.post(path, JSON.stringify(file));
-    }
-    async getFileStorage(fileType) {
-        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
-        return CamOverlayAPI_1.storageSchema.parse(data);
-    }
-    async updateInfoticker(serviceID, text) {
-        await this.get(`/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`);
-    }
-    async setEnabled(serviceID, enabled) {
-        await this.post(`/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
-    }
-    async isEnabled(serviceID) {
-        const res = await this.client.get('/local/camoverlay/api/services.cgi?action=get');
+    async isEnabled(serviceId, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: { action: 'get' },
+            timeout: options?.timeout,
+        });
         if (res.ok) {
             const data = JSON.parse(await res.text());
             for (const service of data.services) {
-                if (service.id === serviceID) {
+                if (service.id === serviceId) {
                     return service.enabled === 1;
                 }
             }
             throw new errors_1.ServiceNotFoundError();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async getSingleService(serviceId) {
-        const data = await this.get('/local/camoverlay/api/services.cgi', {
+    async getSingleService(serviceId, options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, {
             action: 'get',
-            service_id: serviceId.toString(),
-        });
-        return CamOverlayAPI_1.serviceSchema.parse(data);
+            service_id: serviceId,
+        }, options);
+        return CamOverlayAPI_1.servicesSchema.parse(res);
     }
-    async getServices() {
-        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
-        return CamOverlayAPI_1.serviceSchema.parse(serviceList).services;
+    async getServices(options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, { action: 'get' }, options);
+        const services = CamOverlayAPI_1.serviceListSchema.parse(res).services;
+        return services;
     }
-    async updateSingleService(serviceId, serviceJson) {
-        const path = '/local/camoverlay/api/services.cgi';
-        await this.post(path, JSON.stringify(serviceJson), {
+    async updateSingleService(service, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify(service), {
             action: 'set',
-            service_id: serviceId.toString(),
-        });
+            service_id: service.id,
+        }, options, undefined);
     }
-    async updateServices(servicesJson) {
-        const path = '/local/camoverlay/api/services.cgi?action=set';
-        await this.post(path, JSON.stringify(servicesJson));
+    async updateServices(services, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify({ services: services }), {
+            action: 'set',
+        }, options, undefined);
     }
-    updateCGText(serviceID, fields) {
+    updateCGText(serviceId, fields, options) {
         const params = {};
         for (const field of fields) {
             const name = field.field_name;
@@ -103,74 +118,102 @@ class CamOverlayAPI {
                 params[`${name}_color`] = field.color;
             }
         }
-        return this.promiseCGUpdate(serviceID, 'update_text', params);
+        return this.promiseCGUpdate(serviceId, 'update_text', params, undefined, undefined, options);
     }
-    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+    updateCGImagePos(serviceId, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+    updateCGImage(serviceId, path, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
             image: path,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
+    updateCGImageFromData(serviceId, imageType, imageData, coordinates = '', x = 0, y = 0, options) {
         const contentType = imageType === CamOverlayAPI_1.ImageType.PNG ? 'image/png' : 'image/jpeg';
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, contentType, imageData, options);
     }
-    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
-        const path = `/local/camoverlay/api/customGraphics.cgi`;
+    async promiseCGUpdate(serviceId, action, params = {}, contentType, data, options) {
+        const path = `${BASE_PATH}/customGraphics.cgi`;
         let headers = {};
-        if (contentType !== undefined && data) {
+        if (contentType !== undefined && data !== undefined) {
             headers = { 'Content-Type': contentType };
         }
-        const res = await this.client.post(path, data ?? '', {
-            action: action,
-            service_id: serviceID.toString(),
-            ...params,
-        }, headers);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: data ?? '',
+            parameters: {
+                action: action,
+                service_id: serviceId.toString(),
+                ...params,
+            },
+            headers,
+            timeout: options?.timeout,
+        });
         if (!res.ok) {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    async _post(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async _getBlob(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
     async parseBlobResponse(response) {
         try {
-            return await response.blob();
+            return (await response.blob());
         }
         catch (err) {
             throw new errors_1.ParsingBlobError(err);
         }
     }
+    async _postUrlEncoded(path, parameters, options, headers) {
+        const data = (0, utils_1.paramToUrl)(parameters);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
+    }
+    async _postJsonEncoded(path, data, parameters, options, headers) {
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return this._post(path, data, parameters, options, { ...baseHeaders, ...headers });
+    }
 }
 exports.CamOverlayAPI = CamOverlayAPI;

package/cjs/CamScripterAPI.js

@@ -1,70 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamOverlayAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
+exports.CamScripterAPI = void 0;
+const ProxyClient_1 = require("./internal/ProxyClient");
+const utils_1 = require("./internal/utils");
 const CamScripterAPI_1 = require("./types/CamScripterAPI");
-const common_2 = require("./types/common");
-class CamOverlayAPI {
+const common_1 = require("./types/common");
+const BASE_PATH = '/local/camscripter';
+class CamScripterAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
+    }
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
     }
-    async checkCameraTime() {
-        return (await this.get('/local/camscripter/camera_time.cgi')).state;
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return CamScripterAPI_1.cameraTimeResponseSchema.parse(res).state;
     }
-    async getStorageInfo() {
-        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
-        return CamScripterAPI_1.storageSchema.parse(data);
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(res.camera_list);
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camscripter/network_camera_list.cgi');
-        return common_2.networkCameraListSchema.parse(response.camera_list);
+    async getStorageInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
+        return CamScripterAPI_1.cameraStorageSchema.parse(res);
     }
-    async getPackageList() {
-        const data = await this.get('/local/camscripter/package/list.cgi');
-        return CamScripterAPI_1.packageInfoListSchema.parse(data);
+    async getPackageList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/list.cgi`, undefined, options);
+        return CamScripterAPI_1.packageInfoListSchema.parse(res);
     }
-    async installPackages(formData, storage) {
-        await this.post(`/local/camscripter/package/install.cgi?storage=${storage}`, formData);
+    async installPackages(formData, storage, options) {
+        await this._post(`${BASE_PATH}/package/install.cgi`, formData, { storage: storage }, options);
     }
-    async uninstallPackage(packageId) {
-        await this.get(`/local/camscripter/package/remove.cgi?package_name=${packageId}`);
+    async uninstallPackage(packageId, options) {
+        await this._getJson(`${BASE_PATH}/package/remove.cgi`, { package_name: packageId }, options);
     }
-    async importSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData);
+    async importSettings(packageId, formData, options) {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'IMPORT',
+            package_name: packageId,
+        }, options);
     }
-    async exportSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData);
+    async exportSettings(packageId, formData, options) {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'EXPORT',
+            package_name: packageId,
+        }, options);
     }
-    async getNodejsStatus() {
-        return (await this.get('/local/camscripter/diagnostics.cgi')).node_state;
+    async getNodejsStatus(options) {
+        const res = await this._getJson(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
+        return CamScripterAPI_1.nodeStateSchema.parse(res);
     }
-    async installNodejs(storage) {
-        await this.get(`/local/camscripter/node_update.cgi?storage=${storage}`);
+    async installNodejs(storage, options) {
+        await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    async _post(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
 }
-exports.CamOverlayAPI = CamOverlayAPI;
+exports.CamScripterAPI = CamScripterAPI;