@camera.ui/sdk 0.0.2 → 0.0.4

package/dist/internal/index.js

@@ -0,0 +1,9 @@
+export * from './contract-validators.js';
+export * from './manager-rpc.js';
+export * from './shared-utils.js';
+export * from './sensor-rpc.js';
+export * from './camera-wire.js';
+export * from './sensor-triggers.js';
+export * from './streaming-internal.js';
+export * from './camera-enums.js';
+export * from './camera-config-internal.js';

package/dist/internal/sensor-triggers.js

@@ -0,0 +1,2 @@
+/** Sensor trigger types — the subset of trigger types that originate from configurable sensors (excludes motion/audio). */
+export const SENSOR_TRIGGER_TYPES = ['contact', 'doorbell', 'switch', 'light', 'siren', 'security_system'];

package/dist/internal/shared-utils.js

@@ -0,0 +1,86 @@
+/**
+ * Deep equality check for arbitrary values.
+ *
+ * Recursively compares primitives, arrays, and plain objects. Object
+ * comparison ignores property declaration order (only key/value pairs
+ * matter). Set `ignoreOrder` to `true` to compare arrays as multisets,
+ * i.e. ignoring element order.
+ *
+ * Typically used for property-change detection on sensors: a property
+ * update is only emitted when the new value is not deeply equal to the
+ * previous value, which avoids redundant events for unchanged data.
+ *
+ * @param first - First value to compare.
+ *
+ * @param second - Second value to compare.
+ *
+ * @param ignoreOrder - If `true`, arrays are compared ignoring element order.
+ *
+ * @returns `true` if the values are deeply equal.
+ *
+ * @example
+ * ```ts
+ * import { isEqual } from '@camera.ui/sdk/internal';
+ *
+ * isEqual({ a: 1, b: 2 }, { b: 2, a: 1 }); // true
+ * isEqual([1, 2, 3], [3, 2, 1], true);     // true (ignoreOrder)
+ * ```
+ */
+export function isEqual(first, second, ignoreOrder = false) {
+    // Same reference or both primitive and equal
+    if (first === second) {
+        return true;
+    }
+    // Handle null/undefined
+    if (first === null || first === undefined || second === null || second === undefined) {
+        return first === second;
+    }
+    // Different types
+    const firstType = first.constructor?.name;
+    const secondType = second.constructor?.name;
+    if (firstType !== secondType) {
+        return false;
+    }
+    // Array comparison
+    if (Array.isArray(first) && Array.isArray(second)) {
+        if (first.length !== second.length) {
+            return false;
+        }
+        if (ignoreOrder) {
+            const secondCopy = [...second];
+            return first.every((item) => {
+                const index = secondCopy.findIndex((secondItem) => isEqual(item, secondItem, ignoreOrder));
+                if (index === -1)
+                    return false;
+                secondCopy.splice(index, 1);
+                return true;
+            });
+        }
+        else {
+            for (let i = 0; i < first.length; i++) {
+                if (!isEqual(first[i], second[i], ignoreOrder)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    // Object comparison
+    if (firstType === 'Object' && secondType === 'Object') {
+        const firstObj = first;
+        const secondObj = second;
+        const fKeys = Object.keys(firstObj);
+        const sKeys = Object.keys(secondObj);
+        if (fKeys.length !== sKeys.length) {
+            return false;
+        }
+        for (const key of fKeys) {
+            if (!isEqual(firstObj[key], secondObj[key], ignoreOrder)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Primitive comparison (fallback)
+    return first === second;
+}

package/dist/internal/streaming-internal.js

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

package/dist/manager/index.js

@@ -1 +1 @@
-export * from './types.js';
+export {};

package/dist/observable/index.js

@@ -0,0 +1,419 @@
+/**
+ * Lightweight reactive primitives for camera.ui.
+ *
+ * Provides cold Observables, multicast Subjects (Subject, BehaviorSubject,
+ * ReplaySubject) and a small set of composable operators for building
+ * property-change notifications and event streams throughout the SDK.
+ */
+// ── Disposable ───────────────────────────────────────────────────────
+/**
+ * Subscription handle returned by `subscribe()`.
+ *
+ * Call `dispose()` (or its alias `unsubscribe()`) to detach the listener
+ * and run any teardown logic registered by the producer. Disposing twice
+ * is a no-op.
+ */
+export class Disposable {
+    #closed = false;
+    #teardown;
+    constructor(teardown) {
+        this.#teardown = teardown;
+    }
+    get closed() {
+        return this.#closed;
+    }
+    dispose() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#teardown();
+    }
+    unsubscribe() {
+        this.dispose();
+    }
+}
+// ── Observable ───────────────────────────────────────────────────────
+/**
+ * Cold producer of a push-based value stream.
+ *
+ * The producer function passed to the constructor is executed once per
+ * `subscribe()` call, so each subscriber gets its own independent run.
+ * `subscribe()` returns a {@link Disposable} that stops the stream and
+ * triggers any teardown registered by the producer.
+ */
+export class Observable {
+    /** @internal */
+    _subscribe;
+    constructor(subscribe) {
+        this._subscribe = subscribe;
+    }
+    /**
+     * Start the producer for this subscriber and route emitted values to `callback`.
+     *
+     * @param callback - Receiver invoked once per emitted value.
+     *
+     * @returns Disposable that stops the stream and runs producer teardown.
+     *
+     * @example
+     * ```ts
+     * const sub = sensor.onPropertyChanged.subscribe((change) => {
+     *   console.log(change.property, change.value);
+     * });
+     * // later
+     * sub.dispose();
+     * ```
+     */
+    subscribe(callback) {
+        return this._subscribe(callback);
+    }
+    pipe(...operators) {
+        let result = this;
+        for (const op of operators) {
+            result = op(result);
+        }
+        return result;
+    }
+}
+// ── Subject ──────────────────────────────────────────────────────────
+/**
+ * Multicast value source.
+ *
+ * Calls to `next(value)` are dispatched synchronously to every active
+ * subscriber. `complete()` releases all subscribers and locks the
+ * Subject so further `next()` calls become no-ops. `subscribe()`
+ * returns a {@link Disposable} for individual cleanup.
+ */
+export class Subject {
+    #subscribers = new Set();
+    #completed = false;
+    get closed() {
+        return this.#completed;
+    }
+    next(value) {
+        if (this.#completed)
+            return;
+        for (const cb of this.#subscribers) {
+            cb(value);
+        }
+    }
+    complete() {
+        if (this.#completed)
+            return;
+        this.#completed = true;
+        this.#subscribers.clear();
+    }
+    subscribe(callback) {
+        if (this.#completed) {
+            return new Disposable(() => { });
+        }
+        this.#subscribers.add(callback);
+        return new Disposable(() => {
+            this.#subscribers.delete(callback);
+        });
+    }
+    pipe(...operators) {
+        let result = this.asObservable();
+        for (const op of operators) {
+            result = op(result);
+        }
+        return result;
+    }
+    /**
+     * Returns a read-only Observable that mirrors this Subject without
+     * exposing `next()` or `complete()`. Useful for handing out a public
+     * stream while keeping write access internal.
+     *
+     * @returns Read-only Observable view of this Subject.
+     *
+     * @example
+     * ```ts
+     * const subject = new Subject<number>();
+     * export const events$ = subject.asObservable();
+     * ```
+     */
+    asObservable() {
+        return new Observable((cb) => this.subscribe(cb));
+    }
+}
+// ── BehaviorSubject ──────────────────────────────────────────────────
+/**
+ * Subject seeded with an initial value that always remembers the latest
+ * emission. New subscribers receive the current value immediately on
+ * `subscribe()` and then all subsequent values. The current value is
+ * also accessible synchronously via `value` and `getValue()`.
+ */
+export class BehaviorSubject extends Subject {
+    #value;
+    constructor(initialValue) {
+        super();
+        this.#value = initialValue;
+    }
+    next(value) {
+        this.#value = value;
+        super.next(value);
+    }
+    getValue() {
+        return this.#value;
+    }
+    get value() {
+        return this.#value;
+    }
+    subscribe(callback) {
+        const disposable = super.subscribe(callback);
+        if (!this.closed) {
+            callback(this.#value);
+        }
+        return disposable;
+    }
+}
+// ── ReplaySubject ────────────────────────────────────────────────────
+/**
+ * Subject that buffers up to the last `bufferSize` values (configurable,
+ * defaults to unbounded). New subscribers immediately receive every
+ * buffered value in order before continuing with live emissions.
+ */
+export class ReplaySubject extends Subject {
+    #buffer = [];
+    #bufferSize;
+    constructor(bufferSize = Infinity) {
+        super();
+        this.#bufferSize = bufferSize;
+    }
+    next(value) {
+        if (this.closed)
+            return;
+        this.#buffer.push(value);
+        if (this.#buffer.length > this.#bufferSize) {
+            this.#buffer.shift();
+        }
+        super.next(value);
+    }
+    subscribe(callback) {
+        // Replay buffered values before subscribing to live values
+        for (const value of this.#buffer) {
+            callback(value);
+        }
+        return super.subscribe(callback);
+    }
+}
+// ── Operators ────────────────────────────────────────────────────────
+/**
+ * Emit only the values for which `predicate` returns `true`.
+ *
+ * @param predicate - Test invoked for each value; truthy passes downstream.
+ *
+ * @returns Operator that filters the source stream.
+ *
+ * @example
+ * ```ts
+ * import { filter } from '@camera.ui/sdk';
+ *
+ * sensor.onPropertyChanged
+ *   .pipe(filter((c) => c.property === 'detected'))
+ *   .subscribe((c) => console.log('motion:', c.value));
+ * ```
+ */
+export function filter(predicate) {
+    return (source) => new Observable((cb) => source.subscribe((value) => {
+        if (predicate(value))
+            cb(value);
+    }));
+}
+/**
+ * Apply `transform` to each emitted value and emit the result.
+ *
+ * @param transform - Projection invoked for each upstream value.
+ *
+ * @returns Operator that maps every value into a new shape.
+ *
+ * @example
+ * ```ts
+ * import { map } from '@camera.ui/sdk';
+ *
+ * sensor.onPropertyChanged
+ *   .pipe(map((c) => c.value as number))
+ *   .subscribe((n) => console.log('battery %:', n));
+ * ```
+ */
+export function map(transform) {
+    return (source) => new Observable((cb) => source.subscribe((value) => {
+        cb(transform(value));
+    }));
+}
+/**
+ * Emit a value only when it differs from the previous one. Uses `===` by
+ * default, or an optional custom comparator (e.g. for deep equality).
+ *
+ * @param comparator - Equality function; return `true` to suppress duplicates.
+ *
+ * @returns Operator that drops consecutive equal values.
+ *
+ * @example
+ * ```ts
+ * import { distinctUntilChanged } from '@camera.ui/sdk';
+ *
+ * sensor.onPropertyChanged
+ *   .pipe(distinctUntilChanged((a, b) => a.value === b.value))
+ *   .subscribe((c) => console.log('changed:', c));
+ * ```
+ */
+export function distinctUntilChanged(comparator) {
+    return (source) => new Observable((cb) => {
+        let hasValue = false;
+        let lastValue;
+        const compare = comparator ?? ((a, b) => a === b);
+        return source.subscribe((value) => {
+            if (!hasValue || !compare(lastValue, value)) {
+                hasValue = true;
+                lastValue = value;
+                cb(value);
+            }
+        });
+    });
+}
+/**
+ * Emit `[previous, current]` pairs for every value after the first.
+ *
+ * @returns Operator that yields adjacent value pairs.
+ *
+ * @example
+ * ```ts
+ * import { pairwise } from '@camera.ui/sdk';
+ *
+ * sensor.onPropertyChanged
+ *   .pipe(pairwise())
+ *   .subscribe(([prev, curr]) => console.log(prev.value, '->', curr.value));
+ * ```
+ */
+export function pairwise() {
+    return (source) => new Observable((cb) => {
+        let hasValue = false;
+        let prev;
+        return source.subscribe((value) => {
+            if (hasValue) {
+                cb([prev, value]);
+            }
+            hasValue = true;
+            prev = value;
+        });
+    });
+}
+/**
+ * Project each source value to a list and flatten the results into the
+ * output stream.
+ *
+ * @param project - Function returning an array of values for each input.
+ *
+ * @returns Operator that flattens projected arrays into a single stream.
+ *
+ * @example
+ * ```ts
+ * import { mergeMap } from '@camera.ui/sdk';
+ *
+ * motionSensor.onPropertyChanged
+ *   .pipe(mergeMap((c) => (c.property === 'detections' ? c.value as any[] : [])))
+ *   .subscribe((det) => console.log('detection:', det));
+ * ```
+ */
+export function mergeMap(project) {
+    return (source) => new Observable((cb) => {
+        let index = 0;
+        return source.subscribe((value) => {
+            const results = project(value, index++);
+            for (const r of results) {
+                cb(r);
+            }
+        });
+    });
+}
+/**
+ * Multicast a cold Observable through a Subject, sharing a single upstream
+ * subscription among all subscribers (reference-counted). Supply a custom
+ * connector (e.g. `() => new ReplaySubject(1)`) to change buffering.
+ *
+ * @param config - Optional config with a `connector` factory for the Subject.
+ *
+ * @param config.connector - Factory returning the multicast Subject to use.
+ *
+ * @returns Operator that multicasts the source.
+ *
+ * @example
+ * ```ts
+ * import { share, ReplaySubject } from '@camera.ui/sdk';
+ *
+ * const events$ = source$.pipe(share({ connector: () => new ReplaySubject(1) }));
+ * events$.subscribe((v) => console.log('a', v));
+ * events$.subscribe((v) => console.log('b', v));
+ * ```
+ */
+export function share(config) {
+    return (source) => {
+        let subject = null;
+        let sourceDisposable = null;
+        let refCount = 0;
+        return new Observable((cb) => {
+            if (!subject) {
+                subject = config?.connector ? config.connector() : new Subject();
+                sourceDisposable = source.subscribe((value) => {
+                    subject.next(value);
+                });
+            }
+            refCount++;
+            const sub = subject.subscribe(cb);
+            return new Disposable(() => {
+                sub.dispose();
+                refCount--;
+                if (refCount === 0) {
+                    sourceDisposable?.dispose();
+                    sourceDisposable = null;
+                    subject = null;
+                }
+            });
+        });
+    };
+}
+// ── Utilities ────────────────────────────────────────────────────────
+/**
+ * Subscribe to the source and return a Promise that resolves with its first
+ * emitted value, then disposes the subscription. Rejects if the source has
+ * already completed without emitting.
+ *
+ * @param observable - Source stream to await.
+ *
+ * @returns Promise that resolves with the first emitted value.
+ *
+ * @example
+ * ```ts
+ * import { firstValueFrom } from '@camera.ui/sdk';
+ *
+ * const change = await firstValueFrom(sensor.onPropertyChanged);
+ * console.log('first change:', change.property);
+ * ```
+ */
+export function firstValueFrom(observable) {
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        // The callback may fire synchronously during subscribe() (BehaviorSubject/
+        // ReplaySubject), so declare sub up front to avoid the temporal dead zone.
+        let sub = undefined;
+        sub = observable.subscribe((value) => {
+            if (!resolved) {
+                resolved = true;
+                // sub may not be assigned yet if value is emitted synchronously (BehaviorSubject/ReplaySubject)
+                if (sub) {
+                    sub.dispose();
+                }
+                resolve(value);
+            }
+        });
+        // Already resolved synchronously — clean up immediately
+        if (resolved) {
+            sub.dispose();
+            return;
+        }
+        // If the observable completed without emitting (closed subject)
+        if ('closed' in observable && observable.closed && !resolved) {
+            reject(new Error('Observable completed without emitting a value'));
+        }
+    });
+}

package/dist/plugin/api.js

@@ -0,0 +1,21 @@
+/**
+ * Lifecycle events emitted on the PluginAPI EventEmitter. Plugins subscribe
+ * with `api.on(API_EVENT.X, handler)` to react to host-driven phase changes.
+ */
+export var API_EVENT;
+(function (API_EVENT) {
+    /**
+     * Emitted exactly once after the plugin has been constructed, all assigned
+     * cameras have been wired up, and `configureCameras()` has returned. Use
+     * this to start background work that must wait until the camera set is
+     * stable (timers, model warm-up, outbound connections).
+     */
+    API_EVENT["FINISH_LAUNCHING"] = "finishLaunching";
+    /**
+     * Emitted when the host is tearing the plugin down (graceful stop, reload
+     * or process exit). Listeners must release resources synchronously enough
+     * to finish before the host kills the process — open files, sockets,
+     * timers, child processes.
+     */
+    API_EVENT["SHUTDOWN"] = "shutdown";
+})(API_EVENT || (API_EVENT = {}));