@camera.ui/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,16 @@
+// External library re-exports
+export * from './external.js';
+// Schema definitions
+export * from './storage/schema.js';
+// Camera system
+export * from './camera/index.js';
+// Manager interfaces
+export * from './manager/index.js';
+// Plugin system
+export * from './plugin/index.js';
+// Sensor system
+export * from './sensor/index.js';
+// Service system
+export * from './service/index.js';
+// Storage system
+export * from './storage/index.js';

package/dist/manager/index.js

@@ -0,0 +1 @@
+export * from './types.js';

package/dist/manager/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin/contract.js

@@ -0,0 +1,120 @@
+import { SensorType } from '../sensor/types.js';
+/**
+ * Validate a plugin contract
+ *
+ * @param contract - The contract to validate
+ *
+ * @returns Whether the contract is valid
+ */
+export function validateContract(contract) {
+    if (!contract || typeof contract !== 'object') {
+        return false;
+    }
+    const c = contract;
+    // Required fields
+    if (!Array.isArray(c.provides))
+        return false;
+    if (!Array.isArray(c.consumes))
+        return false;
+    if (typeof c.name !== 'string' || c.name.length === 0)
+        return false;
+    // Validate sensor types
+    const validSensorTypes = Object.values(SensorType);
+    for (const type of c.provides) {
+        if (!validSensorTypes.includes(type)) {
+            return false;
+        }
+    }
+    for (const type of c.consumes) {
+        if (!validSensorTypes.includes(type)) {
+            return false;
+        }
+    }
+    // Optional fields validation
+    if (c.pythonVersion !== undefined) {
+        if (!['3.10', '3.11', '3.12'].includes(c.pythonVersion)) {
+            return false;
+        }
+    }
+    if (c.dependencies !== undefined && !Array.isArray(c.dependencies)) {
+        return false;
+    }
+    if (c.cameraController !== undefined && typeof c.cameraController !== 'boolean') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Check if a plugin is a provider (provides any sensors)
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @returns Whether the plugin is a provider
+ */
+export function isProvider(contract) {
+    return contract.provides.length > 0;
+}
+/**
+ * Check if a plugin is a consumer (consumes any sensors)
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @returns Whether the plugin is a consumer
+ */
+export function isConsumer(contract) {
+    return contract.consumes.length > 0;
+}
+/**
+ * Check if a plugin is a pure hub (only consumes, doesn't provide)
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @returns Whether the plugin is a pure hub
+ */
+export function isHub(contract) {
+    return contract.provides.length === 0 && contract.consumes.length > 0;
+}
+/**
+ * Check if a plugin provides a specific sensor type
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @param type - The sensor type to check
+ *
+ * @returns Whether the plugin provides the sensor type
+ */
+export function providesSensor(contract, type) {
+    return contract.provides.includes(type);
+}
+/**
+ * Check if a plugin consumes a specific sensor type
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @param type - The sensor type to check
+ *
+ * @returns Whether the plugin consumes the sensor type
+ */
+export function consumesSensor(contract, type) {
+    return contract.consumes.includes(type);
+}
+/**
+ * Check if a plugin is a camera controller (can create/manage cameras)
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @returns Whether the plugin is a camera controller
+ */
+export function isCameraController(contract) {
+    return contract.cameraController === true;
+}
+/**
+ * Check if a plugin is qualified (provides, consumes, or is camera controller)
+ *
+ * @param contract - The plugin contract to check
+ *
+ * @returns Whether the plugin is qualified
+ */
+export function isQualifiedContract(contract) {
+    return contract.provides.length > 0 || contract.consumes.length > 0 || contract.cameraController === true;
+}

package/dist/plugin/index.js

@@ -0,0 +1,3 @@
+export * from './contract.js';
+export * from './interfaces.js';
+export * from './types.js';

package/dist/plugin/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sensor/audio.js

@@ -0,0 +1,118 @@
+import { Sensor } from './base.js';
+import { SensorCategory, SensorType } from './types.js';
+/**
+ * Audio sensor property keys
+ */
+export var AudioProperty;
+(function (AudioProperty) {
+    AudioProperty["Detected"] = "detected";
+    AudioProperty["Detections"] = "detections";
+    AudioProperty["Decibels"] = "decibels";
+})(AudioProperty || (AudioProperty = {}));
+/**
+ * Audio Sensor
+ *
+ * Base class for external audio detection (Ring, ONVIF events, etc.)
+ * Properties can be set directly: `sensor.detected = true`
+ *
+ * For audio-stream-based detection, use `AudioDetectorSensor` instead.
+ */
+export class AudioSensor extends Sensor {
+    type = SensorType.Audio;
+    category = SensorCategory.Sensor;
+    name;
+    /**
+     * External audio sensors don't require audio frames.
+     * They receive detection events from external sources (APIs, ONVIF, etc.)
+     */
+    _requiresFrames = false;
+    constructor(name = 'Audio Sensor') {
+        super();
+        this.name = name;
+        // Initialize defaults
+        this.props.detected = false;
+        this.props.detections = [];
+        this.props.decibels = 0;
+    }
+    /** Whether audio event is currently detected */
+    get detected() {
+        return this.rawProps.detected;
+    }
+    /** Set audio detected state */
+    set detected(value) {
+        this.props.detected = value;
+    }
+    /** Current audio detections */
+    get detections() {
+        return this.rawProps.detections;
+    }
+    /** Set audio detections */
+    set detections(value) {
+        this.props.detections = value;
+    }
+    /** Current decibel level */
+    get decibels() {
+        return this.rawProps.decibels;
+    }
+    /** Set decibel level */
+    set decibels(value) {
+        this.props.decibels = value;
+    }
+    /**
+     * Update audio detection state
+     *
+     * @param detected - Whether audio event is currently detected
+     *
+     * @param detections - Array of detection events
+     *
+     * @param decibels - Current decibel level
+     */
+    setAudio(detected, detections = [], decibels) {
+        this.props.detected = detected;
+        this.props.detections = detections;
+        if (decibels !== undefined) {
+            this.props.decibels = decibels;
+        }
+    }
+    /** Clear audio detection state */
+    clearAudio() {
+        this.props.detected = false;
+        this.props.detections = [];
+        this.props.decibels = 0;
+    }
+}
+/**
+ * Audio Detector Sensor (Active Detection)
+ *
+ * Use this class for audio-based event detection (glass break, screams, etc.)
+ * The `inputProperties` getter specifies the required audio input format.
+ *
+ * @example
+ * ```typescript
+ * class GlassBreakDetector extends AudioDetectorSensor {
+ *   get inputProperties(): AudioInputProperties {
+ *     return { sampleRate: 16000, channels: 1, format: 'pcm16' };
+ *   }
+ *
+ *   async detectAudio(audio: AudioData): Promise<AudioResult> {
+ *     const events = await this.classifier.classify(audio.data);
+ *     return {
+ *       detected: events.some(e => e.label === 'glass_break'),
+ *       detections: events.map(e => ({
+ *         label: e.label,
+ *         confidence: e.score,
+ *         box: { x: 0, y: 0, width: 1, height: 1 },
+ *       })),
+ *       decibels: audio.decibels,
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export class AudioDetectorSensor extends AudioSensor {
+    /**
+     * Indicates this sensor requires audio frames for detection.
+     * Used by the backend to determine streaming requirements.
+     */
+    _requiresFrames = true;
+}