camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.21

package/cjs/models/CamOverlayAPI/widgetsSchema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.widgetListSchema = exports.widgetsSchema = void 0;
+const customGraphicsSchema_1 = require("./customGraphicsSchema");
+const imagesSchema_1 = require("./imagesSchema");
+const accuweatherSchema_1 = require("./accuweatherSchema");
+const infotickerSchema_1 = require("./infotickerSchema");
+const pipSchema_1 = require("./pipSchema");
+const ptzCompassSchema_1 = require("./ptzCompassSchema");
+const ptzSchema_1 = require("./ptzSchema");
+const screenSharingSchema_1 = require("./screenSharingSchema");
+const webCameraSharingSchema_1 = require("./webCameraSharingSchema");
+const zod_1 = require("zod");
+exports.widgetsSchema = zod_1.z.discriminatedUnion('name', [
+    infotickerSchema_1.infoTickerSchema,
+    accuweatherSchema_1.accuweatherSchema,
+    ptzCompassSchema_1.ptzCompassSchema,
+    imagesSchema_1.imagesSchema,
+    ptzSchema_1.ptzSchema,
+    pipSchema_1.pipSchema,
+    customGraphicsSchema_1.customGraphicsSchema,
+    screenSharingSchema_1.screenSharingSchema,
+    webCameraSharingSchema_1.webCameraSharingSchema,
+]);
+exports.widgetListSchema = zod_1.z.object({
+    services: zod_1.z.array(exports.widgetsSchema),
+});

package/cjs/node/DefaultClient.d.ts

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

package/cjs/node/DefaultClient.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultClient = void 0;
+const utils_1 = require("../internal/utils");
+const HttpRequestSender_1 = require("./HttpRequestSender");
+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_1.HttpRequestSender(agentOptions);
+    }
+    get url() {
+        return `${this.tls ? 'https' : 'http'}://${this.user}:${this.pass}@${this.ip}:${this.port}`;
+    }
+    get = (...params) => {
+        const [path, parameters, headers] = params;
+        const options = this.getBaseConnectionParams('GET', path, parameters ?? {});
+        options.headers = headers;
+        return this.httpRequestSender.sendRequest(options);
+    };
+    post = (...params) => {
+        const [path, data, parameters, headers] = params;
+        const options = this.getBaseConnectionParams('POST', path, parameters ?? {});
+        options.headers = headers;
+        return this.httpRequestSender.sendRequest(options, data);
+    };
+    getBaseConnectionParams(method, path, params) {
+        const pathName = (0, utils_1.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,
+        };
+    }
+}
+exports.DefaultClient = DefaultClient;

