@camera.ui/browser 0.0.94 → 0.0.95

package/dist/types/packages/common/src/utils/subscribed.d.ts

@@ -1,3 +1,4 @@
+import type { Subscribed as SubscribedInterface } from '@camera.ui/types';
 import type { Subscription } from 'rxjs';
 export declare class Subscribed {
     private readonly subscriptions;
@@ -7,3 +8,11 @@ export declare class Subscribed {
     protected unsubscribe(): void;
     protected unsubscribeAdditional(): void;
 }
+export declare class SubscribedPublic implements SubscribedInterface {
+    private readonly subscriptions;
+    private readonly additionalSubscriptions;
+    addSubscriptions(...subscriptions: Subscription[]): void;
+    addAdditionalSubscriptions(...subscriptions: Subscription[]): void;
+    unsubscribe(): void;
+    unsubscribeAdditional(): void;
+}

package/dist/types/packages/plugineer/src/polyglot/node/camera/index.d.ts

@@ -1,10 +1,10 @@
 import { Subscribed } from '@camera.ui/common/utils';
 import { LRUCache } from 'lru-cache';
 import { BehaviorSubject } from 'rxjs';
-import type { AudioSetEvent, AudioState, BatterySetEvent, BatteryState, Camera, CameraActivitySettings, CameraDelegate, CameraFrameWorkerSettings, CameraInformation, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, CameraType, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, PluginLogger as Logger, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SetValues, SirenSetEvent, SirenState, StateValues } from '@camera.ui/types';
+import type { AudioSetEvent, AudioState, BatterySetEvent, BatteryState, Camera, CameraActivitySettings, CameraDelegate, CameraFrameWorkerSettings, CameraInformation, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, CameraType, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, LoggerService, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SetValues, SirenSetEvent, SirenState, StateValues } from '@camera.ui/types';
 import type { Observable } from 'rxjs';
 export declare abstract class BaseCameraDevice extends Subscribed {
-    protected logger: Logger;
+    protected logger: LoggerService;
     protected snapshotCache: LRUCache<string, ArrayBuffer, unknown>;
     protected cameraSubject: BehaviorSubject<Camera>;
     protected cameraState: BehaviorSubject<boolean>;
@@ -55,7 +55,8 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     get lowResolutionSource(): CameraSource | undefined;
     get ptz(): CameraPTZDelegate;
     abstract get sources(): CameraSource[];
-    constructor(camera: Camera, logger: Logger);
+    abstract get internalSources(): CameraSource[];
+    constructor(camera: Camera, logger: LoggerService);
     protected abstract cleanup(): void;
     getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
     snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;

package/dist/types/packages/plugineer/src/polyglot/node/camera/interfaces/prebuffer.d.ts

@@ -1,9 +1,8 @@
-import type { CameraPrebufferDelegate, Container, PrebufferState, StreamInfo } from '@camera.ui/types';
+import type { CameraPrebufferDelegate, Container, PrebufferState } from '@camera.ui/types';
 export declare class CameraPrebufferInterface implements CameraPrebufferDelegate {
     delegate?: CameraPrebufferDelegate;
     private onRequest;
     constructor(onRequest: (client: any, fn: string, args?: any[], timeout?: number) => Promise<any>);
-    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
     getPrebufferingState(sourceName: string, container: Container): Promise<PrebufferState | undefined>;
     private _onRequest;
 }

package/dist/types/packages/plugineer/src/polyglot/node/camera/types.d.ts

@@ -0,0 +1,15 @@
+import type { AudioSetEvent, AudioState, BatterySetEvent, BatteryState, DoorbellSetEvent, DoorbellState, FrameData, FrameMetadata, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SirenSetEvent, SirenState } from '@camera.ui/types';
+import type { CameraInterface } from './interfaces/camera.js';
+import type { CameraPrebufferInterface } from './interfaces/prebuffer.js';
+import type { CameraPTZInterface } from './interfaces/ptz.js';
+export interface FrameState extends MotionState {
+    frameData: FrameData;
+    metadata: FrameMetadata;
+}
+export type States = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
+export type Sets = LightSetEvent | MotionSetEvent | AudioSetEvent | ObjectSetEvent | DoorbellSetEvent | SirenSetEvent | BatterySetEvent;
+export interface CameraInterfaces {
+    readonly cameraDelegate: CameraInterface;
+    readonly prebufferDelegate: CameraPrebufferInterface;
+    readonly ptzDelegate: CameraPTZInterface;
+}

package/dist/types/packages/plugineer/src/polyglot/node/plugins/types.d.ts

@@ -0,0 +1,136 @@
+import type { Camera, CameraConfigInputSettings, CameraDevice, CameraExtension, ProbeStream, SetValues, StateValues } from '@camera.ui/types';
+export interface ProcessLoadMessage {
+    cameras: Camera[];
+    plugin: PluginInfo;
+    storage: PluginStorage;
+}
+export interface ProcessMessage {
+    type: PLUGIN_COMMAND;
+    data?: ProcessLoadMessage;
+}
+export interface ProcessResponse {
+    type: PLUGIN_STATUS;
+    data?: ProcessErrorMessage;
+}
+export declare enum API_EVENT {
+    FINISH_LAUNCHING = "finishLaunching",
+    SHUTDOWN = "shutdown"
+}
+export declare enum PLUGIN_STATUS {
+    READY = "ready",
+    STARTING = "starting",
+    STARTED = "started",
+    STOPPED = "stopped",
+    ERROR = "error",
+    UNKNOWN = "unknown",
+    DISABLED = "disabled"
+}
+export declare enum PLUGIN_COMMAND {
+    START = "start",
+    STOP = "stop"
+}
+export type ProcessErrorMessage = string;
+export interface PluginStorage {
+    installPath: string;
+    storagePath: string;
+    configFile: string;
+}
+export interface PluginInfo {
+    id: string;
+    name: string;
+    contract: PluginContract;
+}
+export type ExtensionOrSupport = {
+    extension: CameraExtension;
+    supportAdditionalCameras?: never;
+} | {
+    extension?: never;
+    supportAdditionalCameras?: boolean;
+};
+export interface PluginContractBase {
+    builtIns?: CameraExtensionWithoutHub[];
+    dependencies?: string[];
+    pythonVersion?: string;
+}
+export type PluginContract = PluginContractBase & ExtensionOrSupport;
+export type CameraExtensionWithoutHub = 'prebuffer' | 'motionDetection' | 'objectDetection' | 'audioDetection' | 'ptz';
+export type Go2RtcIncomingMessage = Go2RtcAnswerMessage | Go2RtcIceCandidateMessage | ErrorMessage;
+export type Go2RtcOutgoingMessage = Go2RtcOfferMessage | Go2RtcIceCandidateMessage;
+export interface Go2RtcOfferMessage {
+    type: 'webrtc/offer';
+    value: Sdp;
+}
+export interface Go2RtcAnswerMessage {
+    type: 'webrtc/answer';
+    value: Sdp;
+}
+export interface Go2RtcIceCandidateMessage {
+    type: 'webrtc/candidate';
+    value: IceCandiate;
+}
+export type Sdp = string;
+export type IceCandiate = string;
+export interface ErrorMessage {
+    type: 'error';
+    value: string;
+}
+export interface DeviceManagerListenerMessagePayload {
+    type: keyof DeviceManagerProxyEventCallbacks;
+    data: DeviceManagerProxyEvents[keyof DeviceManagerProxyEvents];
+}
+export interface DeviceManagerProxyEvents {
+    cameraSelected: {
+        camera: Camera;
+        extension: CameraExtension;
+    };
+    cameraDeselected: {
+        camera: Camera;
+        extension: CameraExtension;
+    };
+}
+export interface DeviceManagerProxyEventCallbacks {
+    cameraSelected: (camera: CameraDevice, extension: CameraExtension) => void;
+    cameraDeselected: (cameraId: string, extension: CameraExtension) => void;
+}
+export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerProxyEvents> {
+    type: K;
+    data: DeviceManagerProxyEvents[K];
+}
+export interface CoreManagerListenerMessagePayload {
+    type: keyof CoreManagerProxyEventCallbacks;
+    data: CoreManagerProxyEvents[keyof CoreManagerProxyEvents];
+}
+export interface CoreManagerProxyEvents {
+}
+export interface CoreManagerProxyEventCallbacks {
+}
+export interface CoreManagerProxyGenericEvent<K extends keyof CoreManagerProxyEvents> {
+    type: K;
+    data: CoreManagerProxyEvents[K];
+}
+export interface RefreshedStates {
+    camera: Camera;
+    states: StateValues;
+    cameraState: boolean;
+}
+export interface CameraDeviceProxyMethods {
+    connect(): void;
+    disconnect(): void;
+    updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T]): void;
+    refreshStates(): RefreshedStates;
+    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    removeCameraSource(sourceId: string): Promise<void>;
+    probeStream(sourceId: string): Promise<ProbeStream | undefined>;
+}
+export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
+    stateName: K;
+    data: {
+        newEvent: StateValues[K];
+        oldEvent: StateValues[K];
+    };
+}
+export interface CameraDeviceListenerMessagePayload {
+    type: 'removed' | 'updated' | 'cameraState';
+    data?: any;
+}

