@camera.ui/browser 0.0.77 → 0.0.80

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

@@ -1,26 +1,40 @@
 import { BaseCameraDevice } from '../../../../../server/src/camera/index.js';
-import { StreamingSession } from '../streaming/streaming-session.js';
-import type { BaseLogger, Camera, CameraSource, IceServer, SetValues } from '../../../../../shared/types/index.js';
+import { CameraAudioDetectionInterface } from '../../../../../server/src/camera/interfaces/audioDetection.js';
+import { CameraMotionDetectionInterface } from '../../../../../server/src/camera/interfaces/motionDetection.js';
+import { CameraObjectDetectionInterface } from '../../../../../server/src/camera/interfaces/objectDetection.js';
+import { CameraPrebufferInterface } from '../../../../../server/src/camera/interfaces/prebuffer.js';
+import { CameraPTZInterface } from '../../../../../server/src/camera/interfaces/ptz.js';
+import { Go2RTCSession } from '../streaming/go2rts-session.js';
+import type { BaseLogger, Camera, CameraConfigInputSettings, CameraSource, IceServer, SetValues } from '../../../../../shared/types/index.js';
 import type { SocketService } from '../socket.js';
-import type { CameraDevice } from '../types.js';
+import type { CameraDevice, Go2RTCSessionOptions } from '../types.js';
 export declare class CameraDeviceProxy extends BaseCameraDevice implements CameraDevice {
     private socketService;
     private socket;
+    private pluginName;
+    private subject;
     private _started;
     get started(): boolean;
+    protected prebufferDelegate: CameraPrebufferInterface;
+    ptzDelegate: CameraPTZInterface;
+    audioDetectorDelegate: CameraAudioDetectionInterface;
+    motionDetectorDelegate: CameraMotionDetectionInterface;
+    objectDetectorDelegate: CameraObjectDetectionInterface;
     get sources(): CameraSource[];
     constructor(camera: Camera, socketService: SocketService, logger: BaseLogger);
-    start(): void;
+    start(): Promise<void>;
     stop(): void;
     close(): void;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    reboot(): Promise<void>;
     getIceServers(): Promise<IceServer[]>;
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
-    createSession(sourceName: string, videoElement: HTMLVideoElement): Promise<StreamingSession>;
+    createSession(options: Go2RTCSessionOptions): Go2RTCSession;
     updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T]): Promise<void>;
+    addCameraSource(source: CameraConfigInputSettings): Promise<void>;
+    updateCameraSource(sourceId: string, source: Partial<CameraConfigInputSettings>): Promise<void>;
+    removeCameraSource(sourceId: string): Promise<void>;
     refreshStates(): Promise<void>;
     cleanup(): Promise<void>;
     private listenToMessages;
+    private onRequest;
 }

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

@@ -7,9 +7,13 @@ interface DeviceManagerBrowserProxyMethods {
 }
 export declare class DeviceManager implements DeviceManagerBrowserProxyMethods {
     private socketService;
+    private socket;
     private logger;
+    private pluginName;
+    private subject;
     constructor(socketService: SocketService, logger: BaseLogger);
     getCameraById(id: string): Promise<CameraDevice | undefined>;
     getCameraByName(name: string): Promise<CameraDevice | undefined>;
+    private onRequest;
 }
 export {};

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

