camstreamerlib 4.0.0-beta.62 → 4.0.0-beta.64

package/cjs/node/CamOverlayDrawingAPI.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from '../types/CamOverlayDrawingAPI';
+export declare class CamOverlayDrawingAPI extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private cameraList;
+    private zIndex;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: CamOverlayDrawingOptions);
+    connect(): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    cairo(command: string, ...params: unknown[]): Promise<TCairoResponse | TCairoCreateResponse>;
+    writeText(...params: TWriteTextParams): Promise<TCairoResponse>;
+    uploadImageData(imgBuffer: Buffer): Promise<TUploadImageResponse>;
+    uploadFontData(fontBuffer: Buffer): Promise<TCairoCreateResponse>;
+    showCairoImage(cairoImage: string, posX: number, posY: number): Promise<TCairoResponse>;
+    showCairoImageAbsolute(cairoImage: string, posX: number, posY: number, width: number, height: number): Promise<TCairoResponse>;
+    removeImage(): Promise<TCairoResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private sendBinaryMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportMessage;
+    private reportError;
+    private reportClose;
+}

package/cjs/node/CamOverlayPainter/Frame.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TAlign, TCairoCreateResponse, TUploadImageResponse } from '../../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { TBg, TBorder, TDrawingCallback, TFrame, TFrameOptions, TObjectFitType, TRgb, TRgba, TText, TTmf } from '../../types/CamOverlayPainter';
+export declare class Frame extends EventEmitter {
+    protected enabled: boolean;
+    protected posX: number;
+    protected posY: number;
+    protected width: number;
+    protected height: number;
+    private text;
+    private fontColor;
+    private fontName?;
+    private font?;
+    private align;
+    private textType;
+    private bgColor?;
+    private bgImageName?;
+    private bgImage?;
+    private bgType?;
+    private borderRadius;
+    private borderWidth;
+    private borderColor;
+    private customDraw?;
+    private layer;
+    protected children: Frame[];
+    constructor(opt: TFrameOptions);
+    enable(): void;
+    disable(): void;
+    setFramePosition(x: number, y: number): void;
+    setFrameSize(width: number, height: number): void;
+    getFrameInfo(): TFrame;
+    setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
+    setFontColor(fontColor: TRgb): void;
+    setFont(fontName: string): void;
+    setFontData(fontData: TCairoCreateResponse): void;
+    getTextInfo(): TText;
+    setBgColor(color: TRgba): void;
+    setBgImage(imageName: string, type?: TObjectFitType): void;
+    setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
+    setBgType(type: TObjectFitType): void;
+    getBgInfo(): TBg;
+    setBorderRadius(radius: number): void;
+    setBorderWidth(width: number): void;
+    setBorderColor(color: TRgba): void;
+    getBorderInfo(): TBorder;
+    setCustomDraw(customDraw: TDrawingCallback): void;
+    resetFont(): void;
+    resetBgColor(): void;
+    resetBgImage(): void;
+    resetCustomDraw(): void;
+    clear(): void;
+    insert(...frames: Frame[]): void;
+    getLayers(): Set<number>;
+    protected layoutChanged(): void;
+    displayImage(cod: CamOverlayDrawingAPI, resourceManager: ResourceManager, cairo: string, ppX: number, ppY: number, scale: number, layer: number): Promise<void>;
+    private prepareResources;
+    protected displayOwnImage(cod: CamOverlayDrawingAPI, cairo: string, ppX: number, ppY: number, scale: number): Promise<void>;
+    private clipDrawing;
+    private drawFrame;
+    private drawImage;
+    private drawText;
+    private drawBorder;
+    private drawRectPath;
+}

package/cjs/node/CamOverlayPainter/Painter.d.ts

@@ -0,0 +1,32 @@
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { CamOverlayDrawingOptions } from '../../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { Frame } from './Frame';
+import { TCoAlignment, TPainterOptions } from '../../types/CamOverlayPainter';
+export declare class Painter extends Frame {
+    private screenWidth;
+    private screenHeight;
+    private coAlignment;
+    private cod;
+    private rm;
+    private refreshLayers;
+    private layers;
+    constructor(opt: TPainterOptions, coopt: CamOverlayDrawingOptions);
+    get camOverlayDrawingAPI(): CamOverlayDrawingAPI;
+    get resourceManager(): ResourceManager;
+    connect(): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    setScreenSize(sw: number, sh: number): void;
+    setCoAlignment(coAlignment: TCoAlignment): void;
+    protected layoutChanged(): void;
+    display(scale?: number): Promise<void>;
+    hide(): Promise<void>;
+    invalidateLayer(layer: number): Promise<void>;
+    private prepareLayers;
+    private prepareSurface;
+    private cleanupSurface;
+    private positionConvertor;
+}

