camstreamerlib 4.0.0-beta.10 → 4.0.0-beta.101

package/cjs/CamOverlayAPI.js

@@ -1,161 +1,115 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamOverlayAPI = exports.BASE_URL = void 0;
-const common_1 = require("./internal/common");
-const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+exports.CamOverlayAPI = void 0;
+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 widgetsSchema_1 = require("./models/CamOverlayAPI/widgetsSchema");
-const fileSchema_1 = require("./models/CamOverlayAPI/fileSchema");
-const utils_1 = require("./internal/utils");
-exports.BASE_URL = '/local/camoverlay/api';
+const ProxyClient_1 = require("./internal/ProxyClient");
+const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+const BASE_PATH = '/local/camoverlay/api';
 class CamOverlayAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${exports.BASE_URL}/proxy.cgi`;
-    static getFilePreviewPath = (path) => `${exports.BASE_URL}/image.cgi?path=${encodeURIComponent(path)}`;
-    async checkCameraTime() {
-        const responseSchema = zod_1.z.discriminatedUnion('state', [
-            zod_1.z.object({
-                state: zod_1.z.literal(true),
-                code: zod_1.z.number(),
-            }),
-            zod_1.z.object({
-                state: zod_1.z.literal(false),
-                code: zod_1.z.number(),
-                reason: zod_1.z.union([
-                    zod_1.z.literal('INVALID_TIME'),
-                    zod_1.z.literal('COULDNT_RESOLVE_HOST'),
-                    zod_1.z.literal('CONNECTION_ERROR'),
-                ]),
-                message: zod_1.z.string(),
-            }),
-        ]);
-        const response = await this._get(`${exports.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_1.ProxyClient(this.client, proxyParams) : this.client;
     }
-    async getNetworkCameraList() {
-        const response = await this._get(`${exports.BASE_URL}/network_camera_list.cgi`);
-        return common_2.networkCameraListSchema.parse(response.camera_list);
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return zod_1.z.boolean().parse(res.state);
     }