@@ -1,15 +1,15 @@
-import { Manager, type Socket } from 'socket.io-client';
-import type { ManagerNames, WebsocketClientRequest } from '../../../../shared/types/index.js';
+import { Manager } from 'socket.io-client';
+import type { Socket } from 'socket.io-client';
 export declare class SocketService {
-    manager: Manager;
+    socket: Socket;
     private token;
     private endpoint;
-    get socket(): Socket;
+    private socketList;
     constructor(endpoint: string, token: string);
-    createManager(): {
+    close(): void;
+    getSocket(id: string, forceNew?: boolean): {
         manager: Manager;
         socket: Socket;
     };
-    sendRequest<T extends ManagerNames>(data: WebsocketClientRequest<T>, socket?: Socket): Promise<any>;
-    close(): void;
+    private createManager;
 }

package/dist/types/packages/client/browser/src/streaming/go2rts-session.d.ts

@@ -0,0 +1,54 @@
+import type { VideoStreamingMode } from '../../../../../shared/types/index.js';
+import type { SocketService } from '../socket.js';
+import type { BaseLogger, CameraDevice, Go2RTCSessionOptions } from '../types.js';
+export declare class Go2RTCSession extends EventTarget {
+    private cameraDevice;
+    private socketService;
+    private logger;
+    private options;
+    private videoPlayer;
+    private socket;
+    private streamId;
+    closed: boolean;
+    micTransceiver: RTCRtpTransceiver | null;
+    private pc;
+    private buf;
+    private mediaSource;
+    private sourceBuffer;
+    private bufLen;
+    private mseCodecs;
+    private videoPlayerMp4?;
+    private media;
+    private codecList;
+    private reconnectTimeout?;
+    private _finishLoading;
+    get mode(): VideoStreamingMode;
+    private webrtcReconnectTimeout?;
+    constructor(cameraDevice: CameraDevice, socketService: SocketService, logger: BaseLogger, options: Go2RTCSessionOptions);
+    connect(customMode?: VideoStreamingMode): void;
+    disconnect(): void;
+    reconnect(customMode?: VideoStreamingMode): Promise<void>;
+    reset(): void;
+    close(): void;
+    private onWsOpen;
+    private onWsClose;
+    private onWsMessage;
+    private requestWebrtc;
+    private onWebrtcData;
+    private createOffer;
+    private requestMse;
+    private onMseData;
+    private onMseBuffer;
+    private requestMjpeg;
+    private onMjpegBuffer;
+    private requestMp4;
+    private onMp4Buffer;
+    private requestHls;
+    private onHlsData;
+    private play;
+    private finishLoading;
+    private createCodecsList;
+    private parseCodecs;
+    private btoaBinary;
+    private uuidv4;
+}

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

@@ -1,11 +1,9 @@
 import type { Observable, Subject } from 'rxjs';
 import type { BaseCameraDevice } from '../../../../server/src/camera/index.js';
-import type { BaseLogger } from '../../../../shared/types/index.js';
-import type { StreamingSession } from './streaming/streaming-session.js';
+import type { BaseLogger, VideoStreamingMode } from '../../../../shared/types/index.js';
+import type { Go2RTCSession } from './streaming/go2rts-session.js';
 export type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraActivitySettings, CameraSource, CameraZone, Container, Detection, DetectionZone, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, Point, PrebufferState, SirenSetEvent, SirenState, ZoneFilter, ZoneType, } from '../../../../shared/types/index.js';
