camstreamerlib 4.0.0-beta.9 → 4.0.0-beta.91

package/esm/CamOverlayAPI.js

@@ -1,160 +1,112 @@
-import { responseStringify } from './internal/common';
-import { ImageType, } from './types/CamOverlayAPI';
-import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
+import { paramToUrl } from './internal/utils';
+import { ParsingBlobError, ErrorWithResponse, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
 import { z } from 'zod';
-import { widgetsSchema } from './models/CamOverlayAPI/widgetsSchema';
-import { fileListSchema, storageSchema } from './models/CamOverlayAPI/fileSchema';
-import { paramToUrl } from './internal/utils';
-export const BASE_URL = '/local/camoverlay/api';
+import { ProxyClient } from './internal/ProxyClient';
+import { fileListSchema, ImageType, storageDataListSchema, serviceListSchema, servicesSchema, wsResponseSchema, } from './types/CamOverlayAPI';
+const BASE_PATH = '/local/camoverlay/api';
 export class CamOverlayAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
-    static getFilePreviewPath = (path) => `${BASE_URL}/file_preview.cgi?path=${encodeURIComponent(path)}`;
-    async checkCameraTime() {
-        const responseSchema = z.discriminatedUnion('state', [
-            z.object({
-                state: z.literal(true),
-                code: z.number(),
-            }),
-            z.object({
-                state: z.literal(false),
-                code: z.number(),
-                reason: z.union([
-                    z.literal('INVALID_TIME'),
-                    z.literal('COULDNT_RESOLVE_HOST'),
-                    z.literal('CONNECTION_ERROR'),
-                ]),
-                message: z.string(),
-            }),
-        ]);
-        const response = await this._get(`${BASE_URL}/camera_time.cgi`);
-        const cameraTime = responseSchema.parse(response);
-        if (!cameraTime.state) {
-            console.error(`Camera time check failed: ${cameraTime.reason} - ${cameraTime.message}`);
-        }
-        return cameraTime.state;
+    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(this.client, proxyParams) : this.client;
     }
-    async getNetworkCameraList() {
-        const response = await this._get(`${BASE_URL}/network_camera_list.cgi`);
-        return networkCameraListSchema.parse(response.camera_list);
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return z.boolean().parse(res.state);
     }
-    async wsAuthorization() {
-        const responseSchema = z.object({
-            status: z.number(),
-            message: z.string(),
-            data: z.string(),
-        });
-        const response = await this._get(`${BASE_URL}/ws_authorization.cgi`);
-        return responseSchema.parse(response).data;
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(res.camera_list);
     }
-    async getMjpegStreamImage(mjpegUrl) {
-        const res = await this._get(`${BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
-        return await this.parseBlobResponse(res);
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return wsResponseSchema.parse(res).message;
     }
-    async listFiles(fileType) {
-        const fileDataSchema = z.object({
-            code: z.number(),
-            list: fileListSchema,
-        });
-        const files = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'list',
-        });
-        return fileListSchema.parse(files.list);
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob(`${BASE_PATH}/fetch_mjpeg_image.cgi`, { mjpeg_url: decodeURIComponent(mjpegUrl) }, options);
     }
-    async uploadFile(fileType, formData, storage) {
-        const path = `${BASE_URL}/upload_${fileType}.cgi`;
-        await this._post(path, formData, {
+    async listFiles(fileType, options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'list' }, options);
+        return 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) {
-        const path = `${BASE_URL}/upload_${fileType}.cgi`;
-        await this._postUrlEncoded(path, {
+    async removeFile(fileType, fileParams, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/upload_${fileType}.cgi`, {
             action: 'remove',
             ...fileParams,
-        });
+        }, options, undefined);
     }
-    async getFileStorage(fileType) {
-        const storageDataListSchema = z.array(z.object({
-            type: storageSchema,
-            state: z.string(),
-        }));
-        const responseSchema = z.object({
-            code: z.number(),
-            list: storageDataListSchema,
-        });
-        const data = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'get_storage',
-        });
-        if (data.code !== 200) {
-            throw new Error('Error occured while fetching file storage data');
+    async getFileStorage(fileType, options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
+        if (res.code !== 200) {
+            throw new StorageDataFetchError(res);
         }
-        return storageDataListSchema.parse(data.list);
+        return storageDataListSchema.parse(res.list);
     }
-    async getFilePreviewFromCamera(path) {
-        const response = await this._get(CamOverlayAPI.getFilePreviewPath(path));
-        return await this.parseBlobResponse(response);
+    async getFilePreviewFromCamera(path, options) {
+        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path), undefined, options);
     }