package/dist/types/packages/plugineer/src/types.d.ts

@@ -0,0 +1,4 @@
+export type MethodKeys<T> = keyof {
+    [K in keyof T as T[K] extends (...args: any) => any ? K : never]: any;
+};
+export type MethodType<T, K extends keyof T> = T[K] extends (...args: any) => any ? T[K] : never;

package/dist/types/packages/{common/src/messaging/index.d.ts → plugineer/src/utils/messageQueue.d.ts}

@@ -1,5 +1,5 @@
-import type { CameraDelegates, PluginLogger } from '@camera.ui/types';
-import type { ProxyConnection, ProxySubscription } from '../nats/index.js';
+import type { CameraDelegates, LoggerService } from '@camera.ui/types';
+import type { ProxyConnection, ProxySubscription } from './nats.js';
 export declare const NATS_SERVER_SUBJECT = "camera.ui-server";
 export interface DeserializedError {
     name: string;
@@ -40,7 +40,7 @@ export declare class MessageQueue {
     private isProcessing;
     private queue;
     private pendingResponses;
-    constructor(type: 'server' | 'client', publisher: ProxyConnection, subscriber: ProxySubscription, logger: PluginLogger, requestHandler: (message: ProxyMessageStructure) => void);
+    constructor(type: 'server' | 'client', publisher: ProxyConnection, subscriber: ProxySubscription, logger: LoggerService, requestHandler: (message: ProxyMessageStructure) => void);
     abortQueue(): void;
     enqueue(message: ProxyMessageStructure): Promise<any>;
     private processQueue;