-export type { BasicPeerConnection } from './streaming/peer-connection.js';
-export type { StreamingSession } from './streaming/streaming-session.js';
-export type { WebrtcConnection } from './streaming/webrtc-connection.js';
+export type { Go2RTCSession } from './streaming/go2rts-session.js';
 export type CameraUiClientConfig = WithCredentials | WithToken;
 export interface BasicBrowserPeerConnection {
     enableMicrophone(track: MediaStreamTrack): void;
@@ -22,11 +20,16 @@ export interface BasicBrowserPeerConnection {
 }
 export interface CameraDevice extends BaseCameraDevice {
     readonly started: boolean;
-    start(): void;
+    start(): Promise<void>;
     stop(): void;
     close(): void;
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
-    createSession(sourceName: string, videoElement: HTMLVideoElement): Promise<StreamingSession>;
+    createSession(options: Go2RTCSessionOptions): Go2RTCSession;
+}
+export interface Go2RTCSessionOptions {
+    sourceName: string;
+    mode: VideoStreamingMode;
+    videoElement: HTMLVideoElement;
+    reconnectInterval?: number;
 }
 interface BaseConfig {
     endpoint: string;

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

@@ -0,0 +1,12 @@
+export declare const isMobile: () => boolean;
+export declare const isAndroid: () => boolean;
+export declare const isIphone: () => boolean;
+export declare const isIpad: () => boolean;
+export declare const isAppleMobile: () => boolean;
+export declare const iosVersion: () => number[] | undefined;
+export declare const isSafari: () => boolean;
+export declare const safariVersion: () => RegExpMatchArray | null;
+export declare const isFirefox: () => boolean;
+export declare const isChrome: () => boolean;
+export declare const isTouch: () => boolean;
+export declare const uuidv4: () => string;

package/dist/types/server/src/api/controllers/users.controller.d.ts

@@ -1,15 +1,21 @@
 import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
-import type { DBUser } from '../database/types.js';
-import type { AuthLoginRequest, AuthParamsRequest, PaginationRequest, UsersInsertRequest, UsersParamsRequest, UsersPatchRequest } from '../types/index.js';
+import type { DBCamviewLayout, DBUser } from '../database/types.js';
+import type { AuthLoginRequest, AuthParamsRequest, PaginationRequest, UsersInsertRequest, UsersParamsRequest, UsersPatchRequest, ViewsInsertRequest, ViewsParamsRequest, ViewsPatchRequest } from '../types/index.js';
 export declare class UsersController {
     private app;
     private configService;
     private service;
     constructor(app: FastifyInstance);
-    getByName(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest & UsersParamsRequest>, reply: FastifyReply): FastifyReply;
     insert(req: FastifyRequest<AuthLoginRequest & UsersInsertRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    getByName(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest & UsersParamsRequest>, reply: FastifyReply): FastifyReply;
     list(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): FastifyReply | Partial<DBUser>[];
     patchByName(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest & UsersParamsRequest & UsersPatchRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
     removeByName(req: FastifyRequest<AuthLoginRequest & UsersParamsRequest>, reply: FastifyReply): Promise<FastifyReply>;
     removeAll(req: FastifyRequest<AuthLoginRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    insertView(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest & UsersParamsRequest & ViewsInsertRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    getViewById(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest & UsersParamsRequest & ViewsParamsRequest>, reply: FastifyReply): FastifyReply;
+    listViews(req: FastifyRequest<AuthLoginRequest & PaginationRequest & AuthParamsRequest & UsersParamsRequest & ViewsParamsRequest>, reply: FastifyReply): FastifyReply | Partial<DBUser>[];
+    patchViewById(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest & UsersParamsRequest & ViewsParamsRequest & ViewsPatchRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
+    removeViewById(req: FastifyRequest<AuthLoginRequest & PaginationRequest & UsersParamsRequest & ViewsParamsRequest>, reply: FastifyReply): Promise<FastifyReply | DBCamviewLayout[]>;
+    removeAllViews(req: FastifyRequest<AuthLoginRequest & PaginationRequest & AuthParamsRequest & UsersParamsRequest>, reply: FastifyReply): Promise<FastifyReply | DBCamviewLayout[]>;
 }

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

@@ -1,21 +1,28 @@
-import type { Database as DB, RootDatabase as RootDB } from 'lmdb';
 import type { FastifyInstance } from 'fastify';
+import type { Database as DB, RootDatabase as RootDB } from 'lmdb';
 import type { Plugin } from '../../plugins/plugin.js';
 import type { DBAuth, DBCamera, DBPlugin, DBSettings, DBUser } from './types.js';
 export declare class Database {
-    private db;
+    readonly CAMERAS_ID = "cameras";
+    readonly DATABASE_ID = "database";
+    readonly PLUGINS_ID = "plugins";
+    readonly USER_PLUGINS_ID = "user-plugins";
+    readonly SETTINGS_ID = "settings";
+    readonly USERS_ID = "users";
+    readonly TOKENS_ID = "tokens";
     authDB: RootDB<DBAuth, 'auth'>;
     camerasDB: DB<DBCamera[], 'cameras'>;
     pluginsDB: DB<DBPlugin[], 'plugins'>;
     settingsDB: DB<DBSettings, 'settings'>;
     usersDB: DB<DBUser[], 'users'>;
     private initialized;
+    private db;
     private app;
     private configService;
     private logger;
     constructor(app: FastifyInstance);
+    initialize(): Promise<void>;
     close(): Promise<void>;
-    initialize(): Promise<Database>;
     updateCameras(): Promise<void>;
     createPluginDatabase(plugin: Plugin): Promise<void>;
     private ensureDatabases;

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

@@ -1,5 +1,5 @@
-import type { DetectionZone, ObjectClasses } from '../../camera/types.js';
-import type { ClientData, JwtTokenEncoded } from '../types/index.js';
+import type { DetectionZone, ObjectClass } from '../../camera/types.js';
+import type { CamviewSettingsLayoutMode, ClientData, JwtTokenEncoded } from '../types/index.js';
 export interface DBAuth {
     tokens: JwtTokenEncoded[];
     clients: ClientData[];
@@ -32,16 +32,19 @@ export interface DBUser {
 export type DBRoles = 'admin' | 'user';
 export interface DBUserPreferences {
     camview: {
-        grids: DBCamviewLayout[];
+        views: DBCamviewLayout[];
     };
 }
+export type DBCamviewViewSize = 1 | 4 | 6 | 7 | 9 | 10 | 12 | 13 | 15 | 16 | 20 | 26;
 export interface DBCamviewLayout {
     readonly _id: string;
     name: string;
+    viewSize: DBCamviewViewSize;
     cameras: DBCamviewLayoutCamera[];
+    type: CamviewSettingsLayoutMode;
 }
 export interface DBCamviewLayoutCamera {
-    readonly _id: string;
+    index: number;
     name: string;
 }
 export interface DBPluginStorage {
@@ -67,6 +70,7 @@ export interface BaseCamera {
     type: CameraType;
     activityZones: CameraZone[];
     activitySettings: CameraActivitySettings;
+    frameWorkerSettings: CameraFrameWorkerSettings;
 }
 export interface Camera extends Omit<BaseCamera, 'activityZones'> {
     hasAudioDetector: boolean;
@@ -74,7 +78,6 @@ export interface Camera extends Omit<BaseCamera, 'activityZones'> {
     hasObjectDetector: boolean;
     hasPtz: boolean;
     hasPrebuffer: boolean;
-    hasIntercom: boolean;
     sources: CameraInput[];
     activityZones: DetectionZone[];
 }
@@ -100,17 +103,21 @@ export interface ZoneRegion {
     coords: ZoneCoord[];
     type: ZoneType;
     filter: ZoneFilter;
-    classes: ObjectClasses[];
+    classes: ObjectClass[];
     isPrivacyMask: boolean;
 }
 export interface ZoneCoord {
     _id: string;
     points: Point;
 }
-export type CameraPrivateProperties = '_id' | 'nativeId' | 'pluginId';
-export interface CameraPublicProperties extends Omit<Camera, CameraPrivateProperties> {
-}
 export type CameraType = 'camera' | 'doorbell';
+export type CameraFrameWorkerDecoder = 'pillow' | 'wasm';
+export type CameraFrameWorkerResolution = 640 | 480 | 320;
+export interface CameraFrameWorkerSettings {
+    decoder: CameraFrameWorkerDecoder;
+    fps: number;
+    resolution: CameraFrameWorkerResolution;
+}
 export interface CameraInformation {
     model: string;
     manufacturer: string;
@@ -125,7 +132,6 @@ export interface CameraExtensions {
     motionDetection?: string;
     audioDetection?: string;
     objectDetection?: string;
-    intercom?: string;
     ptz?: string;
     plugins: string[];
 }
@@ -139,30 +145,30 @@ export interface CameraInputSettings {
     urls: string[];
 }
 export interface Go2RtcRTSPSource {
-    single: string;
-    default: string;
-    mp4: string;
+    readonly single: string;
+    readonly default: string;
+    readonly mp4: string;
 }
 export interface Go2RtcEndpoint {
-    webrtc: string;
-    mse: string;
-    lmp4: string;
-    mmp4: string;
-    mp4: string;
-    mp4Snapshot: string;
-    jpegSnapshot: string;
-    lHlsTs: string;
-    lHlsFmp4: string;
-    mHlsFmp4: string;
-    mjpeg: string;
-    mjpegHtml: string;
+    readonly webrtc: string;
+    readonly mse: string;
+    readonly lmp4: string;
+    readonly mmp4: string;
+    readonly mp4: string;
+    readonly mp4Snapshot: string;
+    readonly jpegSnapshot: string;
+    readonly lHlsTs: string;
+    readonly lHlsFmp4: string;
+    readonly mHlsFmp4: string;
+    readonly mjpeg: string;
+    readonly mjpegHtml: string;
 }
 export interface Go2RtcFFMPEGSource {
-    aac: string;
-    opus: string;
+    readonly aac: string;
+    readonly opus: string;
 }
 export interface Go2RtcWSSource {
-    webrtc: string;
+    readonly webrtc: string;
 }
 export interface StreamUrls {
     ws: Go2RtcWSSource;
@@ -178,6 +184,6 @@ export interface CameraInput {
 }
 export type CameraRoles = 'detect' | 'record' | 'stream' | 'snapshot' | 'none';
 export interface CameraUiSettings {
-    streamingModes: VideoStreamingMode[];
+    streamingMode: VideoStreamingMode;
 }
 export type VideoStreamingMode = 'webrtc' | 'mse' | 'webrtc/tcp' | 'mjpeg' | 'hls' | 'mp4';

package/dist/types/server/src/api/go2rtc/api/config.d.ts

@@ -1,9 +1,8 @@
-import type { AxiosResponse } from 'axios';
 import type { RequestQueue } from '../queue.js';
 export declare class ConfigApi {
     private requestQueue;
     constructor(requestQueue: RequestQueue);
-    getConfig(): Promise<AxiosResponse>;
-    rewriteConfig(data: Record<string, any>): Promise<AxiosResponse>;
-    mergeConfig(data: Record<string, any>): Promise<AxiosResponse>;
+    getConfig(): Promise<any>;
+    rewriteConfig(data: Record<string, any>): Promise<void>;
+    mergeConfig(data: Record<string, any>): Promise<void>;
 }

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

@@ -1,2 +1 @@
-import { type AxiosInstance } from 'axios';
-export declare const axiosInstance: () => AxiosInstance;
+export declare const fetchInstance: () => ((url: RequestInfo, options?: RequestInit) => Promise<Response>);

package/dist/types/server/src/api/go2rtc/api/streams.d.ts

@@ -1,11 +1,10 @@
-import type { AxiosResponse } from 'axios';
 import type { RequestQueue } from '../queue.js';
-import type { SourceData, StreamData } from '../types.js';
+import type { NameData, SourceData, StreamData } from '../types.js';
 export declare class StreamsApi {
     private requestQueue;
     constructor(requestQueue: RequestQueue);
-    createStream(data: StreamData): Promise<AxiosResponse>;
-    deleteStream(data: SourceData): Promise<AxiosResponse>;
-    getStreamInfo(data: SourceData): Promise<AxiosResponse>;
-    updateStreamSource(data: StreamData): Promise<AxiosResponse>;
+    createStream(data: StreamData): Promise<void>;
+    deleteStream(data: NameData): Promise<void>;
+    getStreamInfo(data: SourceData): Promise<any>;
+    updateStreamSource(data: StreamData): Promise<void>;
 }

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

@@ -44,14 +44,17 @@ export interface OnvifSource {
 export interface ExitData {
     code: number;
 }
+export interface NameData {
+    name: string;
+}
 export interface SourceData {
     src: string;
 }
 export interface StreamData {
-    src: string;
     name: string;
+    src?: string | string[];
 }
 export interface IntercomData {
-    src: string;
+    name: string;
     dst: string;
 }

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

@@ -1,6 +1,6 @@
 export declare class Server {
-    private secureApp?;
-    private insecureApp?;
+    private app?;
+    private localApp?;
     private api;
     private logger;
     private configService;
@@ -8,17 +8,15 @@ export declare class Server {
     register(): Promise<void>;
     listen(): Promise<void>;
     close(): Promise<void>;
-    private setupSecureAppListeners;
-    private setupInsecureAppListeners;
-    private registerSecureAppPlugins;
-    private registerInsecureAppPlugins;
+    private setupListeners;
+    private registerPlugins;
     private registerRouters;
     private get corsOptions();
     private get helmetOptions();
     private get multipartOptions();
-    private get rateLimitOptions();
-    private get insecureServerOptions();
-    private get secureServerOptions();
+    private get serverOptions();
+    private get localServerOptions();
+    private qsParser;
     private get socketOptions();
     private get staticOptions();
 }

package/dist/types/server/src/api/middlewares/pagination.middleware.d.ts

@@ -1,3 +1,3 @@
-import { type AuthLoginRequest, type PaginationRequest, type PaginationResponse } from '../types/index.js';
 import type { FastifyReply, FastifyRequest } from 'fastify';
+import type { AuthLoginRequest, PaginationRequest, PaginationResponse } from '../types/index.js';
 export declare const pages: (req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply, payload: any) => Promise<PaginationResponse | void>;

package/dist/types/server/src/api/plugins/logger.plugin.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyPluginAsync } from 'fastify';
+declare module 'fastify' {
+    interface FastifyReply {
+        startTime: number;
+    }
+}
+export declare const LoggerPlugin: FastifyPluginAsync;

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

@@ -2,6 +2,5 @@ import type { FastifyInstance } from 'fastify';
 export declare class FastifyRoutes {
     private app;
     constructor(app: FastifyInstance<any, any, any, any>);
-    register(): Promise<void>;
-    registerInsecure(): Promise<void>;
+    register(local?: boolean): Promise<void>;
 }