@camera.ui/browser 0.0.69 → 0.0.70

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

@@ -0,0 +1,29 @@
+import 'reflect-metadata';
+import { Plugin } from './plugin.js';
+import { PluginWorker } from './worker.js';
+import type { IPackageJson } from '../api/types/index.js';
+export declare class PluginManager {
+    private logger;
+    private api;
+    private configService;
+    plugins: Map<string, Plugin>;
+    pluginWorkers: Map<string, PluginWorker>;
+    searchPaths: Set<string>;
+    constructor();
+    static isQualifiedPluginIdentifier(pluginName: string): boolean;
+    static extractPluginScope(pluginName: string): string;
+    static extractPluginName(pluginName: string): string;
+    static transformDisplaName(pluginName: string): string;
+    static loadPackageJSON(installPath: string): IPackageJson;
+    initializeInstalledPlugins(): Promise<void>;
+    initializeInstalledPlugin(plugin: Plugin): Promise<void>;
+    loadPlugin(absolutePath: string, pluginId?: string, storagePath?: string): Promise<Plugin>;
+    removePlugin(plugin: Plugin, removeFromDb?: boolean, removeStorage?: boolean): Promise<void>;
+    startPluginChild(pluginName: string): Promise<void>;
+    stopPluginChild(pluginName: string): Promise<void>;
+    initializePlugins(): Promise<void>;
+    private loadInstalledPlugins;
+    private removeOrphanedPlugins;
+    private loadDefaultPaths;
+    private addNpmPrefixToSearchPaths;
+}

