@camera.ui/browser 0.0.92 → 0.0.93

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

@@ -1,4 +1,4 @@
-import type { CoreManager as CoreManagerProxyMethods, IceServer } from '../../../../../shared/types/index.js';
+import type { CoreManagerProxyMethods, IceServer } from '../../../../../shared/types/index.js';
 import type { SocketService } from '../socket.js';
 import type { BaseLogger } from '../types.js';
 export declare class CoreManager implements CoreManagerProxyMethods {

package/dist/types/server/src/api/types/index.d.ts

@@ -1,5 +1,5 @@
+import type { AuthConfig } from '@camera.ui/common';
 import type { Readable } from 'node:stream';
-import type { AuthConfig } from '../../decoder/types.js';
 import type { CameraExtension, PLUGIN_STATUS, PluginContract, RootSchema } from '../../plugins/types.js';
 import type { LoggingLevel } from '../../services/config/types.js';
 import type { CameraExtensions, CameraZone, DBCamera, DBCamviewLayout, DBRoles, DBUser } from '../database/types.js';

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

@@ -1,9 +1,8 @@
 import { CameraDevice, CameraPrebufferInterface, CameraPTZInterface } from '@camera.ui/plugineer';
 import type { Logger } from '@camera.ui/common/logger';
 import type { Camera } from '../api/database/types.js';
-import type { MotionFrame, VideoFrame } from '../decoder/types.js';
 import type { ProxyServer } from '../nats/index.js';
-import type { CameraConfigInputSettings, CameraDelegate, CameraSource, SetValues } from './types.js';
+import type { CameraConfigInputSettings, CameraDelegate, CameraSource, MotionFrame, SetValues, VideoFrame } from './types.js';
 export declare class CameraController extends CameraDevice {
     proxy: ProxyServer;
     private motionTimeout?;

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

@@ -1,6 +1,8 @@
-import type { CameraInterface, CameraPrebufferInterface, CameraPTZInterface } from '@camera.ui/plugineer';
-import type { CameraInformation, CameraInput, CameraInputSettings, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
-import type { FrameData, FrameMetadata } from '../decoder/types.js';
+import type { CameraInterface, CameraPrebufferInterface, CameraPTZInterface, StreamingConnectionOptions } from '@camera.ui/plugineer';
+import type { Observable, ReplaySubject, Subject, Subscription } from 'rxjs';
+import type { ConnectionState, RTCSessionDescription, RtpPacket, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
+import type { Camera, CameraActivitySettings, CameraFrameWorkerSettings, CameraInformation, CameraInput, CameraInputSettings, CameraType, Point, ZoneFilter, ZoneType } from '../api/database/types.js';
+import type { DecoderFormat, FrameBuffer, FrameData, FrameImage, FrameMetadata, ImageOptions } from '../decoder/types.js';
 import type { JsonSchema, JsonSchemaForm, SchemaConfig } from '../plugins/types.js';
 export type SpawnInput = string | number;
 export interface FfmpegOptions {
@@ -212,3 +214,115 @@ export interface StorageController {
     getCameraStorage<T extends Record<string, any> = Record<string, any>>(cameraId: string): CameraStorage<T> | undefined;
     removeCameraStorage(cameraId: string): void;
 }
+export interface WeriftSession extends Subscribed {
+    readonly onCallEnded: ReplaySubject<void>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    readonly onAudioRtp: Subject<RtpPacket>;
+    readonly isUsingOpus: Promise<boolean>;
+    reservePort(bufferPorts?: number): Promise<number>;
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    transcodeReturnAudio(ffmpegOptions: {
+        ffmpegPath: string;
+        input: SpawnInput[];
+    }): Promise<void>;
+    stop(): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+    requestKeyFrame(): void;
+}
+export interface CameraDevice {
+    readonly id: string;
+    readonly nativeId: string | undefined;
+    readonly pluginId: string;
+    readonly connected: boolean;
+    readonly disabled: boolean;
+    readonly name: string;
+    readonly type: CameraType;
+    readonly info: CameraInformation;
+    readonly isCloud: boolean;
+    readonly hasLight: boolean;
+    readonly hasSiren: boolean;
+    readonly hasBinarySensor: boolean;
+    readonly hasBattery: boolean;
+    readonly hasMotionDetector: boolean;
+    readonly hasAudioDetector: boolean;
+    readonly hasObjectDetector: boolean;
+    readonly hasPtz: boolean;
+    readonly hasPrebuffer: boolean;
+    readonly activityZones: DetectionZone[];
+    readonly activitySettings: CameraActivitySettings;
+    readonly frameWorkerSettings: CameraFrameWorkerSettings;
+    readonly streamSource: CameraSource;
+    readonly snapshotSource: CameraSource | undefined;
+    readonly highResolutionSource: CameraSource | undefined;
+    readonly midResolutionSource: CameraSource | undefined;
+    readonly lowResolutionSource: CameraSource | undefined;
+    readonly ptz: CameraPTZDelegate;
+    readonly sources: CameraSource[];
+    readonly onConnected: Observable<boolean>;
+    readonly onLightSwitched: Observable<LightState>;
+    readonly onMotionDetected: Observable<MotionState>;
+    readonly onAudioDetected: Observable<AudioState>;
+    readonly onObjectDetected: Observable<ObjectState>;
+    readonly onDoorbellPressed: Observable<DoorbellState>;
+    readonly onSirenDetected: Observable<SirenState>;
+    readonly onBatteryChanged: Observable<BatteryState>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+    onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
+        newState: StateValues[T];
+        oldState: StateValues[T];
+    }>;
+    onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{
+        property: T;
+        oldData: Camera[T];
+        newData: Camera[T];
+    }>;
+    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
+    setDelegate<T extends keyof CameraDelegates>(name: T, delegate: CameraDelegates[T]): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getFrames(prebufferDuration?: number): AsyncIterableIterator<VideoFrame>;
+    getMotionFrames(): AsyncIterableIterator<MotionFrame>;
+    updateState(stateName: 'light', eventData: LightSetEvent): Promise<void>;
+    updateState(stateName: 'motion', eventData: MotionSetEvent, frame?: VideoFrame): Promise<void>;
+    updateState(stateName: 'audio', eventData: AudioSetEvent): Promise<void>;
+    updateState(stateName: 'object', eventData: ObjectSetEvent): Promise<void>;
+    updateState(stateName: 'doorbell', eventData: DoorbellSetEvent): Promise<void>;
+    updateState(stateName: 'siren', eventData: SirenSetEvent): Promise<void>;
+    updateState(stateName: 'battery', eventData: BatterySetEvent): Promise<void>;
+    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    removeCameraSource(sourceId: string): Promise<void>;
+    createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<WeriftSession>;
+}
+export interface VideoFrame {
+    readonly frameData: FrameData;
+    readonly metadata: FrameMetadata;
+    readonly inputWidth: number;
+    readonly inputHeight: number;
+    readonly inputFormat: DecoderFormat;
+    toBuffer(options?: ImageOptions): Promise<FrameBuffer>;
+    toImage(options?: ImageOptions): Promise<FrameImage>;
+    save(path: string, options?: ImageOptions): Promise<void>;
+}
+export interface MotionFrame extends VideoFrame {
+    readonly motion: MotionState;
+}
+export interface BasicPeerConnection {
+    createOffer(): Promise<RTCSessionDescription>;
+    acceptAnswer(answer: {
+        type: 'answer';
+        sdp: string;
+    }): Promise<void>;
+    addIceCandidate(candidate: Partial<WeriftRTCICECandidate>): Promise<void>;
+    onIceCandidate: Subject<WeriftRTCICECandidate>;
+    onConnectionState: Observable<ConnectionState>;
+    close(): void;
+    requestKeyFrame?: () => void;
+}
+interface Subscribed {
+    addSubscriptions(...subscriptions: Subscription[]): void;
+    addAdditionalSubscriptions(...subscriptions: Subscription[]): void;
+    unsubscribe(): void;
+    unsubscribeAdditional(): void;
+}
+export {};

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

@@ -1,5 +1,5 @@
+import type { AuthConfig } from '@camera.ui/common';
 import type { Sharp } from 'sharp';
-import type { MotionState } from '../camera/types.js';
 export type DecoderFormat = 'yuv' | 'rgb';
 export interface ImageMetadata {
     width: number;
@@ -56,23 +56,6 @@ export interface FrameImage {
     image: Sharp;
     info: ImageInformation;
 }
-export interface VideoFrame {
-    readonly frameData: FrameData;
-    readonly metadata: FrameMetadata;
-    readonly inputWidth: number;
-    readonly inputHeight: number;
-    readonly inputFormat: DecoderFormat;
-    toBuffer: (options?: ImageOptions) => Promise<FrameBuffer>;
-    toImage: (options?: ImageOptions) => Promise<FrameImage>;
-    save: (path: string, options?: ImageOptions) => Promise<void>;
-}
-export interface MotionFrame extends VideoFrame {
-    motion: MotionState;
-}
-export interface AuthConfig {
-    user: string;
-    password: string;
-}
 export interface BaseFrameWorkerConfig {
     frameWorkerId: string;
     cameraId: string;

package/dist/types/server/src/decoder/worker.d.ts

@@ -1,7 +1,7 @@
+import type { AuthConfig } from '@camera.ui/common';
 import { Subscribed } from '@camera.ui/common';
 import { PLUGIN_STATUS } from '../plugins/types.js';
 import type { CameraController } from '../camera/controller.js';
-import type { AuthConfig } from './types.js';
 export declare class FrameWorker extends Subscribed {
     readonly frameWorkerId: string;
     name: string;

package/dist/types/server/src/nats/index.d.ts

@@ -3,7 +3,7 @@ import { CameraDeviceProxy } from './proxy/cameraDevice.js';
 import { CoreManagerProxy } from './proxy/coreManager.js';
 import { DeviceManagerProxy } from './proxy/deviceManager.js';
 import { NatsServer } from './server.js';
-import type { ProxySubscription } from '@camera.ui/common';
+import type { ProxySubscription } from '@camera.ui/common/nats';
 import type { CameraStorage, StateValues } from '../camera/types.js';
 import type { MethodKeys, MethodType } from '../types.js';
 import type { CameraDeviceListenerMessagePayload, CoreManagerProxyEvents, DeviceManagerProxyEvents, PluginMap, ProxyAuth } from './types.js';

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

@@ -1,4 +1,4 @@
-import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common/messaging';
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
 import type { CameraConfigInputSettings, CameraInterfaces, SetValues } from '../../camera/types.js';
 import type { MethodKeys, MethodType } from '../../types.js';
 import type { CameraDeviceProxyMethods, RefreshedStates } from '../types.js';

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

@@ -1,7 +1,7 @@
-import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common/messaging';
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
 import type { IceServer } from '../../services/config/types.js';
-import type { CoreManager } from '../types.js';
-export declare class CoreManagerProxy implements CoreManager {
+import type { CoreManagerProxyMethods } from '../types.js';
+export declare class CoreManagerProxy implements CoreManagerProxyMethods {
     private configService;
     private pluginsService;
     private systemService;

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

@@ -1,8 +1,8 @@
-import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common/messaging';
+import type { MessageQueue, ProxyMessageStructure } from '@camera.ui/common';
 import type { Camera } from '../../api/database/types.js';
 import type { CameraConfig } from '../../camera/types.js';
-import type { DeviceManager } from '../types.js';
-export declare class DeviceManagerProxy implements DeviceManager {
+import type { DeviceManagerProxyMethods } from '../types.js';
+export declare class DeviceManagerProxy implements DeviceManagerProxyMethods {
     private camerasService;
     private pluginsService;
     private messageQueue;

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

@@ -1,7 +1,7 @@
+import type { AuthConfig } from '@camera.ui/common';
 import type { CameraDevice } from '@camera.ui/plugineer';
 import type { Camera, DBSystem, VideoStreamingMode } from '../api/database/types.js';
 import type { CameraConfig, CameraConfigInputSettings, SetValues, StateValues } from '../camera/types.js';
-import type { AuthConfig } from '../decoder/types.js';
 import type { AudioDetectionPlugin } from '../plugins/interfaces/audioDetection.js';
 import type { BasePlugin } from '../plugins/interfaces/base.js';
 import type { MotionDetectionPlugin } from '../plugins/interfaces/motionDetection.js';
@@ -42,7 +42,14 @@ export interface CameraDeviceListenerMessagePayload {
     type: 'removed' | 'updated' | 'cameraState';
     data?: any;
 }
-export interface DeviceManager {
+export 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 interface DeviceManagerProxyMethods {
     createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
     getCameraByName(cameraName: string): Promise<CameraDevice | undefined>;
     getCameraById(cameraId: string): Promise<CameraDevice | undefined>;
@@ -71,7 +78,14 @@ export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerPro
     type: K;
     data: DeviceManagerProxyEvents[K];
 }
-export interface CoreManager {
+export declare interface CoreManager extends CoreManagerProxyMethods {
+    on<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
+    once<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
+    off<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
+    removeListener<E extends keyof CoreManagerProxyEventCallbacks>(event: E, listener: CoreManagerProxyEventCallbacks[E]): this;
+    removeAllListeners<E extends keyof CoreManagerProxyEventCallbacks>(event?: E): this;
+}
+export interface CoreManagerProxyMethods {
     getFFmpegPath(): Promise<string>;
     getServerAddresses(): Promise<string[]>;
     getIceServers(): Promise<IceServer[]>;

package/dist/types/server/src/nats/utils.d.ts

@@ -1,2 +1,2 @@
-import type { AuthConfig } from '../decoder/types.js';
+import type { AuthConfig } from '@camera.ui/common';
 export declare function generateCredentials(): AuthConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/browser",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "description": "camera.ui browser client",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "module": "./dist/bundle.js",
@@ -25,7 +25,7 @@
     "prepublishOnly": "npm i --package-lock-only && npm run lint && npm run format && npm run build"
   },
   "dependencies": {
-    "lru-cache": "^11.0.0",
+    "lru-cache": "^11.0.1",
     "rxjs": "^7.8.1",
     "socket.io-client": "^4.7.5"
   },