-    async wsAuthorization() {
-        const responseSchema = zod_1.z.object({
-            status: zod_1.z.number(),
-            message: zod_1.z.string(),
-            data: zod_1.z.string(),
-        });
-        const response = await this._get(`${exports.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 common_1.networkCameraListSchema.parse(res.camera_list);
     }
-    async getMjpegStreamImage(mjpegUrl) {
-        return await this._getBlob(`${exports.BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return CamOverlayAPI_1.wsResponseSchema.parse(res).message;
     }
-    async listFiles(fileType) {
-        const fileDataSchema = zod_1.z.object({
-            code: zod_1.z.number(),
-            list: fileSchema_1.fileListSchema,
-        });
-        const files = await this._get(`${exports.BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'list',
-        });
-        return fileSchema_1.fileListSchema.parse(files.list);
+    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) {
-        const path = `${exports.BASE_URL}/upload_${fileType}.cgi`;
-        await this._post(path, formData, {
+    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 = `${exports.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 = zod_1.z.array(zod_1.z.object({
-            type: fileSchema_1.storageSchema,
-            state: zod_1.z.string(),
-        }));
-        const responseSchema = zod_1.z.object({
-            code: zod_1.z.number(),
-            list: storageDataListSchema,
-        });
-        const data = await this._get(`${exports.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 errors_1.StorageDataFetchError(res);
         }
-        return storageDataListSchema.parse(data.list);
+        return CamOverlayAPI_1.storageDataListSchema.parse(res.list);
     }
-    async getFilePreviewFromCamera(path) {
-        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path));
+    async getFilePreviewFromCamera(path, options) {
+        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path), undefined, options);
     }
-    async updateInfoticker(serviceID, text) {
-        await this._get(`${exports.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(`${exports.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(`${exports.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 errors_1.ServiceNotFoundError();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
-    async getSingleWidget(serviceId) {
-        const data = await this._get(`${exports.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_1.widgetsSchema.parse(data);
+            service_id: serviceId,
+        }, options);
+        return CamOverlayAPI_1.servicesSchema.parse(res);
     }
-    async getWidgets() {
-        const widgetList = await this._get(`${exports.BASE_URL}/services.cgi`, {
-            action: 'get',
-        });
-        const widgets = widgetList.services;
-        widgets.forEach((widget) => {
-            const parsedWidget = widgetsSchema_1.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 = CamOverlayAPI_1.serviceListSchema.parse(res).services;
+        return services;
     }
-    async updateSingleWidget(widget) {
-        const path = `${exports.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 = `${exports.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;
@@ -164,93 +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 = `${exports.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 (0, common_1.responseStringify)(res));
+            throw new errors_1.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 (0, common_1.responseStringify)(res));
+            throw new errors_1.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 (0, common_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
-    async _getBlob(...args) {
-        const res = await this.client.get(...args);
+    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, common_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async parseBlobResponse(response) {
         try {
-            return await response.blob();
+            return (await response.blob());
         }
         catch (err) {
             throw new errors_1.ParsingBlobError(err);
         }
     }
-    async _postUrlEncoded(path, params, headers) {
-        const data = (0, utils_1.paramToUrl)(params);
+    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, {}, { ...baseHeaders, ...headers });
+        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
     }
-    async _postJsonEncoded(...args) {
-        const [path, data, params, headers] = args;
+    async _postJsonEncoded(path, data, parameters, options, headers) {
         const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return this._post(path, data, params, { ...baseHeaders, ...headers });
+        return this._post(path, data, parameters, options, { ...baseHeaders, ...headers });
     }
 }
 exports.CamOverlayAPI = CamOverlayAPI;

package/cjs/CamScripterAPI.d.ts

@@ -1,19 +1,46 @@
-import { IClient } from './internal/common';
-import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
-import { TNetworkCamera } from './types/common';
-export declare class CamOverlayAPI<Client extends IClient = IClient> {
-    client: Client;
+import { ProxyClient } from './internal/ProxyClient';
+import { IClient, TResponse } from './internal/types';
+import { THttpRequestOptions, TProxyParams, TStorageType } from './types/common';
+export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
+    private client;
     constructor(client: Client);
-    checkCameraTime(): Promise<boolean>;
-    getStorageInfo(): Promise<TStorage>;
-    getNetworkCameraList(): Promise<TNetworkCamera[]>;
-    getPackageList(): Promise<TPackageInfoList>;
-    installPackages(formData: FormData, storage: TStorageType): Promise<void>;
-    uninstallPackage(packageId: string): Promise<void>;
-    importSettings(packageId: string, formData: FormData): Promise<void>;
-    exportSettings(packageId: string, formData: FormData): Promise<void>;
-    getNodejsStatus(): Promise<TNodeState>;
-    installNodejs(storage: TStorageType): Promise<void>;
-    private get;
-    private post;
+    static getProxyPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<[{
+        type: "FLASH";
+        capacity_mb: number;
+    }, {
+        type: "SD_DISK";
+        capacity_mb: number;
+    }] | [{
+        type: "FLASH";
+        capacity_mb: number;
+    }]>;
+    getPackageList(options?: THttpRequestOptions): Promise<{
+        storage: "FLASH" | "SD_DISK";
+        manifest: {
+            package_name: string;
+            package_menu_name: string;
+            package_version: string;
+            vendor: string;
+            ui_link: string;
+            required_camscripter_version?: string | undefined;
+            required_camscripter_rbi_version?: string | undefined;
+        };
+    }[]>;
+    installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
+    uninstallPackage(packageId: string, options?: THttpRequestOptions): Promise<void>;
+    importSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
+    exportSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
+    getNodejsStatus(options?: THttpRequestOptions): Promise<{
+        node_state: "OK" | "NOT_INSTALLED" | "NOT_FOUND";
+    }>;
+    installNodejs(storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
+    private _getJson;
+    private _post;
 }

package/cjs/CamScripterAPI.js

@@ -1,64 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamOverlayAPI = void 0;
-const common_1 = require("./internal/common");
+exports.CamScripterAPI = void 0;
+const errors_1 = require("./errors/errors");
+const ProxyClient_1 = require("./internal/ProxyClient");
 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(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_1.ProxyClient(this.client, proxyParams) : this.client;
     }
-    async getStorageInfo() {
-        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
-        return CamScripterAPI_1.storageSchema.parse(data);
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return CamScripterAPI_1.cameraTimeResponseSchema.parse(res).state;
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camscripter/network_camera_list.cgi');
-        return common_2.networkCameraListSchema.parse(response.camera_list);
+    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 getPackageList() {
-        const data = await this.get('/local/camscripter/package/list.cgi');
-        return CamScripterAPI_1.packageInfoListSchema.parse(data);
+    async getStorageInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
+        return CamScripterAPI_1.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 CamScripterAPI_1.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 CamScripterAPI_1.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 (0, common_1.responseStringify)(res));
+            throw new errors_1.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 (0, common_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
 }
-exports.CamOverlayAPI = CamOverlayAPI;
+exports.CamScripterAPI = CamScripterAPI;