camstreamerlib 3.5.2 → 4.0.0-beta.2

package/internal/transformers.d.ts

@@ -0,0 +1,5 @@
+import type { CamelCasedProperties, CamelCasedPropertiesDeep, SnakeCasedProperties, SnakeCasedPropertiesDeep } from 'type-fest';
+export declare const toCamelCase: <T extends object>(o: T) => CamelCasedProperties<T>;
+export declare const toCamelCaseDeep: <T extends object>(o: T) => CamelCasedPropertiesDeep<T>;
+export declare const toSnakeCase: <T extends object>(o: T) => SnakeCasedProperties<T>;
+export declare const toSnakeCaseDeep: <T extends object>(o: T) => SnakeCasedPropertiesDeep<T>;

package/internal/transformers.js

@@ -0,0 +1,25 @@
+import { camelCase, snakeCase, isPlainObject, mapKeys, mapValues } from 'lodash';
+export const toCamelCase = (o) => mapKeys(o, camelCaseKey);
+export const toCamelCaseDeep = (o) => {
+    return mapKeysDeep(o, camelCaseKey);
+};
+export const toSnakeCase = (o) => mapKeys(o, snakeCaseKey);
+export const toSnakeCaseDeep = (o) => {
+    return mapKeysDeep(o, snakeCaseKey);
+};
+const camelCaseKey = (_, key) => camelCase(key);
+const snakeCaseKey = (_, key) => snakeCase(key);
+const mapKeysDeep = (obj, cb) => {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => {
+            return mapKeysDeep(item, cb);
+        });
+    }
+    if (typeof obj !== 'object' || isPlainObject(obj) === false) {
+        return obj;
+    }
+    const result = mapKeys(obj, cb);
+    return mapValues(result, (value) => {
+        return mapKeysDeep(value, cb);
+    });
+};

package/internal/utils.d.ts

@@ -0,0 +1,11 @@
+import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
+import { TParameters } from './common';
+export declare const addParametersToPath: (path: string, params?: TParameters) => string;
+export declare const paramToUrl: (params?: TParameters) => string;
+export declare const arrayToUrl: (arr: string | string[]) => string;
+export declare const isCamera: (id?: string) => boolean;
+export declare const isStream: (id?: string) => boolean;
+export declare const isClip: (id?: string) => boolean;
+export declare const isTracker: (id?: string) => boolean;
+export declare const isPlaylist: (id?: string) => boolean;
+export declare const isLoopPlayType: (playType: TPlaylistPlayType) => boolean;

package/internal/utils.js

