@camera.ui/sdk 0.0.3 → 0.0.5

package/dist/sensor/occupancy.js

@@ -0,0 +1,52 @@
+import { Sensor, SensorType, SensorCategory } from './base.js';
+/**
+ * Properties for occupancy sensors
+ *
+ * @internal
+ */
+export var OccupancyProperty;
+(function (OccupancyProperty) {
+    /** Whether occupancy is detected (true = occupied) */
+    OccupancyProperty["Detected"] = "detected";
+})(OccupancyProperty || (OccupancyProperty = {}));
+/** Occupancy sensor for detecting presence in a room or area */
+export class OccupancySensor extends Sensor {
+    type = SensorType.Occupancy;
+    category = SensorCategory.Sensor;
+    constructor(name = 'Occupancy Sensor') {
+        super(name);
+        this._writeState({ [OccupancyProperty.Detected]: false });
+    }
+    get detected() {
+        return this.props.detected;
+    }
+    /**
+     * Report occupancy state.
+     *
+     * @param value - True when the area is currently occupied.
+     *
+     * @example
+     * ```ts
+     * occupancy.setDetected(true);
+     * ```
+     */
+    setDetected(value) {
+        this._writeState({ [OccupancyProperty.Detected]: value });
+    }
+    /**
+     * Read-only sensor: external writes are ignored. State is reported via `setDetected`.
+     *
+     * Called by the cross-process plugin host when a generic property write is received.
+     * Occupancy sensors have no externally writable properties, so the parameters are
+     * unused (underscore-prefixed) and the call is a no-op.
+     *
+     * @param _property - Unused — occupancy sensors expose no writable properties.
+     *
+     * @param _value - Unused — occupancy sensors expose no writable properties.
+     *
+     * @internal
+     */
+    updateValue(_property, _value) {
+        // No-op — occupancy state is reported by the plugin, not set externally.
+    }
+}

package/dist/sensor/ptz.js