package/dist/types/server/src/plugins/node/api.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import { DeviceManager, PluginsManager, SystemManager } from './proxy/index.js';
+import { StorageController } from './storageController.js';
+import type { BasePlugin } from '../base.js';
+import type { Plugin } from '../plugin.js';
+import type { PluginConfigService } from './config.js';
+import type { PluginLogger } from './logger.js';
+export declare interface API {
+    on(event: 'finishLaunching', listener: () => void): this;
+    on(event: 'shutdown', listener: () => void): this;
+    once(event: 'finishLaunching', listener: () => void): this;
+    once(event: 'shutdown', listener: () => void): this;
+    off(event: 'finishLaunching', listener: () => void): this;
+    off(event: 'shutdown', listener: () => void): this;
+    removeListener(event: 'finishLaunching', listener: () => void): this;
+    removeListener(event: 'shutdown', listener: () => void): this;
+    removeAllListeners(event?: string): this;
+    readonly deviceManager: DeviceManager;
+    readonly pluginsManager: PluginsManager;
+    readonly systemManager: SystemManager;
+    readonly storageController: StorageController;
+    readonly configService: PluginConfigService;
+    readonly storagePath: string;
+    readonly configFile: string;
+}
+export declare class PluginAPI extends EventEmitter implements API {
+    private initialized;
+    readonly deviceManager: DeviceManager;
+    readonly pluginsManager: PluginsManager;
+    readonly systemManager: SystemManager;
+    readonly storageController: StorageController;
+    readonly configService: PluginConfigService;
+    readonly storagePath: string;
+    readonly configFile: string;
+    readonly plugin: BasePlugin;
+    constructor(plugin: Plugin, logger: PluginLogger, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+}

package/dist/types/server/src/plugins/node/cameraStorage.d.ts

@@ -0,0 +1,108 @@
+import type { PluginJsonSchema, PluginJsonSchemaForm, SchemaConfig } from '../types.js';
+import type { PluginAPI } from './api.js';
+export declare class CameraStorage {
+    private cameraId;
+    private instance;
+    private api;
+    private db;
+    private _schema;
+    private _values;
+    get values(): Record<string, any>;
+    constructor(api: PluginAPI, instance: any, cameraId: string, schema?: PluginJsonSchemaForm);
+    /**
+     * Initialize the storage.
+     * This will load the configuration from the database.
+     */
+    initializeStorage(): Promise<void>;
+    /**
+     * Get a value from the configuration by its key/path.
+     * If the schema has an onGet function, the onGet function will be called.
+     * If the onGet functions is undefined, the value from the configuration will be returned.
+     * If the schema has a default value, and the configuration value is undefined, the default value will be returned.
+     *
+     * @param path - The path to the configuration value.
+     * @returns The value from the configuration.
+     */
+    getValue<T = string>(path: string): Promise<T> | undefined;
+    getValue<T = string>(path: string, defaultValue: T): Promise<T>;
+    /**
+     * Set a new value for a given key/path in the configuration.
+     * If the schema of the value has an onSet function, and the value has changed, the onSet function will be called.
+     * If the schema of the value is declared as storable, the value will be saved to the database.
+     *
+     * @param path - The path to the configuration value.
+     * @param newValue - The new value to set.
+     */
+    setValue<T = string>(path: string, newValue: T): Promise<void>;
+    /**
+     * Check if a value exists by its config path/key.
+     *
+     * @param path - The path to the value to check.
+     * @returns True if the value exists, false otherwise.
+     */
+    hasValue(path: string): boolean;
+    /**
+     * Get the root schema and configuration.
+     * This will also call the onGet functions for the schema.
+     *
+     * @returns The root schema and configuration.
+     */
+    getConfig(): Promise<SchemaConfig>;
+    /**
+     * Set a new configuration.
+     * If the schema of a value which has been changed has an onSet function, the onSet function will be called.
+     *
+     * @param newConfig - The new configuration to set.
+     */
+    setConfig(newConfig: Record<string, any>): Promise<void>;
+    /**
+     * Add a new schema to the existing schema.
+     * It will also add the value to the configuration.
+     * If the schema is declared as storable, the value will be saved to the database.
+     *
+     * @param schema - The new schema to add.
+     * @param path - The path to the schema to add.
+     */
+    addSchema(schema: PluginJsonSchemaForm): Promise<void>;
+    addSchema(path: string, schema: PluginJsonSchema): Promise<void>;
+    /**
+     * Remove a schema by its config path/key from the existing schema.
+     * It will also remove the value from the configuration.
+     * If the schema is declared as storable, the value will be removed from the database.
+     *
+     * @param path - The path to the schema to remove.
+     */
+    removeSchema(path: string): Promise<void>;
+    /**
+     * Change a schema by its config path/key from the existing schema.
+     * It will also change the value from the configuration.
+     * If the schema is declared as storable, the value will be saved to the database.
+     *
+     * @param path - The path to the schema to change.
+     * @param schema - The new schema to set.
+     */
+    changeSchema(path: string, newSchema: Partial<PluginJsonSchema>): Promise<void>;
+    /**
+     * Get a schema by its config path/key.
+     *
+     * @param path - The path to the schema to get.
+     * @returns The schema.
+     */
+    getSchema<T>(path: string): T | undefined;
+    /**
+     * Check if a schema exists by its config path/key.
+     *
+     * @param path - The path to the schema to check.
+     * @returns True if the schema exists, false otherwise.
+     */
+    hasSchema(path: string): boolean;
+    private resolveOnGetFunctions;
+    private resolveOnGetFunctionsForObject;
+    private resolveOnGetFunctionsForSchema;
+    private triggerOnSetForChanges;
+    private filterStorableValues;
+    private containsStorableSchema;
+    private saveDb;
+    private removeDb;
+    private close;
+}

package/dist/types/server/src/plugins/node/config.d.ts

@@ -0,0 +1,104 @@
+import { type Path } from 'object-path';
+import type { JSONValue, PluginConfig } from '../types.js';
+export declare class PluginConfigService {
+    private config;
+    private configFile;
+    constructor(configFile: string);
+    /**
+     * Get key (Path) from config.json
+     *
+     * @param key - Key to lookup for
+     * @param defaultValue - Default value if `key` not exist
+     * @param validate - Validate the value of the `key` and replace with `defaultValue` if it is not valid
+     * @param refresh - Re-Read config.json before lookup for the `key`
+     * @param writeIfNotValid - Optional parameter, if true, the changes will be written to the file, if the value of the `key` is not valid and is replaced by the `defaultValue`
+     *
+     * @returns `value` for the given `key` or `defaultValue`
+     */
+    get(key: Path, defaultValue: JSONValue, validate: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
+    get(key: Path, defaultValue?: unknown, validate?: Function, refresh?: boolean, writeIfNotValid?: boolean): any;
+    /**
+     * Test key (Path) existence
+     *
+     * @param key - Key to lookup for
+     * @param refresh - Re-Read config.json before lookup for the `key`
+     */
+    has(key: Path, refresh?: boolean): boolean;
+    /**
+     * Set a value if it doesn't exist, do nothing if it does
+     *
+     * @param key - Key whose existence is to be checked
+     * @param defaultValue - Default value if `key` not exist
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    ensureExists(key: Path, defaultValue: JSONValue, write?: boolean): void;
+    /**
+     * Set a key (Path) to a value
+     *
+     * @param key - Key
+     * @param value - Value to set for they given `key`
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    set(key: Path, value: any, write?: boolean): void;
+    /**
+     * Insert an item in an array path
+     *
+     * @param key - Key to the array
+     * @param value - Value to insert in the array
+     * @param at - Index
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    insert(key: Path, value: any, at?: number, write?: boolean): void;
+    /**
+     * Create (if path isn't an array) and push the value to it. Can push unlimited number of values
+     *
+     * @param key - Key to the array
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     * @param items - Values to push in to the array
+     */
+    push(key: Path, write?: boolean, ...items: any[]): void;
+    /**
+     * Deletes a member from object or array
+     *
+     * @param key - Key to lookup for
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    delete(key: Path, write?: boolean): void;
+    /**
+     * @param refresh - Re-Read config.json
+     *
+     * @returns config.json
+     */
+    all(refresh?: boolean): PluginConfig;
+    /**
+     * @param config - New config.json
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    replace(config: PluginConfig, write?: boolean): void;
+    /**
+     * Updates a specific value in a nested object structure by a given path and key.
+     *
+     * @param path - The path to the nested object.
+     * @param searchKey - The key to search for.
+     * @param searchValue - The value to match the searchKey.
+     * @param targetKey - The key of the value to be updated.
+     * @param newValue - The new value to be set.
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    updateValue(path: string, searchKey: string, searchValue: any, targetKey: string, newValue: any, write?: boolean): void;
+    /**
+     * Replaces a specific item in a nested object structure by a given path and key.
+     * If the item does not exist, it will be added.
+     * If the path does not exist, it will be created.
+     *
+     * @param path - The path to the nested object.
+     * @param searchKey - The key to search for.
+     * @param searchValue - The value to match the searchKey.
+     * @param newItem - The new item to replace the old one. If the item does not exist, it will be added.
+     * @param write - Optional parameter, if true, the changes will be written to the file.
+     */
+    replaceOrAddItem(path: string, searchKey: string, searchValue: any, newItem: any, write?: boolean): void;
+    private init;
+    private read;
+    private write;
+}

package/dist/types/server/src/plugins/node/logger.d.ts

@@ -0,0 +1,14 @@
+export declare class PluginLogger {
+    private _prefix;
+    private _loggerPrefix;
+    private _disableTimestamps;
+    private get prefix();
+    constructor(prefix: string, disableTimestamps: boolean);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    attention(...args: any[]): void;
+    debug(...args: any[]): void;
+    trace(...args: any[]): void;
+    private formatDateTime;
+}

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

@@ -0,0 +1,44 @@
+import { CameraDevice } from '../../../camera/base/cameraDevice.js';
+import type { Camera } from '../../../api/database/types.js';
+import type { CameraSource, OnSetEvent, StateValues } from '../../../camera/types.js';
+import type { Frame } from '../../../decoder/types.js';
+import type { IceServer } from '../../../services/config/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+export declare class CameraDeviceProxy extends CameraDevice {
+    private api;
+    private initialized;
+    private publisher;
+    private client;
+    private cameraSubscriber;
+    private cameraPluginSubscriber;
+    private frameSubscriber?;
+    private activeSockets;
+    private messageQueue;
+    private auth;
+    private pluginID;
+    private pluginName;
+    private clientSubject;
+    private cameraSubscriberSubject;
+    private cameraPluginSubscriberSubject;
+    private frameSubject;
+    get sources(): CameraSource[];
+    constructor(api: PluginAPI, logger: PluginLogger, camera: Camera, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    reboot(): Promise<void>;
+    generateFrames(): AsyncIterableIterator<Frame>;
+    getFfmpegPath(): Promise<string>;
+    getIceServers(): Promise<IceServer[]>;
+    updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
+    refreshStates(): Promise<void>;
+    cleanup(): Promise<void>;
+    private connectToServer;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+}

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

@@ -0,0 +1,47 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import { CameraDeviceProxy } from './cameraDevice.js';
+import type { CameraDevice } from '../../../camera/base/cameraDevice.js';
+import type { CameraConfig } from '../../../camera/types.js';
+import type { DeviceManagerProxyEventCallbacks, DeviceManagerProxyMethods } from '../../../nats/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+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 DeviceManager {
+    private api;
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    private devices;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    getCameraById(id: string): Promise<CameraDevice | undefined>;
+    getCameraByName(name: string): Promise<CameraDevice | undefined>;
+    createCamera(cameraConfig: CameraConfig): Promise<CameraDevice>;
+    removeCameraByName(name: string): Promise<void>;
+    removeCameraById(id: string): Promise<void>;
+    emit(): boolean;
+    configureCameras(cameraDevices: CameraDeviceProxy[]): void;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private addOrGetCamera;
+    private close;
+}

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

@@ -0,0 +1,4 @@
+export * from './cameraDevice.js';
+export * from './deviceManager.js';
+export * from './pluginsManager.js';
+export * from './systemManager.js';

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

@@ -0,0 +1,38 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import type { PluginsManagerProxyEventCallbacks, PluginsManagerProxyMethods } from '../../../nats/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+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 PluginsManager {
+    private api;
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    emit(): boolean;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private isPluginMessage;
+    private isStorageMessage;
+    private close;
+}

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

