camstreamerlib 4.0.0-beta.99 → 4.0.1

package/cjs/internal/BasicAPI.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicAPI = void 0;
+const errors_1 = require("../errors/errors");
+const ProxyClient_1 = require("./ProxyClient");
+const utils_1 = require("./utils");
+class BasicAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
+    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 errors_1.ErrorWithResponse(res);
+        }
+    }
+    async _getText(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.text();
+        }
+        else {
+            throw new errors_1.ErrorWithResponse(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 errors_1.ErrorWithResponse(res);
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new errors_1.ParsingBlobError(err);
+        }
+    }
+    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 errors_1.ErrorWithResponse(res);
+        }
+    }
+    async _postJsonEncoded(path, data, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const jsonData = JSON.stringify(data);
+        const res = await agent.post({
+            path,
+            data: jsonData,
+            parameters,
+            headers: { 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new errors_1.ErrorWithResponse(res);
+        }
+        return res;
+    }
+    async _postUrlEncoded(path, data, options) {
+        const encodedData = (0, utils_1.paramToUrl)(data);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: encodedData,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new errors_1.ErrorWithResponse(res);
+        }
+        return res;
+    }
+}
+exports.BasicAPI = BasicAPI;

package/cjs/internal/WsEvents.d.ts

@@ -30,6 +30,7 @@ export declare class WsEvents<T extends {
     resendInitData(): void;
     addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;
     removeListener<Type extends TEventType<T>>(type: Type, id: string): void;
+    removeAllListenersForId(id: string): void;
     private onMessage;
     private processMessage;
     destroy(): void;

package/cjs/internal/WsEvents.js

@@ -37,6 +37,11 @@ class WsEvents {
             }
         }
     }