@@ -1,159 +1,173 @@
-import { Sensor } from './base.js';
-import { SensorCategory, SensorType } from './types.js';
-/**
- * PTZ Capability enum
- * Describes what PTZ features this sensor supports
- */
+import { Sensor, SensorType, SensorCategory } from './base.js';
+/** Optional capabilities for PTZ controls. Add to `capabilities` to enable features. */
 export var PTZCapability;
 (function (PTZCapability) {
-    /** Supports horizontal panning */
     PTZCapability["Pan"] = "pan";
-    /** Supports vertical tilting */
     PTZCapability["Tilt"] = "tilt";
-    /** Supports zoom in/out */
     PTZCapability["Zoom"] = "zoom";
-    /** Supports preset positions */
+    /** Camera supports named position presets */
     PTZCapability["Presets"] = "presets";
-    /** Supports home position */
+    /** Camera supports a home position */
     PTZCapability["Home"] = "home";
 })(PTZCapability || (PTZCapability = {}));
 /**
- * PTZ control property keys
+ * Properties for PTZ controls
+ *
+ * @internal
  */
 export var PTZProperty;
 (function (PTZProperty) {
+    /** Current pan/tilt/zoom position */
     PTZProperty["Position"] = "position";
+    /** Whether the camera is currently moving */
     PTZProperty["Moving"] = "moving";
+    /** List of available preset names */
     PTZProperty["Presets"] = "presets";
+    /** Current movement velocity (continuous move) */
     PTZProperty["Velocity"] = "velocity";
+    /** Target preset to move to */
     PTZProperty["TargetPreset"] = "targetPreset";
 })(PTZProperty || (PTZProperty = {}));
 /**
- * PTZ Control
- *
- * Bidirectional control for camera pan/tilt/zoom.
- *
- * @example
- * ```typescript
- * // Move to absolute position
- * ptz.position = { pan: 45, tilt: -10, zoom: 0.5 };
- *
- * // Continuous move
- * ptz.continuousMove({ panSpeed: 1, tiltSpeed: 0, zoomSpeed: 0 });
- *
- * // Stop all movement
- * ptz.stop();
- *
- * // Go to preset
- * ptz.goToPreset('Entrance');
+ * Pan-tilt-zoom camera control. Override `setPosition()` / `setVelocity()` /
+ * `setTargetPreset()` to drive hardware, then call the corresponding `super.X()`
+ * method after success to sync the SDK state. For hardware-pushed state updates
+ * (e.g. PTZ position change events), call the `super` methods from your event
+ * handler — that bypasses any plugin override and only syncs state.
  *
- * // Go to home position
- * ptz.goHome();
- * ```
+ * Set `capabilities` to advertise supported axes and features. Use `setPresets()`
+ * to publish the discovered preset list and `setMoving()` to publish movement state.
  */
 export class PTZControl extends Sensor {
     type = SensorType.PTZ;
     category = SensorCategory.Control;
-    name;
-    /**
-     * Create a new PTZ control sensor.
-     *
-     * @param name - Human-readable name for this sensor
-     */
     constructor(name = 'PTZ') {
-        super();
-        this.name = name;
-        // Initialize defaults
-        this.props.position = { pan: 0, tilt: 0, zoom: 0 };
-        this.props.moving = false;
-        this.props.presets = [];
+        super(name);
+        this._writeState({
+            [PTZProperty.Position]: { pan: 0, tilt: 0, zoom: 0 },
+            [PTZProperty.Moving]: false,
+            [PTZProperty.Presets]: [],
+        });
     }
-    /** Current PTZ position */
     get position() {
-        return this.rawProps.position;
-    }
-    /** Set PTZ position (absolute move) */
-    set position(value) {
-        this.props.position = value;
+        return this.props.position;
     }
-    /** Whether PTZ is currently moving */
     get moving() {
-        return this.rawProps.moving;
+        return this.props.moving;
     }
-    /** Set moving state */
-    set moving(value) {
-        this.props.moving = value;
-    }
-    /** Available presets */
     get presets() {
-        return this.rawProps.presets;
-    }
-    /** Set available presets */
-    set presets(value) {
-        this.props.presets = value;
+        return this.props.presets;
     }
-    /** Current velocity (for continuous move) */
     get velocity() {
-        return this.rawProps.velocity;
-    }
-    /** Set velocity for continuous move */
-    set velocity(value) {
-        this.props.velocity = value;
+        return this.props.velocity;
     }
-    /** Target preset to go to */
     get targetPreset() {
-        return this.rawProps.targetPreset;
+        return this.props.targetPreset;
     }
-    /** Set target preset */
-    set targetPreset(value) {
-        this.props.targetPreset = value;
-    }
-    /** Go to home position (pan: 0, tilt: 0, zoom: 0) */
-    goHome() {
-        this.props.position = { pan: 0, tilt: 0, zoom: 0 };
+    /**
+     * Move to an absolute pan/tilt/zoom position. Override to drive hardware and
+     * call `await super.setPosition(value)` after success to sync the SDK state.
+     *
+     * @param value - Absolute pan/tilt/zoom target position.
+     *
+     * @example
+     * ```ts
+     * await ptz.setPosition({ pan: 0.25, tilt: -0.1, zoom: 0.5 });
+     * ```
+     */
+    async setPosition(value) {
+        this._writeState({ [PTZProperty.Position]: value });
     }
     /**
-     * Pan to specific angle
+     * Continuous-move command. Override to drive hardware and call
+     * `await super.setVelocity(value)` after success to sync the SDK state.
+     *
+     * @param value - Per-axis speeds in `[-1, 1]`, or `undefined` to stop.
      *
-     * @param angle - Pan angle in degrees
+     * @example
+     * ```ts
+     * await ptz.setVelocity({ panSpeed: 0.5, tiltSpeed: 0, zoomSpeed: 0 });
+     * await ptz.setVelocity(undefined); // stop
+     * ```
      */
-    pan(angle) {
-        this.props.position = { ...this.position, pan: angle };
+    async setVelocity(value) {
+        this._writeState({ [PTZProperty.Velocity]: value });
     }
     /**
-     * Tilt to specific angle
+     * Preset-move command. Override to drive hardware and call
+     * `await super.setTargetPreset(value)` after success to sync the SDK state.
+     *
+     * @param value - Preset name to move to, or `undefined` to clear.
      *
-     * @param angle - Tilt angle in degrees
+     * @example
+     * ```ts
+     * await ptz.setTargetPreset('Driveway');
+     * ```
      */
-    tilt(angle) {
-        this.props.position = { ...this.position, tilt: angle };
+    async setTargetPreset(value) {
+        this._writeState({ [PTZProperty.TargetPreset]: value });
     }
     /**
-     * Zoom to specific level (0-1)
+     * Publish the discovered preset list (typically called once at startup).
      *
-     * @param level - Zoom level between 0 and 1
+     * @param value - List of preset names supported by the camera.
+     *
+     * @example
+     * ```ts
+     * ptz.setPresets(['Home', 'Driveway', 'Backyard']);
+     * ```
      */
-    zoom(level) {
-        this.props.position = { ...this.position, zoom: Math.max(0, Math.min(1, level)) };
+    setPresets(value) {
+        this._writeState({ [PTZProperty.Presets]: value });
     }
     /**
-     * Start continuous movement
+     * Publish movement state (e.g. when continuous-move starts/stops).
+     *
+     * @param value - True while the camera is moving.
      *
-     * @param velocity - Movement speed for each axis (-1 to 1)
+     * @example
+     * ```ts
+     * ptz.setMoving(true);
+     * ```
      */
-    continuousMove(velocity) {
-        this.props.velocity = velocity;
+    setMoving(value) {
+        this._writeState({ [PTZProperty.Moving]: value });
     }
-    /** Stop all movement */
-    stop() {
-        this.props.velocity = { panSpeed: 0, tiltSpeed: 0, zoomSpeed: 0 };
+    /**
+     * Move the camera to the home position (pan=0, tilt=0, zoom=0).
+     *
+     * @example
+     * ```ts
+     * await ptz.goHome();
+     * ```
+     */
+    async goHome() {
+        await this.setPosition({ pan: 0, tilt: 0, zoom: 0 });
     }
     /**
-     * Go to a saved preset
+     * Cross-process consumer entry point. Dispatches writable properties
+     * to semantic methods so plugin overrides (hardware actions) are honored.
+     * `moving` and `presets` are observed/discovered state and not externally writable;
+     * only `Position`, `Velocity`, and `TargetPreset` may be set.
+     *
+     * @param property - Property name to write.
+     *
+     * @param value - New value for the property.
      *
-     * @param preset - Preset name
+     * @internal
      */
-    goToPreset(preset) {
-        this.props.targetPreset = preset;
+    async updateValue(property, value) {
+        switch (property) {
+            case PTZProperty.Position:
+                await this.setPosition(value);
+                return;
+            case PTZProperty.Velocity:
+                await this.setVelocity(value);
+                return;
+            case PTZProperty.TargetPreset:
+                await this.setTargetPreset(value);
+                return;
+        }
+        // Unknown / non-writable property (incl. moving, presets) — ignored.
     }
 }

package/dist/sensor/securitySystem.js

@@ -0,0 +1,98 @@
+import { Sensor, SensorType, SensorCategory } from './base.js';
+/** Security system arm/disarm states (HomeKit-compatible values) */
+export var SecuritySystemState;
+(function (SecuritySystemState) {
+    SecuritySystemState[SecuritySystemState["StayArm"] = 0] = "StayArm";
+    SecuritySystemState[SecuritySystemState["AwayArm"] = 1] = "AwayArm";
+    SecuritySystemState[SecuritySystemState["NightArm"] = 2] = "NightArm";
+    SecuritySystemState[SecuritySystemState["Disarmed"] = 3] = "Disarmed";
+    SecuritySystemState[SecuritySystemState["AlarmTriggered"] = 4] = "AlarmTriggered";
+})(SecuritySystemState || (SecuritySystemState = {}));
+/**
+ * Properties for security system controls
+ *
+ * @internal
+ */
+export var SecuritySystemProperty;
+(function (SecuritySystemProperty) {
+    /** The actual current state of the security system */
+    SecuritySystemProperty["CurrentState"] = "currentState";
+    /** The desired target state (set by user, transitions to currentState) */
+    SecuritySystemProperty["TargetState"] = "targetState";
+})(SecuritySystemProperty || (SecuritySystemProperty = {}));
+/**
+ * Security system control. Override `setTargetState()` to drive hardware and call
+ * `await super.setTargetState(value)` once the hardware confirms — the base
+ * implementation updates both `targetState` and `currentState`.
+ */
+export class SecuritySystem extends Sensor {
+    type = SensorType.SecuritySystem;
+    category = SensorCategory.Control;
+    constructor(name = 'Security System') {
+        super(name);
+        this._writeState({
+            [SecuritySystemProperty.CurrentState]: SecuritySystemState.Disarmed,
+            [SecuritySystemProperty.TargetState]: SecuritySystemState.Disarmed,
+        });
+    }
+    get currentState() {
+        return this.props.currentState;
+    }
+    get targetState() {
+        return this.props.targetState;
+    }
+    /**
+     * Set the target state. Override to drive hardware and call
+     * `await super.setTargetState(value)` after success — the base implementation
+     * syncs both `targetState` and `currentState` to the new value.
+     *
+     * @param value - Desired armed/disarmed state from {@link SecuritySystemState}.
+     *
+     * @example
+     * ```ts
+     * import { SecuritySystemState } from '@camera.ui/sdk';
+     * await alarm.setTargetState(SecuritySystemState.AwayArm);
+     * ```
+     */
+    async setTargetState(value) {
+        this._writeState({
+            [SecuritySystemProperty.TargetState]: value,
+            [SecuritySystemProperty.CurrentState]: value,
+        });
+    }
+    /**
+     * Publish the actual security system state. Use this to drive transitions
+     * that diverge from the user-requested target — most notably the
+     * `AlarmTriggered` state when an intruder is detected, or arming-delay
+     * intermediate states. Read-only from cross-process consumers
+     * (`updateValue` ignores it).
+     *
+     * @param value - Current security system state from {@link SecuritySystemState}.
+     *
+     * @example
+     * ```ts
+     * import { SecuritySystemState } from '@camera.ui/sdk';
+     * alarm.setCurrentState(SecuritySystemState.AlarmTriggered);
+     * ```
+     */
+    setCurrentState(value) {
+        this._writeState({ [SecuritySystemProperty.CurrentState]: value });
+    }
+    /**
+     * Cross-process consumer entry point. Dispatches writable properties
+     * to semantic methods so plugin overrides (hardware actions) are honored.
+     * `currentState` is observed-only and not externally writable; only `targetState` may be set.
+     *
+     * @param property - Property name to write.
+     *
+     * @param value - New value for the property.
+     *
+     * @internal
+     */
+    async updateValue(property, value) {
+        if (property === SecuritySystemProperty.TargetState) {
+            await this.setTargetState(value);
+        }
+        // Unknown / non-writable property (incl. currentState) — ignored.
+    }
+}

package/dist/sensor/siren.js

@@ -1,73 +1,105 @@
-import { Sensor } from './base.js';
-import { SensorCategory, SensorType } from './types.js';
-/**
- * Siren Capability enum
- * Describes what Siren features this sensor supports
- */
+import { Sensor, SensorType, SensorCategory } from './base.js';
+/** Optional capabilities for siren controls */
 export var SirenCapability;
 (function (SirenCapability) {
-    /** Supports volume control */
+    /** Siren supports volume adjustment (0–100) */
     SirenCapability["Volume"] = "volume";
-    /** Supports different siren modes */
-    SirenCapability["Modes"] = "modes";
 })(SirenCapability || (SirenCapability = {}));
 /**
- * Siren control property keys
+ * Properties for siren controls
+ *
+ * @internal
  */
 export var SirenProperty;
 (function (SirenProperty) {
+    /** Whether the siren is currently active */
     SirenProperty["Active"] = "active";
+    /** Volume level (0–100) */
     SirenProperty["Volume"] = "volume";
 })(SirenProperty || (SirenProperty = {}));
 /**
- * Siren Control
- *
- * Bidirectional control for camera siren/alarm.
- * Properties can be set directly: `siren.active = true`
+ * Siren control sensor. Override `setActive()`/`setInactive()` to drive your
+ * hardware, then `await super.setActive()` / `await super.setInactive()` to sync
+ * the SDK state. For hardware-pushed updates, call the `super` methods from your
+ * event handler — that bypasses any plugin override and only syncs state.
  */
 export class SirenControl extends Sensor {
     type = SensorType.Siren;
     category = SensorCategory.Control;
-    name;
     constructor(name = 'Siren') {
-        super();
-        this.name = name;
-        // Initialize defaults
-        this.props.active = false;
-        this.props.volume = 100;
+        super(name);
+        this._writeState({
+            [SirenProperty.Active]: false,
+            [SirenProperty.Volume]: 100,
+        });
     }
-    /** Whether siren is active */
     get active() {
-        return this.rawProps.active;
-    }
-    /** Activate/deactivate siren */
-    set active(value) {
-        this.props.active = value;
+        return this.props.active;
     }
-    /** Volume level (0-100) */
     get volume() {
-        return this.rawProps.volume;
+        return this.props.volume;
     }
-    /** Set volume level (0-100) */
-    set volume(value) {
-        this.props.volume = Math.max(0, Math.min(100, value));
+    /**
+     * Activate the siren. Override to drive hardware and call `await super.setActive()`
+     * after success to sync the SDK state.
+     *
+     * @example
+     * ```ts
+     * await siren.setActive();
+     * ```
+     */
+    async setActive() {
+        this._writeState({ [SirenProperty.Active]: true });
     }
-    /** Activate siren */
-    activate() {
-        this.props.active = true;
+    /**
+     * Deactivate the siren. Override to drive hardware and call `await super.setInactive()`
+     * after success to sync the SDK state.
+     *
+     * @example
+     * ```ts
+     * await siren.setInactive();
+     * ```
+     */
+    async setInactive() {
+        this._writeState({ [SirenProperty.Active]: false });
     }
-    /** Deactivate siren */
-    deactivate() {
-        this.props.active = false;
+    /**
+     * Set volume. Override to drive hardware and call `await super.setVolume(value)`
+     * after success. The default implementation clamps the value to [0, 100].
+     *
+     * @param value - Volume level in the range 0–100.
+     *
+     * @example
+     * ```ts
+     * await siren.setVolume(80);
+     * ```
+     */
+    async setVolume(value) {
+        this._writeState({ [SirenProperty.Volume]: Math.max(0, Math.min(100, value)) });
     }
     /**
-     * Sound siren for a duration
+     * Cross-process consumer entry point. Dispatches writable properties
+     * to semantic methods so plugin overrides (hardware actions) are honored.
+     * Unknown properties are ignored — only `Active` and `Volume` are externally writable.
+     *
+     * @param property - Property name to write.
+     *
+     * @param value - New value for the property.
      *
-     * @param durationMs - Duration to sound siren in milliseconds
+     * @internal
      */
-    async soundFor(durationMs) {
-        this.activate();
-        await new Promise((resolve) => setTimeout(resolve, durationMs));
-        this.deactivate();
+    async updateValue(property, value) {
+        switch (property) {
+            case SirenProperty.Active:
+                if (value)
+                    await this.setActive();
+                else
+                    await this.setInactive();
+                return;
+            case SirenProperty.Volume:
+                await this.setVolume(value);
+                return;
+        }
+        // Unknown / non-writable property — ignored.
     }
 }

package/dist/sensor/smoke.js

@@ -0,0 +1,52 @@
+import { Sensor, SensorType, SensorCategory } from './base.js';
+/**
+ * Properties for smoke sensors
+ *
+ * @internal
+ */
+export var SmokeProperty;
+(function (SmokeProperty) {
+    /** Whether smoke is detected */
+    SmokeProperty["Detected"] = "detected";
+})(SmokeProperty || (SmokeProperty = {}));
+/** Smoke detector sensor */
+export class SmokeSensor extends Sensor {
+    type = SensorType.Smoke;
+    category = SensorCategory.Sensor;
+    constructor(name = 'Smoke Sensor') {
+        super(name);
+        this._writeState({ [SmokeProperty.Detected]: false });
+    }
+    get detected() {
+        return this.props.detected;
+    }
+    /**
+     * Report smoke detection state.
+     *
+     * @param value - True when smoke is currently detected.
+     *
+     * @example
+     * ```ts
+     * smoke.setDetected(true);
+     * ```
+     */
+    setDetected(value) {
+        this._writeState({ [SmokeProperty.Detected]: value });
+    }
+    /**
+     * Read-only sensor: external writes are ignored. State is reported via `setDetected`.
+     *
+     * Called by the cross-process plugin host when a generic property write is received.
+     * Smoke sensors have no externally writable properties, so the parameters are
+     * unused (underscore-prefixed) and the call is a no-op.
+     *
+     * @param _property - Unused — smoke sensors expose no writable properties.
+     *
+     * @param _value - Unused — smoke sensors expose no writable properties.
+     *
+     * @internal
+     */
+    updateValue(_property, _value) {
+        // No-op — smoke state is reported by the plugin, not set externally.
+    }
+}

package/dist/sensor/spec.js

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