@@ -0,0 +1,34 @@
+import { isNullish } from './common';
+export const addParametersToPath = (path, params) => {
+    if (params === undefined || Object.keys(params).length === 0) {
+        return path;
+    }
+    const joinChar = path.indexOf('?') === -1 ? '?' : '&';
+    return `${path}${joinChar}${paramToUrl(params)}`;
+};
+export const paramToUrl = (params) => {
+    if (params === undefined) {
+        return '';
+    }
+    let output = '';
+    for (const key in params) {
+        const value = params[key];
+        if (isNullish(value)) {
+            continue;
+        }
+        output += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`;
+    }
+    return output.slice(0, output.length - 1);
+};
+export const arrayToUrl = (arr) => {
+    if (Array.isArray(arr)) {
+        return arr.join(',');
+    }
+    return arr;
+};
+export const isCamera = (id) => id?.charAt(0) === 'c';
+export const isStream = (id) => id?.charAt(0) === 'c' || id?.charAt(0) === 'a';
+export const isClip = (id) => id?.charAt(0) === 's';
+export const isTracker = (id) => id?.charAt(0) === 't';
+export const isPlaylist = (id) => id?.charAt(0) === 'p';
+export const isLoopPlayType = (playType) => playType.includes('LOOP');

package/internal/versionCompare.d.ts

@@ -0,0 +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) => 1 | -1 | 0;
+export declare const versionCompare: (a: string, b: string) => 1 | -1 | 0;
+export declare const fixVersionToDots: (version: string) => string;

package/internal/versionCompare.js

@@ -0,0 +1,44 @@
+export const assertVersionString = (s, msg) => {
+    if (!s.match(/^[0-9]+(\.[0-9]+){1,3}$/)) {
+        throw new Error(msg ?? `${s} is not a version`);
+    }
+};
+export const isFirmwareVersionAtLeast = (version, compareVersion) => {
+    return firmwareVersionCompare(version, compareVersion) >= 0;
+};
+export const isVersionAtLeast = (version, compareVersion) => {
+    return versionCompare(version, compareVersion) >= 0;
+};
+export const firmwareVersionCompare = (a, b) => {
+    const versions = [a, b];
+    const matchBetaFirmwareVersion = (x) => /^CVP-/.test(x) || /^[0-9]+.*beta/.test(x);
+    if (versions.every(matchBetaFirmwareVersion)) {
+        return 0;
+    }
+    if (matchBetaFirmwareVersion(a)) {
+        return -1;
+    }
+    if (matchBetaFirmwareVersion(b)) {
+        return 1;
+    }
+    return versionCompare(a, b);
+};
+export const versionCompare = (a, b) => {
+    assertVersionString(a);
+    assertVersionString(b);
+    const aSplit = parseVersion(a);
+    const bSplit = parseVersion(b);
+    for (let i = 0; i < aSplit.length; i++) {
+        if (aSplit[i] !== bSplit[i]) {
+            return aSplit[i] < bSplit[i] ? -1 : 1;
+        }
+    }
+    return 0;
+};
+export const fixVersionToDots = (version) => version.replaceAll('-', '.');
+const parseVersion = (version) => {
+    assertVersionString(version);
+    const parsed = version.split('.').map((s) => parseInt(s));
+    parsed.push(...Array(4 - parsed.length).fill(0));
+    return parsed;
+};

package/node/DefaultClient.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IClient, HttpOptions, TParameters } from '../internal/common';
+export declare class DefaultClient implements IClient {
+    private tls;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private httpRequestSender;
+    constructor(opt?: HttpOptions);
+    get url(): string;
+    get(path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    post(path: string, data: string | FormData | Buffer, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    private getBaseConnectionParams;
+}

package/node/DefaultClient.js

@@ -0,0 +1,50 @@
+import { addParametersToPath } from '../internal/utils';
+import { HttpRequestSender } from './HttpRequestSender';
+export class DefaultClient {
+    tls;
+    ip;
+    port;
+    user;
+    pass;
+    httpRequestSender;
+    constructor(opt = {}) {
+        this.tls = opt.tls ?? false;
+        this.ip = opt.ip ?? '127.0.0.1';
+        this.port = opt.port ?? (this.tls ? 443 : 80);
+        this.user = opt.user ?? '';
+        this.pass = opt.pass ?? '';
+        let agentOptions;
+        if (opt.tlsInsecure !== undefined || opt.keepAlive !== undefined) {
+            agentOptions = {
+                rejectUnaurhorized: !opt.tlsInsecure,
+                keepAlive: opt.keepAlive,
+            };
+        }
+        this.httpRequestSender = new HttpRequestSender(agentOptions);
+    }
+    get url() {
+        return `${this.tls ? 'https' : 'http'}://${this.user}:${this.pass}@${this.ip}:${this.port}`;
+    }
+    async get(path, parameters = {}, headers) {
+        const options = this.getBaseConnectionParams('GET', path, parameters);
+        options.headers = headers;
+        return this.httpRequestSender.sendRequest(options);
+    }
+    async post(path, data, parameters = {}, headers) {
+        const options = this.getBaseConnectionParams('POST', path, parameters);
+        options.headers = headers;
+        return this.httpRequestSender.sendRequest(options, data);
+    }
+    getBaseConnectionParams(method, path, params) {
+        let pathName = addParametersToPath(path, params);
+        return {
+            method: method,
+            protocol: this.tls ? 'https:' : 'http:',
+            host: this.ip,
+            port: this.port,
+            path: pathName,
+            user: this.user,
+            pass: this.pass,
+        };
+    }
+}

package/{internal → node}/HttpRequestSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-/// <reference types="node" />
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
 export type HttpRequestOptions = {
     method?: string;
     protocol: string;
@@ -19,7 +19,7 @@ export declare class HttpRequestSender {
     private agent?;
     private authData?;
     constructor(agentOptions?: AgentOptions);
-    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | FormData): Promise<Response>;
+    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | UndiciFormData): Promise<UndiciResponse>;
     private sendRequestWithAuth;
     private static getURL;
     private getAuthorization;

package/node/HttpRequestSender.js