package/cjs/node/CamOverlayPainter/ResourceManager.d.ts

@@ -0,0 +1,15 @@
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TUploadImageResponse, TCairoCreateResponse } from '../../types/CamOverlayDrawingAPI';
+export declare class ResourceManager {
+    private co;
+    private imgFileNames;
+    private fontFileNames;
+    private images;
+    private fonts;
+    constructor(co: CamOverlayDrawingAPI);
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    image(moniker: string): Promise<TUploadImageResponse | undefined>;
+    font(moniker: string): Promise<TCairoCreateResponse | undefined>;
+    clear(): void;
+}

package/cjs/node/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Options } from '../internal/types';
+import { TCamScripterEvent, TEventDeclaration, TEventUndeclaration, TCamScripterResponse } from '../types/CamScripterAPICameraEventsGenerator';
+export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: Options);
+    connect(): void;
+    disconnect(): void;
+    declareEvent(eventDeclaration: TEventDeclaration): Promise<TCamScripterResponse>;
+    undeclareEvent(eventUndeclaration: TEventUndeclaration): Promise<TCamScripterResponse>;
+    sendEvent(event: TCamScripterEvent): Promise<TCamScripterResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportErr;
+    private reportClose;
+}

package/cjs/node/DefaultClient.d.ts

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

package/cjs/node/Digest.d.ts

@@ -0,0 +1,4 @@
+export declare class Digest {
+    private nonceCount;
+    getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string): string;
+}

package/cjs/node/Digest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/node/HttpRequestSender.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export type HttpRequestOptions = {
+    method?: string;
+    protocol: string;
+    host: string;
+    port: number;
+    path: string;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+};
+export type AgentOptions = {
+    rejectUnaurhorized?: boolean;
+    keepAlive?: boolean;
+};
+export declare class HttpRequestSender {
+    private agent?;
+    private authData?;
+    constructor(agentOptions?: AgentOptions);
+    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | UndiciFormData): Promise<UndiciResponse>;
+    private sendRequestWithAuth;
+    private static getURL;
+    private getAuthorization;
+    private invalidateAuthorization;
+    private static getAuthHeader;
+}

package/cjs/node/HttpServer.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import EventEmitter from 'events';
+export type HttpServerOptions = {
+    host?: string;
+    port?: number;
+};
+type TOnRequestCallback = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare class HttpServer extends EventEmitter {
+    private host;
+    private port;
+    private registeredPaths;
+    private server;
+    private sockets;
+    constructor(options?: HttpServerOptions);
+    getServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    onRequest(pathName: string, callback: TOnRequestCallback): void;
+    close(): void;
+}
+export {};

package/cjs/node/TimeZoneDaemon.d.ts

@@ -0,0 +1,6 @@
+export declare class TimeZoneDaemon {
+    private checkTimer?;
+    constructor(checkInterval?: number);
+    stop(): void;
+    private checkAndUpdateTimeZone;
+}

package/cjs/node/TimeZoneDaemon.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeZoneDaemon = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+class TimeZoneDaemon {
+    checkTimer;
+    constructor(checkInterval = 60000) {
+        this.checkTimer = setInterval(() => this.checkAndUpdateTimeZone(), checkInterval);
+    }
+    stop() {
+        clearInterval(this.checkTimer);
+    }
+    async checkAndUpdateTimeZone() {
+        try {
+            const { stdout } = await execPromise('timedatectl show -p Timezone --value');
+            const systemTimezone = stdout.toString().trim();
+            const nodeTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (systemTimezone !== nodeTimezone) {
+                process.env.TZ = systemTimezone;
+            }
+        }
+        catch (error) {
+            console.error('Error checking/updating timezone:', error);
+        }
+    }
+}
+exports.TimeZoneDaemon = TimeZoneDaemon;

package/cjs/node/VapixEvents.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { Options } from '../internal/types';
+export declare class VapixEvents extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private ws;
+    constructor(options?: Options);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}

package/cjs/node/WsClient.d.ts

@@ -0,0 +1,30 @@
+import { IWsClient, Options } from '../internal/types';
+export type WsClientOptions = Options & {
+    address: string;
+    headers?: Record<string, string>;
+    pingInterval?: number;
+    protocol?: string;
+};
+export declare class WsClient implements IWsClient {
+    private user;
+    private pass;
+    private address;
+    private protocol?;
+    private pingInterval;
+    private wsOptions;
+    private digestAddress;
+    private isAlive;
+    private pingTimer?;
+    private ws?;
+    private isClosed;
+    constructor(options: WsClientOptions);
+    open(wwwAuthenticateHeader?: string): void;
+    onMessage: (_: ArrayBuffer | string) => void;
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send(data: ArrayBuffer | string): void;
+    destroy(): void;
+    reconnect(): void;
+    private closeWsConnection;
+}