package/cjs/node/HttpRequestSender.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestSender = void 0;
+const Digest_1 = require("../internal/Digest");
+const undici_1 = require("undici");
+class HttpRequestSender {
+    agent;
+    authData;
+    constructor(agentOptions) {
+        this.agent = new undici_1.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 undici_1.Request(url, { body: postData, method: options.method, headers: options.headers });
+        const res = await (0, undici_1.fetch)(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_1.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)}`;
+        }
+    }
+}
+exports.HttpRequestSender = HttpRequestSender;

package/cjs/node/HttpServer.js

@@ -0,0 +1,96 @@
+"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 {
+    host;
+    port;
+    registeredPaths;
+    server;
+    sockets;
+    constructor(options) {
+        super();
+        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) => {
+            this.emit('access', req.method + ' ' + req.url);
+            const parsedUrl = url.parse(req.url ?? '');
+            parsedUrl.pathname ??= '';
+            const requestCallback = this.registeredPaths.get(parsedUrl.pathname);
+            if (requestCallback) {
+                requestCallback(req, res);
+                return;
+            }
+            let pathname = `./html${parsedUrl.pathname}`;
+            const ext = path.parse(pathname).ext;
+            const map = {
+                '.ico': 'image/x-icon',
+                '.html': 'text/html',
+                '.js': 'text/javascript',
+                '.json': 'application/json',
+                '.css': 'text/css',
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.wav': 'audio/wav',
+                '.mp3': 'audio/mpeg',
+                '.svg': 'image/svg+xml',
+                '.pdf': 'application/pdf',
+                '.doc': 'application/msword',
+            };
+            fs.access(pathname, fs.constants.R_OK, (err) => {
+                if (err) {
+                    res.statusCode = 404;
+                    res.end(`File ${pathname} not found!`);
+                    this.emit('error', `File ${pathname} not found!`);
+                    return;
+                }
+                if (fs.statSync(pathname).isDirectory()) {
+                    pathname += `/index${ext}`;
+                }
+                fs.readFile(pathname, (error, data) => {
+                    if (error) {
+                        res.statusCode = 500;
+                        res.end(`Error getting the file: ${error}`);
+                        this.emit('error', `Error getting the file: ${error}`);
+                    }
+                    else {
+                        res.setHeader('Content-type', map[ext] ?? 'text/plain');
+                        res.setHeader('Access-Control-Allow-Origin', '*');
+                        res.end(data);
+                    }
+                });
+            });
+        });
+        this.server.on('error', (err) => {
+            this.emit('error', err);
+        });
+        this.server.listen(this.port, this.host);
+        this.sockets = {};
+        let idTracker = 0;
+        this.server.on('connection', (socket) => {
+            const socketID = idTracker++;
+            this.sockets[socketID] = socket;
+            socket.on('close', () => {
+                delete this.sockets[socketID];
+            });
+        });
+    }
+    getServer() {
+        return this.server;
+    }
+    onRequest(pathName, callback) {
+        this.registeredPaths.set(pathName, callback);
+    }
+    close() {
+        this.server.close();
+        for (const key in this.sockets) {
+            this.sockets[key]?.destroy();
+        }
+    }
+}
+exports.HttpServer = HttpServer;

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

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

package/cjs/node/WsClient.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = void 0;
+const EventEmitter = require("events");
+const WebSocket = require("ws");
+const Digest_1 = require("../internal/Digest");
+class WsClient extends EventEmitter {
+    user;
+    pass;
+    address;
+    protocol;
+    pingInterval;
+    wsOptions;
+    digestAddress;
+    isAlive = true;
+    pingTimer;
+    ws;
+    isClosed = false;
+    constructor(options) {
+        super();
+        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 = options.pingInterval ?? 30000;
+        this.protocol = options.protocol;
+        this.wsOptions = {
+            auth: `${this.user}:${this.pass}`,
+            rejectUnauthorized: !tlsInsecure,
+            headers: options.headers ?? {},
+        };
+    }
+    open(wwwAuthenticateHeader) {
+        try {
+            if (this.ws !== undefined) {
+                return;
+            }
+            this.isClosed = false;
+            if (this.protocol === undefined) {
+                this.ws = new WebSocket(this.address, this.wsOptions);
+            }
+            else {
+                this.ws = new WebSocket(this.address, this.protocol, this.wsOptions);
+            }
+            this.ws.binaryType = 'arraybuffer';
+            this.isAlive = true;
+            this.pingTimer = setInterval(async () => {
+                if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
+                    this.emit('error', new Error('Connection timeout'));
+                    await this.closeWsConnection();
+                }
+                else {
+                    this.isAlive = false;
+                    this.ws?.ping();
+                }
+            }, 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.ws.on('unexpected-response', (req, res) => {
+                if (res.statusCode === 401 && res.headers['www-authenticate'] !== undefined) {
+                    if (this.pingTimer) {
+                        clearInterval(this.pingTimer);
+                    }
+                    this.ws?.removeAllListeners();
+                    this.ws = undefined;
+                    this.open(res.headers['www-authenticate']);
+                }
+                else {
+                    this.emit('error', new Error('Status code: ' + res.statusCode));
+                    this.closeWsConnection();
+                }
+            });
+            this.ws.on('open', () => this.emit('open'));
+            this.ws.on('message', (data) => this.emit('message', data));
+            this.ws.on('error', (error) => {
+                this.emit('error', error);
+                this.closeWsConnection();
+            });
+            this.ws.on('close', () => this.closeWsConnection());
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error('Unknown error'));
+            this.closeWsConnection();
+        }
+    }
+    send(data) {
+        if (this.ws === undefined) {
+            throw new Error("This websocket hasn't been opened yet.");
+        }
+        if (this.ws.readyState === this.ws.OPEN) {
+            this.ws.send(data);
+        }
+    }
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        this.closeWsConnection();
+    }
+    reconnect() {
+        this.closeWsConnection();
+    }
+    closeWsConnection() {
+        if (this.ws === undefined) {
+            return;
+        }
+        const wsCopy = this.ws;
+        this.ws = undefined;
+        try {
+            if (this.pingTimer) {
+                clearInterval(this.pingTimer);
+            }
+            wsCopy.removeAllListeners();
+            wsCopy.on('error', () => { });
+            if (wsCopy.readyState !== WebSocket.CLOSING && wsCopy.readyState !== WebSocket.CLOSED) {
+                wsCopy.close();
+            }
+            setTimeout(() => {
+                if (wsCopy.readyState !== WebSocket.CLOSED) {
+                    wsCopy.terminate();
+                }
+            }, 5000);
+            this.emit('close');
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            const shouldRestart = !this.isClosed;
+            setTimeout(() => {
+                wsCopy.removeAllListeners();
+                if (shouldRestart && !this.isClosed) {
+                    this.open();
+                }
+            }, 10000);
+        }
+    }
+}
+exports.WsClient = WsClient;

package/{node → cjs/node}/WsEventClient.d.ts

@@ -1,4 +1,4 @@
-import { IWebsocket } from '../internal/common';
+import { IWebsocket } from '../internal/types';
 import { WsClientOptions } from './WsClient';
 type TEvent = {
     data: string;

package/cjs/node/WsEventClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsEventClient = void 0;
+const WsClient_1 = require("./WsClient");
+class WsEventClient {
+    wsClient;
+    constructor(options) {
+        this.wsClient = new WsClient_1.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;
+}
+exports.WsEventClient = WsEventClient;

package/cjs/node/index.d.ts

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/cjs/node/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = exports.DefaultClient = void 0;
+var DefaultClient_1 = require("./DefaultClient");
+Object.defineProperty(exports, "DefaultClient", { enumerable: true, get: function () { return DefaultClient_1.DefaultClient; } });
+var WsClient_1 = require("./WsClient");
+Object.defineProperty(exports, "WsClient", { enumerable: true, get: function () { return WsClient_1.WsClient; } });