@camera.ui/browser 0.0.33 → 0.0.35

package/dist/src/proxy/proxies/camera.d.ts

@@ -1,57 +1,88 @@
-import type { CameraInput } from '../../api/database/types';
+/// <reference types="pouchdb-core" />
+/// <reference types="node" />
 import type { OnSetEvent, StateValues } from '../../camera/types';
 import type { IceServer } from '../../services/config/types';
-import type { FfmpegOptions, PrebufferType } from '../../camera/types';
-import type { ProxyServer } from '..';
-import type { CameraDeviceProxyMessageStructure, CameraDeviceProxyMethods, CameraDeviceListenerMessagePayload, CameraId } from '../types';
+import type { FfmpegOptions, PrebufferType, CameraDelegate } from '../../camera/types';
+import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types';
+import type { MessageQueue } from '../queue';
+import type { CameraDeviceHub } from '../../camera';
+import type { Camera } from '../../api/database/types';
 export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     private api;
     private configService;
     private camerasService;
     private pluginsService;
-    private proxyServer;
-    constructor(proxyServer: ProxyServer);
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
     snapshot(data: {
-        sourceName: string;
+        prebuffer?: boolean;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<ArrayBuffer>;
     setPrebufferSource(data: {
         sourceName: string;
-        address: string | null;
+        address: string;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
+    removePrebufferSource(data: {
+        sourceName: string;
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
-    getFffmpegPath(): string;
-    getIceServers(): IceServer[];
+    removePrebufferSources(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
+    getFffmpegPath(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): string;
+    getIceServers(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): IceServer[];
     updateState<T extends keyof StateValues>(data: {
         stateName: T;
         eventData: OnSetEvent<T>;
         cameraId: string;
-    }): void;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
     refreshStates(data: {
         cameraId: string;
-    }): {
-        sources: CameraInput[];
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<{
+        camera: Camera;
         states: StateValues;
-    } | undefined;
+    }>;
     streamVideo(data: {
         sourceName: string;
         options: FfmpegOptions;
         cameraId: string;
+        pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
     recordToFile(data: {
         sourceName: string;
         outputPath: string;
         duration?: number;
         cameraId: string;
+        pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
-    handleMessage(msg: CameraDeviceProxyMessageStructure): Promise<void>;
-    publishCameraMessage<K extends keyof StateValues>(cameraId: CameraId, stateName: K, data: {
-        newEvent: StateValues[K];
-        oldEvent: StateValues[K];
-    }): Promise<void>;
-    publishCameraMessage(cameraId: CameraId, type: CameraDeviceListenerMessagePayload['type'], data?: any): Promise<void>;
-    private isCameraState;
+    onRequestSnapshotRequest(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
+    onRequestPrepareStream(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
+    onRequestWebRTCOffer(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;
+    onRequestWebRTCIceCandidates(cameraDevice: CameraDeviceHub, ...args: Parameters<CameraDelegate['onCandidates']>): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

package/dist/src/proxy/proxies/plugin.d.ts

@@ -1,10 +1,11 @@
 import { type CameraStorage, type BasePlugin } from '../../plugins/types';
-import type { ProxyServer } from '..';
-import type { MethodKeys } from '../types';
+import type { MethodKeys, ProxyMessageStructure } from '../types';
+import type { MessageQueue } from '../queue';
 export declare class PluginProxy {
     private pluginsService;
-    private proxyServer;
-    constructor(proxyServer: ProxyServer);
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
     onRequestPluginFn<K extends Exclude<MethodKeys<BasePlugin>, 'configureCameras'>>(pluginId: string, fn: K, ...args: Parameters<BasePlugin[K]>): Promise<ReturnType<BasePlugin[K]>>;
     onRequestStorageFn<K extends MethodKeys<CameraStorage>>(pluginId: string, cameraId: string, fn: K, ...args: Parameters<CameraStorage[K]>): Promise<ReturnType<CameraStorage[K]>>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

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

@@ -1,17 +1,12 @@
-import type { ProxyServer } from '..';
 import type { ApiProxyMethods, ProxyMessageStructure } from '../types';
 import type { Camera } from '../../api/database/types';
 import type { CameraConfig } from '../../camera/types';
-export declare interface ServerProxy {
-    listen(): any;
-    removeListener(): any;
-    removeAllListeners(): any;
-}
+import type { MessageQueue } from '../queue';
 export declare class ServerProxy implements ApiProxyMethods {
     private camerasService;
     private pluginsService;
-    private proxyServer;
-    constructor(proxyServer: ProxyServer);
+    private messageQueue;
+    constructor(messageQueue: MessageQueue);
     getCameraByName(data: {
         name: string;
     }): Promise<Camera | undefined>;
@@ -30,5 +25,5 @@ export declare class ServerProxy implements ApiProxyMethods {
         id: string;
         pluginId: string;
     }): Promise<void>;
-    handleMessage(msg: ProxyMessageStructure): Promise<void>;
+    handleMessage(message: ProxyMessageStructure): Promise<void>;
 }

package/dist/src/proxy/queue.d.ts

@@ -1,15 +1,14 @@
-import type { Reply, Router } from 'zeromq';
-import type { QueueItem } from './types';
+import type { ProxyMessageStructure } from './types';
+import type { ProxyServer } from '.';
 export declare class MessageQueue {
-    private queue;
+    private logger;
+    private proxyServer;
+    private router;
     private isProcessing;
+    private queue;
     private pendingResponses;
-    private reqServer;
-    private router;
-    constructor(reqServer: Reply, router: Router);
-    addToQueue(item: QueueItem): Promise<void>;
-    receiveResponse(requestId: string, response: any): void;
-    receiveError(requestId: string, error: Error): void;
+    constructor(proxyServer: ProxyServer);
+    enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;
-    private sendMessage;
+    private listenToDealer;
 }

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

@@ -1,81 +1,35 @@
-/// <reference types="node" />
-import type { Camera, CameraInput } from '../api/database/types';
-import type { BasePlugin, CameraStorage } from '../plugins/types';
+import type { Camera } from '../api/database/types';
+import type { CameraExtension } from '../plugins/types';
 import type { CameraConfig, OnSetEvent, StateValues, CameraDevice, FfmpegOptions, PrebufferType } from '../camera/types';
 import type { IceServer } from '../services/config/types';
 export type MethodKeys<T> = {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T];
-export interface ClientQueueItem {
-    requestId: string;
-    message: any;
+export interface QueueItem {
+    message: ProxyMessageStructure;
     resolve: (response: any) => void;
     reject: (error: Error) => void;
-    timeout: number;
-}
-export interface QueueItem {
-    requestType: 'router' | 'request';
-    targetId: string;
-    requestId: string;
-    message: any;
-    timeout?: number;
-    onResponse?: (response: any) => void;
-    onError?: (error: Error) => void;
-}
-export interface RequestPayload {
-    fn: string;
-    data: Record<string, any>;
-    requestId: string;
 }
-export interface QueueRequestItem {
-    payload: CameraDeviceProxyMessageStructure | ProxyMessageStructure;
-    resolve: (value: any) => void;
-    reject: (reason?: any) => void;
-    timeout: NodeJS.Timeout;
-}
-export interface RouterDealerPayload {
-    fn: keyof BasePlugin | keyof CameraStorage;
-    args: any[];
+export interface ProxyMessageStructure {
     requestId: string;
-    targetId: string;
-    pluginId: string;
     cameraId?: string;
-}
-export interface PluginRouterDealePayload extends RouterDealerPayload {
-    fn: keyof BasePlugin;
-}
-export interface StorageRouterDealerPayload extends RouterDealerPayload {
-    fn: keyof CameraStorage;
-}
-export interface QueueRouterDealerItem {
-    payload: RouterDealerPayload;
-    resolve: (value: any) => void;
-    reject: (reason?: any) => void;
-    timeout: NodeJS.Timeout;
-}
-export type CameraId = string;
-export type PluginId = string;
-export type TargetID = CameraId | PluginId | 'all';
-export interface PendingMessagePayload {
-    requestId: string;
-    response?: any;
-}
-export interface ListenerMessagePayload {
-    type: keyof ProxyEventCallbacks;
-    data: any;
-}
-export interface ProxyMessageStructure {
     targetId: string;
-    targetName: string;
+    targetName?: string;
     pluginId: string;
-    cameraId?: boolean;
-    requestId: string;
-    fn: ProxyMethodNames;
-    data: any;
+    type: 'request' | 'reply';
+    proxy: 'system' | 'device' | 'plugins' | 'camera';
+    client: 'pluginFn' | 'pluginStorage' | 'cameraFn' | 'cameraDelegate' | 'device' | 'system';
+    fn: string;
+    args: any;
+    timeout: number;
     timestamp: number;
+    response?: any;
+    error?: any;
+}
+export interface WsManagerClientMessage {
+    method: ProxyMethodNames;
+    args: any[];
 }
-export type ProxyEvents = SystemManagerProxyEvents & DeviceManagerProxyEvents;
-export type ProxyEventCallbacks = SystemManagerProxyEventCallbacks & DeviceManagerProxyEventCallbacks;
 export type ProxyMethodNames = SystemManagerProxyMethodNames | DeviceManagerProxyMethodNames;
 export interface ApiProxyMethods {
     createCamera(data: {
@@ -99,10 +53,6 @@ export interface ApiProxyMethods {
         pluginId: string;
     }): Promise<void>;
 }
-export interface WsManagerClientMessage {
-    method: ProxyMethodNames;
-    args: any[];
-}
 export interface DeviceManagerListenerMessagePayload {
     type: keyof DeviceManagerProxyEventCallbacks;
     data: any;
@@ -113,20 +63,38 @@ export interface DeviceManagerProxyMethods {
     getCameraById(id: string): Promise<CameraDevice | undefined>;
     removeCameraByName(name: string): Promise<void>;
     removeCameraById(id: string): Promise<void>;
+}
+export interface DeviceManagerProxyMethodsListener {
     listen<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callback: DeviceManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof DeviceManagerProxyEventCallbacks>(eventType: E, callbackToRemove: DeviceManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof DeviceManagerProxyEventCallbacks>(eventType?: E): void;
 }
 export type DeviceManagerProxyMethodNames = MethodKeys<DeviceManagerProxyMethods>;
 export interface DeviceManagerProxyEvents {
-    cameraAdded: Camera;
-    cameraRemoved: Camera;
-    cameraUpdated: Camera;
+    cameraSelected: {
+        camera: Camera;
+        extension: CameraExtension;
+    };
+    cameraDeselected: {
+        camera: Camera;
+        extension: CameraExtension;
+    };
+    cameraAdded: {
+        camera: Camera;
+    };
+    cameraRemoved: {
+        camera: Camera;
+    };
+    cameraUpdated: {
+        camera: Camera;
+    };
 }
 export type DeviceManagerProxyEventCallbacks = {
+    cameraSelected: (camera: CameraDevice, extension: CameraExtension) => void;
+    cameraDeselected: (cameraId: string, extension: CameraExtension) => void;
     cameraAdded: (camera: CameraDevice) => void;
-    cameraUpdated: (cameraId: string, camera: CameraDevice) => void;
     cameraRemoved: (cameraId: string) => void;
+    cameraUpdated: (cameraId: string, camera: CameraDevice) => void;
 };
 export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerProxyEvents> {
     type: K;
@@ -137,6 +105,8 @@ export interface SystemManagerListenerMessagePayload {
     data: any;
 }
 export interface SystemManagerProxyMethods {
+}
+export interface SystemManagerProxyMethodsListener {
     listen<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callback: SystemManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof SystemManagerProxyEventCallbacks>(eventType: E, callbackToRemove: SystemManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof SystemManagerProxyEventCallbacks>(eventType?: E): void;
@@ -154,6 +124,8 @@ export interface PluginsManagerListenerMessagePayload {
     data: any;
 }
 export interface PluginsManagerProxyMethods {
+}
+export interface PluginsManagerProxyMethodsListener {
     listen<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callback: PluginsManagerProxyEventCallbacks[E]): void;
     removeListener<E extends keyof PluginsManagerProxyEventCallbacks>(eventType: E, callbackToRemove: PluginsManagerProxyEventCallbacks[E]): void;
     removeAllListeners<E extends keyof PluginsManagerProxyEventCallbacks>(eventType?: E): void;
@@ -175,58 +147,68 @@ export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     };
 }
 export interface CameraDeviceListenerMessagePayload {
-    type: 'removed' | 'updated';
+    type: 'removed' | 'updated' | 'updatedSources';
     data?: any;
 }
-export interface CameraDeviceProxyMessageStructure {
-    targetId: string;
-    targetName: string;
-    pluginId: string;
-    cameraId?: string;
-    requestId: string;
-    fn: CameraDeviceProxyMethodNames;
-    data: any;
-    timestamp: number;
-}
 export interface CameraDeviceProxyMethods {
     snapshot(data: {
         sourceName: string;
+        prebuffer?: boolean;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<ArrayBuffer>;
     setPrebufferSource(data: {
         sourceName: string;
-        address: string | null;
+        address: string;
         type: PrebufferType;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
+    removePrebufferSource(data: {
+        sourceName: string;
+        type: PrebufferType;
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
+    }): Promise<void>;
+    removePrebufferSources(data: {
+        cameraId: string;
+        pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
     getFffmpegPath(data: {
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): string;
     getIceServers(data: {
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): IceServer[];
     updateState<T extends keyof StateValues>(data: {
         stateName: T;
         eventData: OnSetEvent<T>;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): void;
     refreshStates(data: {
         cameraId: string;
         pluginId: string;
-    }): {
-        sources: CameraInput[];
+        ws?: boolean;
+    }): Promise<{
+        camera: Camera;
         states: StateValues;
-    } | undefined;
+    }>;
     streamVideo(data: {
         sourceName: string;
         options: FfmpegOptions;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
     recordToFile(data: {
         sourceName: string;
@@ -234,6 +216,7 @@ export interface CameraDeviceProxyMethods {
         duration?: number;
         cameraId: string;
         pluginId: string;
+        ws?: boolean;
     }): Promise<void>;
 }
 export type CameraDeviceProxyMethodNames = MethodKeys<CameraDeviceProxyMethods>;

package/dist/src/services/config/index.d.ts

@@ -37,7 +37,6 @@ export declare class ConfigService {
     UI_PORT: number;
     UI_ELECTRON_PORT: number;
     PROXY_ROUTER_ADDRESS: string;
-    PROXY_REQ_ADDRESS: string;
     PROXY_PUB_ADDRESS: string;
     PROXY_PUBLIC_KEY: string;
     get config(): IConfig;
@@ -47,7 +46,8 @@ export declare class ConfigService {
     constructor();
     read(): void;
     writeConfig(newConfig?: IConfig): void;
-    writeGo2RtcConfig(newConfig?: Go2RtcConfig): void;
+    writeGo2RtcConfigFile(newConfig?: Go2RtcConfig): void;
+    writeGo2RtcConfigApi(newConfig?: Go2RtcConfig): Promise<void>;
     mergeGo2RtcConfig(): Promise<void>;
     private defaultConfig;
     private defaultGo2RtcConfig;

package/dist/src/services/config/types.d.ts

@@ -23,6 +23,7 @@ export interface PluginsSettings {
 }
 export interface IConfig {
     port: number;
+    insecurePort: number;
     tempFile?: string;
     ssl: IConfigSSL;
     logger: Logger;
@@ -61,8 +62,8 @@ export interface Go2RtcConfig {
     srtp: SRTP;
     rtmp: RTMP;
     webrtc: Webrtc;
-    streams: Partial<Streams>;
     ffmpeg: Ffmpeg;
+    streams?: Partial<Streams>;
     homekit?: Partial<HomeKit>;
     hass?: Partial<Hass>;
     webtorrent?: Partial<Webtorrent>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/browser",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "camera.ui browser client",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "main": "./dist/bundle.js",
@@ -31,7 +31,7 @@
     "typescript": "^5.3.3",
     "updates": "^15.1.1",
     "utf-8-validate": "^6.0.3",
-    "webpack": "^5.89.0",
+    "webpack": "^5.90.0",
     "webpack-cli": "^5.1.4"
   },
   "bugs": {