+    removeAllListenersForId(id) {
+        for (const type in this.listeners) {
+            this.removeListener(type, id);
+        }
+    }
     onMessage(incomeData) {
         if (this.isDestroyed) {
             return;

package/cjs/internal/constants.d.ts

@@ -1 +1,2 @@
 export declare const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = "11.11.73";
+export declare const FIRMWARE_WITH_OVERLAYS_SUPPORT = "10.7.0";

package/cjs/internal/constants.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = void 0;
+exports.FIRMWARE_WITH_OVERLAYS_SUPPORT = exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = void 0;
 exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = '11.11.73';
+exports.FIRMWARE_WITH_OVERLAYS_SUPPORT = '10.7.0';

package/cjs/internal/convertors.d.ts

@@ -0,0 +1,6 @@
+import { TInternalVapixParameters } from '../types/CamStreamerAPI';
+import { TBitrateMode, TBitrateVapixParams } from '../types/common';
+export declare const parseBitrateOptionsToVapixParams: (firmWareVersion: string, bitrateMode: TBitrateMode | undefined, cameraOptions: Partial<TBitrateVapixParams>) => string;
+export declare const parseVapixParamsToBitrateOptions: (bitrateVapixParams: string) => TBitrateVapixParams;
+export declare const parseVideoOptionsToVapixParams: (firmWareVersion: string, video: TInternalVapixParameters) => string;
+export declare const parseVapixParamsToVideoOptions: (internalVapixParams: string) => TInternalVapixParameters;

package/cjs/internal/convertors.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVapixParamsToVideoOptions = exports.parseVideoOptionsToVapixParams = exports.parseVapixParamsToBitrateOptions = exports.parseBitrateOptionsToVapixParams = void 0;
+const constants_1 = require("./constants");
+const versionCompare_1 = require("./versionCompare");
+const parseBitrateOptionsToVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
+    if (!(0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
+        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
+    }
+    if (bitrateMode === undefined) {
+        return '';
+    }
+    const data = {
+        VBR: 'videobitratemode=vbr',
+        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}&videobitratepriority=framerate`,
+        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
+    };
+    return data[bitrateMode];
+};
+exports.parseBitrateOptionsToVapixParams = parseBitrateOptionsToVapixParams;
+const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
+    const params = {};
+    const searchParams = new URLSearchParams(bitrateVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
+    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
+    if (hasLowerFw) {
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: 'MBR',
+            maximumBitRate: maximumBitRate,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate * 1.1),
+        };
+    }
+    if (bitrateMode === 'ABR') {
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
+        };
+    }
+    else if (bitrateMode === 'MBR') {
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: bitrateMode,
+            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
+        };
+    }
+    return {
+        bitrateMode: bitrateMode,
+        retentionTime: 1,
+        maximumBitRate: 0,
+        bitRateLimit: 0,
+    };
+};
+exports.parseVapixParamsToBitrateOptions = parseVapixParamsToBitrateOptions;
+const parseVideoOptionsToVapixParams = (firmWareVersion, video) => {
+    const bitrateParams = (0, exports.parseBitrateOptionsToVapixParams)(firmWareVersion, video.bitrateMode, {
+        maximumBitRate: video.maximumBitRate,
+        retentionTime: video.retentionTime,
+        bitRateLimit: video.bitRateLimit,
+    });
+    let overlaysParams = '';
+    if ((0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.FIRMWARE_WITH_OVERLAYS_SUPPORT) && video.overlays !== undefined) {
+        overlaysParams = `&overlays=${video.overlays}`;
+    }
+    const nbrOfChannels = video.nbrOfChannels ? (video.audio === 1 ? `&nbrOfChannels=${video.nbrOfChannels}` : '') : '';
+    const audioParams = `audio=${video.audio}${nbrOfChannels}`;
+    const videoCodecParams = video.videoCodec === 'h264'
+        ? `videoCodec=${video.videoCodec}&h264Profile=${video.h264Profile}`
+        : `videoCodec=${video.videoCodec}`;
+    const videoParams = `camera=${video.camera}&resolution=${video.resolution}&fps=${video.fps}&compression=${video.compression}&videokeyframeinterval=${video.govLength}&${videoCodecParams}${overlaysParams}`;
+    return [videoParams, bitrateParams, audioParams].join('&');
+};
+exports.parseVideoOptionsToVapixParams = parseVideoOptionsToVapixParams;
+const parseVapixParamsToVideoOptions = (internalVapixParams) => {
+    const bitrateOptions = (0, exports.parseVapixParamsToBitrateOptions)(internalVapixParams);
+    const params = {};
+    const searchParams = new URLSearchParams(internalVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    let h264Profile = undefined;
+    if (params['videoCodec'] === 'h264') {
+        h264Profile = (params['h264Profile'] ?? 'high');
+    }
+    let nbrOfChannels = undefined;
+    if (params['audio'] === '1') {
+        nbrOfChannels = parseInt(params['nbrOfChannels'] ?? '1');
+    }
+    return {
+        ...bitrateOptions,
+        camera: params['camera'] ?? '1',
+        resolution: params['resolution'] ?? '',
+        fps: parseInt(params['fps'] ?? '0', 10),
+        compression: parseInt(params['compression'] ?? '0', 10),
+        govLength: parseInt(params['videokeyframeinterval'] ?? '0', 10),
+        videoCodec: (params['videoCodec'] ?? 'h264'),
+        h264Profile,
+        audio: parseInt(params['audio'] ?? '0'),
+        nbrOfChannels,
+        overlays: params['overlays'],
+    };
+};
+exports.parseVapixParamsToVideoOptions = parseVapixParamsToVideoOptions;

package/cjs/internal/transformers.js

@@ -1,32 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toSnakeCaseDeep = exports.toSnakeCase = exports.toCamelCaseDeep = exports.toCamelCase = void 0;
-const lodash_1 = require("lodash");
-const toCamelCase = (o) => (0, lodash_1.mapKeys)(o, camelCaseKey);
+const lodash_es_1 = require("lodash-es");
+const toCamelCase = (o) => (0, lodash_es_1.mapKeys)(o, camelCaseKey);
 exports.toCamelCase = toCamelCase;
 const toCamelCaseDeep = (o) => {
     return mapKeysDeep(o, camelCaseKey);
 };
 exports.toCamelCaseDeep = toCamelCaseDeep;
-const toSnakeCase = (o) => (0, lodash_1.mapKeys)(o, snakeCaseKey);
+const toSnakeCase = (o) => (0, lodash_es_1.mapKeys)(o, snakeCaseKey);
 exports.toSnakeCase = toSnakeCase;
 const toSnakeCaseDeep = (o) => {
     return mapKeysDeep(o, snakeCaseKey);
 };
 exports.toSnakeCaseDeep = toSnakeCaseDeep;
-const camelCaseKey = (_, key) => (0, lodash_1.camelCase)(key);
-const snakeCaseKey = (_, key) => (0, lodash_1.snakeCase)(key);
+const camelCaseKey = (_, key) => (0, lodash_es_1.camelCase)(key);
+const snakeCaseKey = (_, key) => (0, lodash_es_1.snakeCase)(key);
 const mapKeysDeep = (obj, cb) => {
     if (Array.isArray(obj)) {
         return obj.map((item) => {
             return mapKeysDeep(item, cb);
         });
     }
-    if (typeof obj !== 'object' || (0, lodash_1.isPlainObject)(obj) === false) {
+    if (typeof obj !== 'object' || (0, lodash_es_1.isPlainObject)(obj) === false) {
         return obj;
     }
-    const result = (0, lodash_1.mapKeys)(obj, cb);
-    return (0, lodash_1.mapValues)(result, (value) => {
+    const result = (0, lodash_es_1.mapKeys)(obj, cb);
+    return (0, lodash_es_1.mapValues)(result, (value) => {
         return mapKeysDeep(value, cb);
     });
 };

package/cjs/internal/types.d.ts

@@ -17,6 +17,9 @@ export type TResponse = {
     status: number;
     ok: boolean;
     statusText: string;
+    headers: {
+        get: (name: string) => string | null;
+    };
 };
 export type TGetParams = {
     path: string;

package/cjs/internal/versionCompare.d.ts

@@ -1,6 +1,6 @@
 export declare const assertVersionString: (s: string, msg?: string) => void;
 export declare const isFirmwareVersionAtLeast: (version: string, compareVersion: string) => boolean;
 export declare const isVersionAtLeast: (version: string, compareVersion: string) => boolean;
-export declare const firmwareVersionCompare: (a: string, b: string) => 0 | 1 | -1;
-export declare const versionCompare: (a: string, b: string) => 0 | 1 | -1;
+export declare const firmwareVersionCompare: (a: string, b: string) => 1 | 0 | -1;
+export declare const versionCompare: (a: string, b: string) => 1 | 0 | -1;
 export declare const fixVersionToDots: (version: string) => string;