@@ -0,0 +1,85 @@
+import { Digest } from '../internal/Digest';
+import { Agent, fetch as undiciFetch, Request as UndiciRequest, } from 'undici';
+export class HttpRequestSender {
+    agent;
+    authData;
+    constructor(agentOptions) {
+        this.agent = new Agent({
+            connect: { rejectUnauthorized: agentOptions?.rejectUnaurhorized, keepAlive: agentOptions?.keepAlive },
+        });
+    }
+    sendRequest(options, postData) {
+        return this.sendRequestWithAuth(options, postData);
+    }
+    async sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
+        options.timeout ??= 10000;
+        const url = HttpRequestSender.getURL(options);
+        const authorization = this.getAuthorization(options, wwwAuthenticateHeader);
+        if (authorization !== undefined) {
+            options.headers ??= {};
+            options.headers['Authorization'] = authorization;
+        }
+        const req = new UndiciRequest(url, { body: postData, method: options.method, headers: options.headers });
+        const res = await undiciFetch(req, { signal: AbortSignal.timeout(options.timeout), dispatcher: this.agent });
+        if (!res.ok) {
+            this.invalidateAuthorization();
+        }
+        if (res.status === 401) {
+            const authenticateHeader = res.headers.get('www-authenticate');
+            if (authenticateHeader !== null &&
+                authenticateHeader.indexOf('Digest') !== -1 &&
+                wwwAuthenticateHeader === undefined) {
+                return this.sendRequestWithAuth(options, postData, authenticateHeader);
+            }
+            else {
+                return res;
+            }
+        }
+        else {
+            return res;
+        }
+    }
+    static getURL(options) {
+        const url = new URL(`${options.protocol}//${options.host}:${options.port}${options.path}`);
+        return url.toString();
+    }
+    getAuthorization(options, wwwAuthenticateHeader) {
+        if (options.user === undefined || options.pass === undefined) {
+            this.authData = undefined;
+            return;
+        }
+        if (this.authData &&
+            (this.authData.host !== options.host ||
+                this.authData.port !== options.port ||
+                this.authData.user !== options.user ||
+                this.authData.pass !== options.pass ||
+                (wwwAuthenticateHeader !== undefined && this.authData.wwwAuthenticateHeader !== wwwAuthenticateHeader))) {
+            this.authData = undefined;
+        }
+        if (this.authData === undefined) {
+            this.authData = {
+                host: options.host,
+                port: options.port,
+                user: options.user,
+                pass: options.pass,
+                wwwAuthenticateHeader,
+                digest: new Digest(),
+            };
+        }
+        return HttpRequestSender.getAuthHeader(options, this.authData);
+    }
+    invalidateAuthorization() {
+        this.authData = undefined;
+    }
+    static getAuthHeader(options, authData) {
+        if (options.user === undefined || options.pass === undefined) {
+            throw new Error('No credentials found');
+        }
+        if (authData.wwwAuthenticateHeader !== undefined && authData.wwwAuthenticateHeader.indexOf('Digest') !== -1) {
+            return authData.digest.getAuthHeader(options.user, options.pass, options.method ?? 'GET', options.path, authData.wwwAuthenticateHeader);
+        }
+        else {
+            return `Basic ${btoa(options.user + ':' + options.pass)}`;
+        }
+    }
+}

package/{HttpServer.d.ts → node/HttpServer.d.ts}

@@ -15,7 +15,7 @@ export declare class HttpServer extends EventEmitter {
     private sockets;
     constructor(options?: HttpServerOptions);
     getServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    onRequest(path: string, callback: TOnRequestCallback): void;
+    onRequest(pathName: string, callback: TOnRequestCallback): void;
     close(): void;
 }
 export {};

package/{HttpServer.js → node/HttpServer.js}