@@ -0,0 +1,18 @@
+import { type NatsConnection, type Subscription } from 'nats';
+import type { BaseLogger } from '../../../camera/types.js';
+import type { ProxyMessageStructure } from '../../../nats/types.js';
+export declare class ClientMessageQueue {
+    private logger;
+    private publisher;
+    private subscriber;
+    private requestHandler;
+    private aborted;
+    private isProcessing;
+    private queue;
+    private pendingResponses;
+    constructor(logger: BaseLogger, publisher: NatsConnection, subscriber: Subscription, requestHandler: (message: ProxyMessageStructure) => void);
+    abortQueue(): void;
+    enqueue(message: ProxyMessageStructure): Promise<any>;
+    private processQueue;
+    private listenToMessages;
+}

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

@@ -0,0 +1,36 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import type { SystemManagerProxyEventCallbacks, SystemManagerProxyMethods } from '../../../nats/types.js';
+import type { PluginAPI } from '../api.js';
+import type { PluginLogger } from '../logger.js';
+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 SystemManager {
+    private api;
+    private logger;
+    private initialized;
+    private publisher;
+    private client;
+    private subscriber;
+    private messageQueue;
+    private auth;
+    private pluginId;
+    private pluginName;
+    private clientSubject;
+    private subscriberSubject;
+    constructor(api: PluginAPI, logger: PluginLogger, pluginId: string, pluginName: string, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    emit(): boolean;
+    private requestHandler;
+    private listenToMessages;
+    private onRequest;
+    private close;
+}