package/cjs/node/events/AxisCameraStationEvents.d.ts

@@ -0,0 +1,12 @@
+import { HttpOptions } from '../../internal/types';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { THttpRequestOptions, TProxyParams } from '../../types/common';
+import { DefaultClient } from '../DefaultClient';
+export declare class AxisCameraStationEvents {
+    private sourceKey;
+    private client;
+    constructor(clientOptions: HttpOptions, sourceKey: string);
+    getClient(proxyParams?: TProxyParams): DefaultClient | ProxyClient<DefaultClient>;
+    sendEvent(data: Record<string, string>, eventType: string, options?: THttpRequestOptions): Promise<void>;
+    private getDate;
+}

package/cjs/node/events/GenetecAgent.d.ts

@@ -0,0 +1,16 @@
+import { GenetecAgentOptions, TCameraDetail, TCameraGuidsResponse, TParams } from '../../types/GenetecAgent';
+export declare class GenetecAgent {
+    private settings;
+    private baseUrl;
+    private credentials;
+    constructor(options?: GenetecAgentOptions);
+    checkConnection(): Promise<void>;
+    getAllCameraGuids(): Promise<TCameraGuidsResponse>;
+    getCameraDetails(guids: {
+        Guid: string;
+    }[], parameters: TParams): Promise<TCameraDetail[]>;
+    sendBookmark(guids: string[], bookmarkText: string): Promise<void>;
+    private getRequestOptions;
+    private getTimeStamp;
+    private fetchWithTimeout;
+}

package/cjs/node/events/GenetecAgent.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenetecAgent = void 0;
+const errors_1 = require("../../errors/errors");
 const utils_1 = require("../../internal/utils");
 const GenetecAgent_1 = require("../../types/GenetecAgent");
 class GenetecAgent {
@@ -25,7 +26,7 @@ class GenetecAgent {
         const requestOptions = this.getRequestOptions('GET');
         const res = await this.fetchWithTimeout(new URL(this.baseUrl), requestOptions);
         if (!res.ok) {
-            throw new Error(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         const responseBody = await res.text();
         const result = await GenetecAgent_1.successResponseSchema.safeParseAsync(JSON.parse(responseBody));
@@ -39,7 +40,7 @@ class GenetecAgent {
         url.searchParams.set('q', 'EntityTypes@Camera');
         const res = await this.fetchWithTimeout(url, requestOptions);
         if (!res.ok) {
-            throw new Error(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         const responseBody = await res.text();
         const result = await GenetecAgent_1.cameraGuidsResponseSchema.safeParseAsync(JSON.parse(responseBody));
@@ -60,7 +61,7 @@ class GenetecAgent {
             url.searchParams.set('q', chunk.map((item) => `entity=${item.Guid},${params}`).join(','));
             const res = await this.fetchWithTimeout(url, requestOptions);
             if (!res.ok) {
-                throw new Error(await (0, utils_1.responseStringify)(res));
+                throw new errors_1.ErrorWithResponse(res);
             }
             const responseBody = await res.text();
             const result = await GenetecAgent_1.cameraDetailsResponseSchema.safeParseAsync(JSON.parse(responseBody));
@@ -80,7 +81,7 @@ class GenetecAgent {
         url.searchParams.set('q', guids.map((guid) => `AddCameraBookmark(${guid},${timeStamp},${bookmarkText})`).join(','));
         const res = await this.fetchWithTimeout(url, requestOptions);
         if (!res.ok) {
-            throw new Error(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         const responseBody = await res.text();
         const result = await GenetecAgent_1.successResponseSchema.safeParseAsync(JSON.parse(responseBody));

package/cjs/node/index.d.ts

@@ -0,0 +1,17 @@
+export * from './DefaultClient';
+export * from './WsClient';
+export * from './HttpServer';
+export * from './HttpRequestSender';
+export * from './events/AxisCameraStationEvents';
+export * from './events/GenetecAgent';
+export * from '../types/GenetecAgent';
+export { ResourceManager } from './CamOverlayPainter/ResourceManager';
+export { Painter } from './CamOverlayPainter/Painter';
+export { Frame } from './CamOverlayPainter/Frame';
+export * from '../types/CamOverlayPainter';
+export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
+export * from '../types/CamOverlayDrawingAPI';
+export { CamScripterAPICameraEventsGenerator } from './CamScripterAPICameraEventsGenerator';
+export * from '../types/CamScripterAPICameraEventsGenerator';
+export { VapixEvents } from './VapixEvents';
+export * from '../types/VapixEvents';