@@ -1,23 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpServer = void 0;
-const http = require("http");
-const url = require("url");
-const fs = require("fs");
-const path = require("path");
-const EventEmitter = require("events");
-class HttpServer extends EventEmitter {
+import * as http from 'http';
+import * as url from 'url';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as EventEmitter from 'events';
+export class HttpServer extends EventEmitter {
+    host;
+    port;
+    registeredPaths;
+    server;
+    sockets;
     constructor(options) {
-        var _a, _b, _c, _d;
         super();
-        this.host = (_b = (_a = options === null || options === void 0 ? void 0 : options.host) !== null && _a !== void 0 ? _a : process.env.HTTP_HOST) !== null && _b !== void 0 ? _b : '0.0.0.0';
-        this.port = (_c = options === null || options === void 0 ? void 0 : options.port) !== null && _c !== void 0 ? _c : parseInt((_d = process.env.HTTP_PORT) !== null && _d !== void 0 ? _d : '80');
+        this.host = options?.host ?? process.env.HTTP_HOST ?? '0.0.0.0';
+        this.port = options?.port ?? parseInt(process.env.HTTP_PORT ?? '80');
         this.registeredPaths = new Map();
         this.server = http.createServer((req, res) => {
-            var _a, _b;
             this.emit('access', req.method + ' ' + req.url);
-            const parsedUrl = url.parse((_a = req.url) !== null && _a !== void 0 ? _a : '');
-            (_b = parsedUrl.pathname) !== null && _b !== void 0 ? _b : (parsedUrl.pathname = '');
+            const parsedUrl = url.parse(req.url ?? '');
+            parsedUrl.pathname ??= '';
             const requestCallback = this.registeredPaths.get(parsedUrl.pathname);
             if (requestCallback) {
                 requestCallback(req, res);
@@ -49,15 +49,14 @@ class HttpServer extends EventEmitter {
                 if (fs.statSync(pathname).isDirectory()) {
                     pathname += `/index${ext}`;
                 }
-                fs.readFile(pathname, (err, data) => {
-                    var _a;
-                    if (err) {
+                fs.readFile(pathname, (error, data) => {
+                    if (error) {
                         res.statusCode = 500;
-                        res.end(`Error getting the file: ${err}`);
-                        this.emit('error', `Error getting the file: ${err}`);
+                        res.end(`Error getting the file: ${error}`);
+                        this.emit('error', `Error getting the file: ${error}`);
                     }
                     else {
-                        res.setHeader('Content-type', (_a = map[ext]) !== null && _a !== void 0 ? _a : 'text/plain');
+                        res.setHeader('Content-type', map[ext] ?? 'text/plain');
                         res.setHeader('Access-Control-Allow-Origin', '*');
                         res.end(data);
                     }
@@ -81,8 +80,8 @@ class HttpServer extends EventEmitter {
     getServer() {
         return this.server;
     }
-    onRequest(path, callback) {
-        this.registeredPaths.set(path, callback);
+    onRequest(pathName, callback) {
+        this.registeredPaths.set(pathName, callback);
     }
     close() {
         this.server.close();
@@ -91,4 +90,3 @@ class HttpServer extends EventEmitter {
         }
     }
 }
-exports.HttpServer = HttpServer;

package/{internal → node}/WsClient.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as EventEmitter from 'events';
-import { WsOptions } from './common';
+import { WsOptions } from '../internal/common';
 export type WsClientOptions = WsOptions & {
     address: string;
     headers?: Record<string, string>;

package/{internal → node}/WsClient.js

@@ -1,39 +1,35 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WsClient = void 0;
-const EventEmitter = require("events");
-const WebSocket = require("ws");
-const Digest_1 = require("./Digest");
-class WsClient extends EventEmitter {
+import * as EventEmitter from 'events';
+import * as WebSocket from 'ws';
+import { Digest } from '../internal/Digest';
+export class WsClient extends EventEmitter {
+    user;
+    pass;
+    address;
+    protocol;
+    pingInterval;
+    wsOptions;
+    digestAddress;
+    isAlive = true;
+    pingTimer;
+    ws;
+    isClosed = false;
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
         super();
-        this.isAlive = true;
-        this.isClosed = false;
-        const tls = (_a = options === null || options === void 0 ? void 0 : options.tls) !== null && _a !== void 0 ? _a : false;
-        const tlsInsecure = (_b = options === null || options === void 0 ? void 0 : options.tlsInsecure) !== null && _b !== void 0 ? _b : false;
-        const ip = (_c = options === null || options === void 0 ? void 0 : options.ip) !== null && _c !== void 0 ? _c : '127.0.0.1';
-        const port = (_d = options === null || options === void 0 ? void 0 : options.port) !== null && _d !== void 0 ? _d : (tls ? 443 : 80);
-        this.user = (_e = options === null || options === void 0 ? void 0 : options.user) !== null && _e !== void 0 ? _e : '';
-        this.pass = (_f = options === null || options === void 0 ? void 0 : options.pass) !== null && _f !== void 0 ? _f : '';
+        const tls = options.tls ?? false;
+        const tlsInsecure = options.tlsInsecure ?? false;
+        const ip = options.ip ?? '127.0.0.1';
+        const port = options.port ?? (tls ? 443 : 80);
+        this.user = options.user ?? '';
+        this.pass = options.pass ?? '';
         const protocol = tls ? 'wss' : 'ws';
         this.address = `${protocol}://${ip}:${port}${options.address}`;
         this.digestAddress = options.address;
-        this.pingInterval = (_g = options.pingInterval) !== null && _g !== void 0 ? _g : 30000;
+        this.pingInterval = options.pingInterval ?? 30000;
         this.protocol = options.protocol;
         this.wsOptions = {
             auth: `${this.user}:${this.pass}`,
             rejectUnauthorized: !tlsInsecure,
-            headers: (_h = options.headers) !== null && _h !== void 0 ? _h : {},
+            headers: options.headers ?? {},
         };
     }
     open(wwwAuthenticateHeader) {
@@ -50,38 +46,36 @@ class WsClient extends EventEmitter {
             }
             this.ws.binaryType = 'arraybuffer';
             this.isAlive = true;
-            this.pingTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                var _a;
+            this.pingTimer = setInterval(async () => {
                 if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
                     this.emit('error', new Error('Connection timeout'));
-                    yield this.closeWsConnection();
+                    await this.closeWsConnection();
                 }
                 else {
                     this.isAlive = false;
-                    (_a = this.ws) === null || _a === void 0 ? void 0 : _a.ping();
+                    this.ws?.ping();
                 }
-            }), this.pingInterval);
+            }, this.pingInterval);
             this.ws.on('pong', () => {
                 this.isAlive = true;
             });
             if (wwwAuthenticateHeader !== undefined) {
-                this.wsOptions.headers['Authorization'] = new Digest_1.Digest().getAuthHeader(this.user, this.pass, 'GET', this.digestAddress, wwwAuthenticateHeader);
+                this.wsOptions.headers['Authorization'] = new Digest().getAuthHeader(this.user, this.pass, 'GET', this.digestAddress, wwwAuthenticateHeader);
             }
-            this.ws.on('unexpected-response', (req, res) => __awaiter(this, void 0, void 0, function* () {
-                var _b;
+            this.ws.on('unexpected-response', (req, res) => {
                 if (res.statusCode === 401 && res.headers['www-authenticate'] !== undefined) {
                     if (this.pingTimer) {
                         clearInterval(this.pingTimer);
                     }
-                    (_b = this.ws) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
+                    this.ws?.removeAllListeners();
                     this.ws = undefined;
                     this.open(res.headers['www-authenticate']);
                 }
                 else {
                     this.emit('error', new Error('Status code: ' + res.statusCode));
-                    yield this.closeWsConnection();
+                    this.closeWsConnection();
                 }
-            }));
+            });
             this.ws.on('open', () => this.emit('open'));
             this.ws.on('message', (data) => this.emit('message', data));
             this.ws.on('error', (error) => {
@@ -149,4 +143,3 @@ class WsClient extends EventEmitter {
         }
     }
 }
-exports.WsClient = WsClient;

package/node/WsEventClient.d.ts

@@ -0,0 +1,13 @@
+import { IWebsocket } from '../internal/common';
+import { WsClientOptions } from './WsClient';
+type TEvent = {
+    data: string;
+};
+export declare class WsEventClient implements IWebsocket<TEvent> {
+    private wsClient;
+    constructor(options: WsClientOptions);
+    send: (data: string) => void;
+    destroy: () => void;
+    onmessage: ((event: TEvent) => void) | null;
+}
+export {};

package/node/WsEventClient.js

@@ -0,0 +1,18 @@
+import { WsClient } from './WsClient';
+export class WsEventClient {
+    wsClient;
+    constructor(options) {
+        this.wsClient = new WsClient(options);
+        this.wsClient.on('message', (data) => {
+            this.onmessage?.({ data: data.toString() });
+        });
+    }
+    send = (data) => {
+        this.wsClient.send(data);
+    };
+    destroy = () => {
+        this.wsClient.close();
+        this.onmessage = null;
+    };
+    onmessage = null;
+}

package/package.json

@@ -1,13 +1,16 @@
 {
     "name": "camstreamerlib",
-    "version": "3.5.2",
+    "version": "4.0.0-beta.2",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
+    "type": "module",
     "dependencies": {
         "adm-zip": "^0.5.9",
         "eventemitter2": "^5.0.1",
+        "lodash": "^4.17.21",
         "prettify-xml": "^1.2.0",
-        "undici": "6.13.0",
+        "type-fest": "^4.41.0",
+        "undici": "^6.21.3",
         "ws": "^8.18.0",
         "xml2js": "^0.5.0",
         "zod": "^3.24.3"
@@ -16,10 +19,11 @@
         "node": ">=18.0.0"
     },
     "devDependencies": {
-        "@camstreamer/eslint-config": "^1.0.0",
+        "@camstreamer/eslint-config": "^1.0.2",
         "@camstreamer/prettier-config": "^2.0.4",
         "@types/adm-zip": "^0.5.5",
         "@types/jest": "^28.0.0",
+        "@types/lodash": "^4.17.18",
         "@types/node": "^18.19.39",
         "@types/ws": "^8.5.10",
         "@types/xml2js": "^0.4.14",