-    async updateInfoticker(serviceID, text) {
-        await this._get(`${BASE_URL}/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+    async updateInfoticker(serviceId, text, options) {
+        await this._getJson(`${BASE_PATH}/infoticker.cgi`, { service_id: serviceId, text: text }, options);
     }
-    async setEnabled(serviceID, enabled) {
-        await this._post(`${BASE_URL}/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+    async setEnabled(serviceId, enabled, options) {
+        await this._post(`${BASE_PATH}/enabled.cgi`, '', { [`id_${serviceId}`]: enabled ? 1 : 0 }, options);
     }
-    async isEnabled(serviceID) {
-        const res = await this.client.get(`${BASE_URL}/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 ServiceNotFoundError();
         }
         else {
-            throw new Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
     }
-    async getSingleWidget(serviceId) {
-        const data = await this._get(`${BASE_URL}/services.cgi`, {
+    async getSingleService(serviceId, options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, {
             action: 'get',
-            service_id: serviceId.toString(),
-        });
-        return widgetsSchema.parse(data);
+            service_id: serviceId,
+        }, options);
+        return servicesSchema.parse(res);
     }
-    async getWidgets() {
-        const widgetList = await this._get(`${BASE_URL}/services.cgi`, {
-            action: 'get',
-        });
-        const widgets = widgetList.services;
-        widgets.forEach((widget) => {
-            const parsedWidget = widgetsSchema.safeParse(widget);
-            if (!parsedWidget.success) {
-                console.warn(`[SERVICE SCHEMA MISMATCH]: Service ${widget.name} (${widget.id}) does not match the current schema, or is a hidden service.`);
-            }
-        });
-        return widgets;
+    async getServices(options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, { action: 'get' }, options);
+        const services = serviceListSchema.parse(res).services;
+        return services;
     }
-    async updateSingleWidget(widget) {
-        const path = `${BASE_URL}/services.cgi`;
-        await this._postJsonEncoded(path, JSON.stringify(widget), {
+    async updateSingleService(service, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify(service), {
             action: 'set',
-            service_id: widget.id.toString(),
-        });
+            service_id: service.id,
+        }, options, undefined);
     }
-    async updateWidgets(widgets) {
-        const path = `${BASE_URL}/services.cgi`;
-        await this._postJsonEncoded(path, JSON.stringify({ services: widgets }), {
+    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;
@@ -163,83 +115,101 @@ export 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 === 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 = `${BASE_URL}/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 responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
     }
-    async _get(...args) {
-        const res = await this.client.get(...args);
+    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());
+            return await res.json();
         }
         else {
-            throw new Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
     }
-    async _post(...args) {
-        const res = await this.client.post(...args);
+    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());
+            return await res.json();
         }
         else {
-            throw new Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
     }
-    async _postUrlEncoded(path, params, headers) {
-        const data = paramToUrl(params);
-        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        return this._post(path, data, {}, { ...baseHeaders, ...headers });
-    }
-    async _postJsonEncoded(...args) {
-        const [path, data, params, headers] = args;
-        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return this._post(path, data, params, { ...baseHeaders, ...headers });
+    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 ErrorWithResponse(res);
+        }
     }
     async parseBlobResponse(response) {
         try {
-            return await response.blob();
+            return (await response.blob());
         }
         catch (err) {
             throw new ParsingBlobError(err);
         }
     }
+    async _postUrlEncoded(path, parameters, options, headers) {
+        const data = 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 });
+    }
 }

package/esm/CamScripterAPI.js

@@ -1,60 +1,76 @@
-import { responseStringify } from './internal/common';
-import { packageInfoListSchema, storageSchema, } from './types/CamScripterAPI';
+import { ErrorWithResponse } from './errors/errors';
+import { ProxyClient } from './internal/ProxyClient';
+import { cameraTimeResponseSchema, nodeStateSchema, packageInfoListSchema, cameraStorageSchema, } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
-export class CamOverlayAPI {
+const BASE_PATH = '/local/camscripter';
+export class CamScripterAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    async checkCameraTime() {
-        return (await this.get('/local/camscripter/camera_time.cgi')).state;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
-    async getStorageInfo() {
-        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
-        return storageSchema.parse(data);
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return cameraTimeResponseSchema.parse(res).state;
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camscripter/network_camera_list.cgi');
-        return networkCameraListSchema.parse(response.camera_list);
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(res.camera_list);
     }
-    async getPackageList() {
-        const data = await this.get('/local/camscripter/package/list.cgi');
-        return packageInfoListSchema.parse(data);
+    async getStorageInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
+        return cameraStorageSchema.parse(res);
     }
-    async installPackages(formData, storage) {
-        await this.post(`/local/camscripter/package/install.cgi?storage=${storage}`, formData);
+    async getPackageList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/list.cgi`, undefined, options);
+        return packageInfoListSchema.parse(res);
     }
-    async uninstallPackage(packageId) {
-        await this.get(`/local/camscripter/package/remove.cgi?package_name=${packageId}`);
+    async installPackages(formData, storage, options) {
+        await this._post(`${BASE_PATH}/package/install.cgi`, formData, { storage: storage }, options);
     }
-    async importSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData);
+    async uninstallPackage(packageId, options) {
+        await this._getJson(`${BASE_PATH}/package/remove.cgi`, { package_name: packageId }, options);
     }
-    async exportSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=EXPORT&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 getNodejsStatus() {
-        return (await this.get('/local/camscripter/diagnostics.cgi')).node_state;
+    async exportSettings(packageId, formData, options) {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'EXPORT',
+            package_name: packageId,
+        }, options);
     }
-    async installNodejs(storage) {
-        await this.get(`/local/camscripter/node_update.cgi?storage=${storage}`);
+    async getNodejsStatus(options) {
+        const res = await this._getJson(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
+        return nodeStateSchema.parse(res);
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async installNodejs(storage, options) {
+        await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
+    }
+    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 responseStringify(res));
+            throw new ErrorWithResponse(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 responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
     }
 }