@symbiote-native/sensors 0.1.0

package/src/angular/services/accelerometer.service/accelerometer.service.test.ts

@@ -0,0 +1,118 @@
+// Co-located Angular-driven test (ADR 0025) for AccelerometerService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires
+// correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IAccelerometerMeasurement } from '../../../core';
+import { AccelerometerService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  Accelerometer: {
+    addListener: (listener: (measurement: IAccelerometerMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 941;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: IAccelerometerMeasurement = { x: 0.1, y: 0.2, z: 0.3, timestamp: 123 };
+
+let capturedResult: Signal<IAccelerometerMeasurement | null> | undefined;
+let capturedListener: ((measurement: IAccelerometerMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-accelerometer-host',
+  standalone: true,
+  template: '',
+})
+class AccelerometerHost {
+  readonly measurement = inject(AccelerometerService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-accelerometer-interval-host',
+  standalone: true,
+  template: '',
+})
+class AccelerometerIntervalHost {
+  readonly measurement = inject(AccelerometerService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('AccelerometerService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, AccelerometerHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, AccelerometerHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, AccelerometerHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, AccelerometerIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, AccelerometerHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/accelerometer.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { Accelerometer, type IAccelerometerMeasurement } from '../../../core';
+
+// Angular twin of React's `useAccelerometer` hook and Vue's `useAccelerometer` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly measurement = inject(AccelerometerService).connect();
+//   // template: {{ measurement()?.x }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class AccelerometerService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<IAccelerometerMeasurement | null> {
+    const measurement = signal<IAccelerometerMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          Accelerometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Accelerometer.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}

package/src/angular/services/barometer.service/barometer.service.test.ts

@@ -0,0 +1,122 @@
+// Co-located Angular-driven test (ADR 0025) for BarometerService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires
+// correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IBarometerMeasurement } from '../../../core';
+import { BarometerService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  Barometer: {
+    addListener: (listener: (measurement: IBarometerMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: IBarometerMeasurement = {
+  pressure: 1013.25,
+  relativeAltitude: 12.3,
+  timestamp: 123,
+};
+
+let capturedResult: Signal<IBarometerMeasurement | null> | undefined;
+let capturedListener: ((measurement: IBarometerMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-barometer-host',
+  standalone: true,
+  template: '',
+})
+class BarometerHost {
+  readonly measurement = inject(BarometerService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-barometer-interval-host',
+  standalone: true,
+  template: '',
+})
+class BarometerIntervalHost {
+  readonly measurement = inject(BarometerService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('BarometerService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, BarometerHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, BarometerHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, BarometerHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, BarometerIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, BarometerHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/barometer.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { Barometer, type IBarometerMeasurement } from '../../../core';
+
+// Angular twin of React's `useBarometer` hook and Vue's `useBarometer` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly measurement = inject(BarometerService).connect();
+//   // template: {{ measurement()?.pressure }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class BarometerService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<IBarometerMeasurement | null> {
+    const measurement = signal<IBarometerMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          Barometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Barometer.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}

package/src/angular/services/device-motion.service/device-motion.service.test.ts

@@ -0,0 +1,125 @@
+// Co-located Angular-driven test (ADR 0025) for DeviceMotionService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires
+// correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IDeviceMotionMeasurement } from '../../../core';
+import { DeviceMotionService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  DeviceMotion: {
+    addListener: (listener: (measurement: IDeviceMotionMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: IDeviceMotionMeasurement = {
+  acceleration: { x: 0.1, y: 0.2, z: 0.3, timestamp: 123 },
+  accelerationIncludingGravity: { x: 0.1, y: 0.2, z: 9.8, timestamp: 123 },
+  rotation: { alpha: 1, beta: 2, gamma: 3, timestamp: 123 },
+  rotationRate: { alpha: 0.1, beta: 0.2, gamma: 0.3, timestamp: 123 },
+  interval: 16,
+  orientation: 0, // DeviceMotionOrientation.Portrait
+};
+
+let capturedResult: Signal<IDeviceMotionMeasurement | null> | undefined;
+let capturedListener: ((measurement: IDeviceMotionMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-device-motion-host',
+  standalone: true,
+  template: '',
+})
+class DeviceMotionHost {
+  readonly measurement = inject(DeviceMotionService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-device-motion-interval-host',
+  standalone: true,
+  template: '',
+})
+class DeviceMotionIntervalHost {
+  readonly measurement = inject(DeviceMotionService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('DeviceMotionService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, DeviceMotionHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, DeviceMotionHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, DeviceMotionHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, DeviceMotionIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, DeviceMotionHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/device-motion.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { DeviceMotion, type IDeviceMotionMeasurement } from '../../../core';
+
+// Angular twin of React's `useDeviceMotion` hook and Vue's `useDeviceMotion` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly measurement = inject(DeviceMotionService).connect();
+//   // template: {{ measurement()?.rotation?.alpha }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class DeviceMotionService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<IDeviceMotionMeasurement | null> {
+    const measurement = signal<IDeviceMotionMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          DeviceMotion.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = DeviceMotion.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}

package/src/angular/services/gyroscope.service/gyroscope.service.test.ts

@@ -0,0 +1,118 @@
+// Co-located Angular-driven test (ADR 0025) for GyroscopeService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires
+// correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IGyroscopeMeasurement } from '../../../core';
+import { GyroscopeService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  Gyroscope: {
+    addListener: (listener: (measurement: IGyroscopeMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: IGyroscopeMeasurement = { x: 0.1, y: 0.2, z: 0.3, timestamp: 123 };
+
+let capturedResult: Signal<IGyroscopeMeasurement | null> | undefined;
+let capturedListener: ((measurement: IGyroscopeMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-gyroscope-host',
+  standalone: true,
+  template: '',
+})
+class GyroscopeHost {
+  readonly measurement = inject(GyroscopeService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-gyroscope-interval-host',
+  standalone: true,
+  template: '',
+})
+class GyroscopeIntervalHost {
+  readonly measurement = inject(GyroscopeService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('GyroscopeService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, GyroscopeHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, GyroscopeHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, GyroscopeHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, GyroscopeIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, GyroscopeHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/gyroscope.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { Gyroscope, type IGyroscopeMeasurement } from '../../../core';
+
+// Angular twin of React's `useGyroscope` hook and Vue's `useGyroscope` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly measurement = inject(GyroscopeService).connect();
+//   // template: {{ measurement()?.x }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class GyroscopeService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<IGyroscopeMeasurement | null> {
+    const measurement = signal<IGyroscopeMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          Gyroscope.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Gyroscope.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}

package/src/angular/services/light-sensor.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { LightSensor, type ILightSensorMeasurement } from '../../../core';
+
+// Angular twin of React's `useLightSensor` hook and Vue's `useLightSensor` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly measurement = inject(LightSensorService).connect();
+//   // template: {{ measurement()?.illuminance }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class LightSensorService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<ILightSensorMeasurement | null> {
+    const measurement = signal<ILightSensorMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          LightSensor.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = LightSensor.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}