@camera.ui/browser 0.0.56 → 0.0.58

package/dist/types/packages/client/browser/src/client.d.ts

@@ -1,13 +1,12 @@
-import { DeviceManagerClient, PluginsManagerClient, SystemManagerClient } from './proxy';
+import { DeviceManager, PluginsManager, SystemManager } from './proxy';
 import type { CameraUiClientConfig } from './types';
 export interface API {
-    deviceManager: DeviceManagerClient;
-    pluginsManager: PluginsManagerClient;
-    systemManager: SystemManagerClient;
+    deviceManager: DeviceManager;
+    pluginsManager: PluginsManager;
+    systemManager: SystemManager;
 }
 export declare class CameraUiClient {
     private api;
-    private socketService?;
     private config;
     private logger;
     private token?;
@@ -18,9 +17,10 @@ export declare class CameraUiClient {
     connect(): Promise<API>;
     disconnect(): Promise<void>;
     updateCredentials(newConfig: CameraUiClientConfig): Promise<void>;
-    getDeviceManager(): DeviceManagerClient | undefined;
-    getPluginsManager(): PluginsManagerClient | undefined;
-    getSystemManager(): SystemManagerClient | undefined;
-    private checkSession;
+    getDeviceManager(): DeviceManager | undefined;
+    getPluginsManager(): PluginsManager | undefined;
+    getSystemManager(): SystemManager | undefined;
+    private login;
+    private proxyCredentials;
     private cleanUpClient;
 }

package/dist/types/packages/client/browser/src/proxy/cameraDevice.d.ts

@@ -1,21 +1,37 @@
-import { BrowserCameraDeviceBase, BrowserStreamingSession } from '../../../../../shared/types';
+import { BrowserCameraDeviceBase } from '../../../../../shared/types';
 import type { BaseLogger, Camera, CameraSource, Frame, IceServer, OnSetEvent, StateValues } from '../../../../../shared/types';
-import type { SocketService } from '../../../node/src/socket';
 export declare class CameraDeviceClient extends BrowserCameraDeviceBase {
-    private socketService;
+    private initialized;
+    private publisher;
+    private client;
+    private cameraSubscriber;
+    private cameraPluginSubscriber;
+    private frameSubscriber;
+    private messageQueue;
+    private auth;
+    private pluginID;
+    private pluginName;
+    private clientSubject;
+    private cameraSubscriberSubject;
+    private cameraPluginSubscriberSubject;
+    private frameSubject;
     get sources(): CameraSource[];
-    constructor(camera: Camera, logger: BaseLogger, socketService: SocketService);
+    constructor(camera: Camera, logger: BaseLogger, auth: {
+        user: string;
+        password: string;
+    });
+    init(): Promise<void>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     reboot(): Promise<void>;
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     generateFrames(): AsyncIterableIterator<Frame>;
     getFfmpegPath(): Promise<string>;
     getIceServers(): Promise<IceServer[]>;
-    createBrowserSession(sourceName: string, videoElement: HTMLVideoElement): Promise<BrowserStreamingSession>;
-    recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
-    cleanup(): void;
     refreshStates(): Promise<void>;
-    private listenToChanges;
+    cleanup(): Promise<void>;
+    private handleRouterRequest;
+    private listenToMessages;
+    private onRequest;
 }

package/dist/types/packages/client/browser/src/proxy/deviceManager.d.ts

@@ -1,18 +1,41 @@
-import { BrowserCameraDeviceBase as CameraDevice } from '../../../../../shared/types';
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { BrowserCameraDeviceBase as CameraDevice } from '../../../../../server/src/camera/base/base.browser';
 import type { BaseLogger, CameraConfig, DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethods } from '../../../../../shared/types';
-import type { SocketService } from '../../../node/src/socket';
-export declare class DeviceManagerClient implements DeviceManagerProxyMethods {
-    private socketService;
-    private devices;
+export declare interface DeviceManager extends DeviceManagerProxyMethods {
+    on<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(event: E, listener: DeviceManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class DeviceManager extends EventEmitter implements DeviceManagerProxyMethods {
     private logger;
-    constructor(socketService: SocketService, logger: BaseLogger);
-    getCameraByName(name: string): Promise<CameraDevice | undefined>;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    private devices;
+    constructor(logger: BaseLogger, auth: {
+        user: string;
+        password: string;
+    });
+    init(): Promise<void>;
     getCameraById(id: string): Promise<CameraDevice | undefined>;
-    createCamera(camera: CameraConfig): Promise<CameraDevice>;
+    getCameraByName(name: string): Promise<CameraDevice | undefined>;
+    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
     removeCameraByName(name: string): Promise<void>;
     removeCameraById(id: string): Promise<void>;
-    on<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callback: DeviceManagerProxyEventCallbacks[E]): void;
-    once<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callback: DeviceManagerProxyEventCallbacks[E]): void;
-    removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callback: DeviceManagerProxyEventCallbacks[E]): void;
-    removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(eventType?: E): void;
+    emit(): boolean;
+    close(): Promise<void>;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private addOrGetCamera;
 }

package/dist/types/packages/client/browser/src/proxy/index.d.ts

@@ -1,4 +1,4 @@
-export * from '../../../node/src/proxy//pluginsManager';
-export * from '../../../node/src/proxy/systemManager';
 export * from './cameraDevice';
 export * from './deviceManager';
+export * from './pluginsManager';
+export * from './systemManager';

package/dist/types/packages/client/browser/src/proxy/pluginsManager.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { BaseLogger, PluginsManagerProxyEventCallbacks, PluginsManagerProxyMethods } from '../../../../../shared/types';
+export declare interface PluginsManager extends PluginsManagerProxyMethods {
+    on<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(event: E, listener: PluginsManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class PluginsManager extends EventEmitter implements PluginsManagerProxyMethods {
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    constructor(logger: BaseLogger, auth: {
+        user: string;
+        password: string;
+    });
+    init(): Promise<void>;
+    emit(): boolean;
+    close(): Promise<void>;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+}

package/dist/types/packages/client/browser/src/proxy/systemManager.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { BaseLogger, SystemManagerProxyEventCallbacks, SystemManagerProxyMethods } from '../../../../../shared/types';
+export declare interface SystemManager extends SystemManagerProxyMethods {
+    on<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof SystemManagerProxyEventCallbacks>(event: E, listener: SystemManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(event?: E): this;
+}
+export declare class SystemManager extends EventEmitter implements SystemManagerProxyMethods {
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    constructor(logger: BaseLogger, auth: {
+        user: string;
+        password: string;
+    });
+    init(): Promise<void>;
+    emit(): boolean;
+    close(): Promise<void>;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+}

package/dist/types/server/src/camera/base/base.browser.d.ts

@@ -1,5 +1,5 @@
 import { BrowserStreamingSession } from '../streaming/browser/browser-streaming-session';
 import { CameraDeviceBase } from './base';
 export declare abstract class BrowserCameraDeviceBase extends CameraDeviceBase {
-    createBrowserSession(sourceName: string, videoElement: HTMLVideoElement): Promise<BrowserStreamingSession>;
+    createSession(sourceName: string, videoElement: HTMLVideoElement): Promise<BrowserStreamingSession>;
 }

package/dist/types/server/src/camera/base/base.d.ts

@@ -61,7 +61,6 @@ export declare abstract class CameraDeviceBase extends Subscribed {
     abstract generateFrames(): AsyncIterableIterator<Frame>;
     abstract getFfmpegPath(): Promise<string>;
     abstract getIceServers(): Promise<IceServer[]>;
-    abstract recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;
     protected abstract cleanup(): void;
     getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;

package/dist/types/server/src/detector/types.d.ts

@@ -25,6 +25,10 @@ export interface BaseFrameWorkerConfig {
     ffmpegPath: string;
     logLevel?: string;
     disableTimestamps?: boolean;
+    auth: {
+        user: string;
+        password: string;
+    };
 }
 export type WorkerMessage = 'ready' | 'getCameraSource';
 export type MainMessage = 'getMetadata' | 'startWorker' | 'stopWorker' | 'startVideoSession' | 'stopVideoSession' | 'setCameraName';

package/dist/types/server/src/plugins/node/proxy/queue.d.ts

@@ -0,0 +1,28 @@
+import type { BaseLogger } from '../../../camera/types';
+import type { ProxyMessageStructure } from '../../../proxy/types';
+interface NatsConnection {
+    publish(subject: string, data: Uint8Array): void;
+}
+interface Subscription extends AsyncIterable<any> {
+}
+interface JSONCodec<T> {
+    encode(d: T): Uint8Array;
+    decode(a: Uint8Array): T;
+}
+export declare class ClientMessageQueue {
+    private logger;
+    private publisher;
+    private subscriber;
+    private requestHandler;
+    private jc;
+    private aborted;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
+    constructor(logger: BaseLogger, publisher: NatsConnection, subscriber: Subscription, codec: JSONCodec<any>, requestHandler: (message: ProxyMessageStructure) => void);
+    abortQueue(): void;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
+    private processQueue;
+    private listenToMessages;
+}
+export {};

package/dist/types/server/src/proxy/constants.d.ts

@@ -0,0 +1 @@
+export declare const NATS_SERVER_SUBJECT = "camera.ui-server";

package/dist/types/server/src/proxy/types.d.ts

@@ -55,6 +55,16 @@ export interface ApiProxyMethods {
         pluginId: string;
     }): Promise<void>;
 }
+export interface ProxyAuth {
+    cluster: {
+        user: string;
+        password: string;
+    };
+    server: {
+        user: string;
+        password: string;
+    };
+}
 export interface DeviceManagerListenerMessagePayload {
     type: keyof DeviceManagerProxyEventCallbacks;
     data: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/browser",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "description": "camera.ui browser client",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "module": "./dist/bundle.js",
@@ -26,8 +26,9 @@
     "axios": "^1.6.8",
     "lodash.clonedeep": "^4.5.0",
     "lodash.isequal": "^4.5.0",
+    "nats.ws": "^1.25.0",
     "rxjs": "^7.8.1",
-    "socket.io-client": "^4.7.5"
+    "util": "^0.12.5"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.10.2",

package/dist/types/packages/client/node/src/proxy/pluginsManager.d.ts

@@ -1,10 +0,0 @@
-import type { PluginsManagerProxyEventCallbacks, PluginsManagerProxyMethods } from '../../../../../shared/types';
-import type { SocketService } from '../socket';
-export declare class PluginsManagerClient implements PluginsManagerProxyMethods {
-    private socketService;
-    constructor(socketService: SocketService);
-    on<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callback: PluginsManagerProxyEventCallbacks[E]): void;
-    once<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callback: PluginsManagerProxyEventCallbacks[E]): void;
-    removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callback: PluginsManagerProxyEventCallbacks[E]): void;
-    removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(eventType?: E): void;
-}

package/dist/types/packages/client/node/src/proxy/systemManager.d.ts

@@ -1,10 +0,0 @@
-import type { SystemManagerProxyEventCallbacks, SystemManagerProxyMethods } from '../../../../../shared/types';
-import type { SocketService } from '../socket';
-export declare class SystemManagerClient implements SystemManagerProxyMethods {
-    private socketService;
-    constructor(socketService: SocketService);
-    on<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callback: SystemManagerProxyEventCallbacks[E]): void;
-    once<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callback: SystemManagerProxyEventCallbacks[E]): void;
-    removeListener<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callback: SystemManagerProxyEventCallbacks[E]): void;
-    removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(eventType?: E): void;
-}

package/dist/types/packages/client/node/src/socket.d.ts

@@ -1,13 +0,0 @@
-import { Manager, type Socket } from 'socket.io-client';
-import type { CameraDeviceProxyMethodNames, DeviceManagerProxyMethodNames, PluginsManagerProxyMethodNames, SystemManagerProxyMethodNames } from '../../../../shared/types';
-type ManagerMethodNames = DeviceManagerProxyMethodNames | SystemManagerProxyMethodNames | PluginsManagerProxyMethodNames;
-type MethodNames<T> = T extends 'manager' ? ManagerMethodNames : T extends 'cameraDevice' ? CameraDeviceProxyMethodNames : never;
-export declare class SocketService {
-    manager: Manager;
-    private token;
-    constructor(endpoint: string, token: string);
-    sendRequest<T extends 'manager' | 'cameraDevice'>(managerType: T, methodName: MethodNames<T>, args: any[]): Promise<any>;
-    getSocket(): Socket;
-    close(): void;
-}
-export {};