@symbiote-native/sensors 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# @symbiote-native/sensors
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-sensors`](https://github.com/expo/expo/tree/main/packages/expo-sensors) — Accelerometer,
+Barometer, DeviceMotion, Gyroscope, LightSensor, Magnetometer, MagnetometerUncalibrated, and
+Pedometer — usable from **every** adapter, React, Vue, and Angular. Unlike this repo's other
+wrappers ([`@symbiote-native/slider`](../slider), [`@symbiote-native/navigation`](../navigation),
+[`@symbiote-native/splash-screen`](../splash-screen)), `expo-sensors` isn't a plain RN native
+module or view — it's built on `expo-modules-core`, so its native code autolinks straight out of
+`node_modules` via `expo-modules-autolinking`, no proxy `react-native.config.cjs`/podspec to ship.
+`expo-sensors`' own JS is never imported (it hard-imports the full `expo` meta-package, which this
+project never depends on) — every sensor's logic is hand-ported into this package's own `core/`.
+
+## Install
+
+```bash
+npm install @symbiote-native/sensors
+```
+
+Depends on `expo-sensors` and `expo-modules-core` directly (regular dependencies, pinned to exact
+versions — never a caret range, since this package's `core/` is hand-ported against one specific
+native API shape and a newer resolve could silently drift the two apart). Never install
+`expo-sensors` yourself, and never add the `expo` package to this project.
+
+## Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-sensors`' native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every future `expo-modules-core`
+package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list, per-sensor permission strings — live in the
+`symbiote-expo-native-module` skill. Reference implementation: `.examples/react/ios/Podfile` and
+`.examples/react/android/app/src/main/java/com/canary/MainApplication.kt`.
+
+Permissions ship with the native module itself — nothing to reimplement, just the platform
+permission string each sensor needs (e.g. DeviceMotion/Pedometer need `NSMotionUsageDescription`
+on iOS).
+
+## Shape
+
+```
+src/core/             DeviceSensor base class + one class per sensor (Accelerometer, Barometer,
+                       DeviceMotion, Gyroscope, LightSensor, Magnetometer,
+                       MagnetometerUncalibrated); Pedometer is free functions instead — upstream
+                       has no shared instance for it. native/ resolves each sensor's native
+                       module by name through expo-modules-core's requireNativeModule.
+src/react/hooks/       @symbiote-native/sensors/react   — useAccelerometer, useBarometer, ...
+src/vue/composables/   @symbiote-native/sensors/vue     — useAccelerometer, useBarometer, ... (same names)
+src/angular/services/  @symbiote-native/sensors/angular — AccelerometerService, BarometerService, ...
+```
+
+Each adapter's hook/composable/service is a thin lifecycle wrapper (subscribe on mount, unsubscribe
+on unmount) over the same `core` singleton — the subscription, permission, and update-interval
+logic is written once and shared by all three.
+
+## Use it
+
+### A `DeviceSensor`-shaped sensor (Accelerometer, Barometer, DeviceMotion, Gyroscope, LightSensor, Magnetometer, MagnetometerUncalibrated)
+
+```tsx
+// React
+import { useAccelerometer } from '@symbiote-native/sensors/react';
+
+function SensorsScreen() {
+  const accelerometer = useAccelerometer();
+  return <Text>{accelerometer && `x ${accelerometer.x} · y ${accelerometer.y} · z ${accelerometer.z}`}</Text>;
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { useAccelerometer } from '@symbiote-native/sensors/vue';
+
+const accelerometer = useAccelerometer();
+</script>
+<template>
+  <Text>{{ accelerometer && `x ${accelerometer.x} · y ${accelerometer.y} · z ${accelerometer.z}` }}</Text>
+</template>
+```
+
+```ts
+// Angular
+import { Component, inject } from '@angular/core';
+import { AccelerometerService } from '@symbiote-native/sensors/angular';
+
+@Component({ /* ... */ })
+export class SensorsScreen {
+  readonly accelerometer = inject(AccelerometerService).connect();
+}
+```
+
+The React example above mirrors the real demo screen, `.examples/react/screens/SensorsScreen.tsx`
+— the Vue and Angular snippets are illustrative; those adapters' own demo screens aren't wired up
+yet (React is this repo's "prove the pattern first" adapter for this package).
+
+Every hook/composable/`connect()` takes an optional `updateIntervalMs` and returns `null` until the
+first native reading arrives — check `isAvailableAsync()` separately if you need to distinguish
+"not available on this device" from "no reading yet" (see [Notes](#notes) below).
+
+### Pedometer — free functions, no shared instance
+
+```ts
+import { watchStepCount, getStepCountAsync, isAvailableAsync } from '@symbiote-native/sensors';
+import { usePedometer } from '@symbiote-native/sensors/react'; // or /vue, /angular's PedometerService
+
+const pedometer = usePedometer(); // { steps: number } | null, live-subscribed
+const { steps } = await getStepCountAsync(startDate, endDate); // one-shot, iOS only in practice
+```
+
+## Notes
+
+- **Simulators have no real IMU/pedometer hardware.** `isAvailableAsync()` genuinely returns
+  `false` on an iOS Simulator (every CoreMotion-backed sensor and `CMPedometer`); on an Android
+  emulator, readings drift on their own even at rest, since the emulator synthesizes motion data
+  rather than returning frozen zeros. Neither is a wiring bug; verify on a real device.
+- **`DeviceMotion.rotation`/`.acceleration`/`.accelerationIncludingGravity`/`.rotationRate` are
+  nested and may be absent from the very first event** (the underlying sensor hasn't reported yet)
+  — guard the nested field itself (`deviceMotion?.rotation && ...`), not just the top-level object.
+- **`rotation.beta` can read `NaN` near pitch ±90°** — an inherent Euler-angle gimbal-lock
+  singularity in `CMAttitude`/the platform's device-orientation math (the same one
+  `DeviceOrientationEvent.beta` has on the web), not a bug in this package.
+
+## Test it
+
+No Fabric/Descriptor angle at all — a sensor is a pure `EventEmitter` + async-function surface,
+never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/**/*.test.ts`, `src/{react,vue,angular}/**/*.test.{ts,tsx}`),
+the same pattern `expo-sensors` itself uses upstream — no `installFabric()`, no ViewConfig.

package/build/angular/index.d.ts

@@ -0,0 +1,16 @@
+export { AccelerometerService } from './services/accelerometer.service';
+export type { IAccelerometerMeasurement } from '../core';
+export { BarometerService } from './services/barometer.service';
+export type { IBarometerMeasurement } from '../core';
+export { DeviceMotionService } from './services/device-motion.service';
+export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement } from '../core';
+export { GyroscopeService } from './services/gyroscope.service';
+export type { IGyroscopeMeasurement } from '../core';
+export { LightSensorService } from './services/light-sensor.service';
+export type { ILightSensorMeasurement } from '../core';
+export { MagnetometerService } from './services/magnetometer.service';
+export type { IMagnetometerMeasurement } from '../core';
+export { MagnetometerUncalibratedService } from './services/magnetometer-uncalibrated.service';
+export type { IMagnetometerUncalibratedMeasurement } from '../core';
+export { PedometerService } from './services/pedometer.service';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, type IPedometerResult, type IPedometerUpdateCallback, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,12 @@
+// AccelerometerService is the Angular-only lifecycle half; the sensor singleton and event
+// subscription plumbing all live in core, shared with React/Vue.
+export { AccelerometerService } from './services/accelerometer.service/index.js';
+export { BarometerService } from './services/barometer.service/index.js';
+export { DeviceMotionService } from './services/device-motion.service/index.js';
+export { DeviceMotionOrientation, gravity } from '../core/index.js';
+export { GyroscopeService } from './services/gyroscope.service/index.js';
+export { LightSensorService } from './services/light-sensor.service/index.js';
+export { MagnetometerService } from './services/magnetometer.service/index.js';
+export { MagnetometerUncalibratedService } from './services/magnetometer-uncalibrated.service/index.js';
+export { PedometerService } from './services/pedometer.service/index.js';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, } from '../core/index.js';

package/build/angular/services/accelerometer.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type IAccelerometerMeasurement } from '../../../core';
+export declare class AccelerometerService {
+    private readonly injector;
+    connect(updateIntervalMs?: number): Signal<IAccelerometerMeasurement | null>;
+}

package/build/angular/services/accelerometer.service/index.js

@@ -0,0 +1,81 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { Accelerometer } from '../../../core/index.js';
+// 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.
+let AccelerometerService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var AccelerometerService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            AccelerometerService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // 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.
+        injector = inject(Injector);
+        connect(updateIntervalMs) {
+            const measurement = signal(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();
+        }
+    };
+    return AccelerometerService = _classThis;
+})();
+export { AccelerometerService };

package/build/angular/services/barometer.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type IBarometerMeasurement } from '../../../core';
+export declare class BarometerService {
+    private readonly injector;
+    connect(updateIntervalMs?: number): Signal<IBarometerMeasurement | null>;
+}

package/build/angular/services/barometer.service/index.js

@@ -0,0 +1,81 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { Barometer } from '../../../core/index.js';
+// 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.
+let BarometerService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var BarometerService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BarometerService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // 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.
+        injector = inject(Injector);
+        connect(updateIntervalMs) {
+            const measurement = signal(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();
+        }
+    };
+    return BarometerService = _classThis;
+})();
+export { BarometerService };

package/build/angular/services/device-motion.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type IDeviceMotionMeasurement } from '../../../core';
+export declare class DeviceMotionService {
+    private readonly injector;
+    connect(updateIntervalMs?: number): Signal<IDeviceMotionMeasurement | null>;
+}

package/build/angular/services/device-motion.service/index.js

@@ -0,0 +1,81 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { DeviceMotion } from '../../../core/index.js';
+// 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.
+let DeviceMotionService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var DeviceMotionService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DeviceMotionService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // 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.
+        injector = inject(Injector);
+        connect(updateIntervalMs) {
+            const measurement = signal(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();
+        }
+    };
+    return DeviceMotionService = _classThis;
+})();
+export { DeviceMotionService };

package/build/angular/services/gyroscope.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type IGyroscopeMeasurement } from '../../../core';
+export declare class GyroscopeService {
+    private readonly injector;
+    connect(updateIntervalMs?: number): Signal<IGyroscopeMeasurement | null>;
+}

package/build/angular/services/gyroscope.service/index.js

@@ -0,0 +1,81 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { Gyroscope } from '../../../core/index.js';
+// 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.
+let GyroscopeService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var GyroscopeService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            GyroscopeService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // 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.
+        injector = inject(Injector);
+        connect(updateIntervalMs) {
+            const measurement = signal(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();
+        }
+    };
+    return GyroscopeService = _classThis;
+})();
+export { GyroscopeService };

package/build/angular/services/light-sensor.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type ILightSensorMeasurement } from '../../../core';
+export declare class LightSensorService {
+    private readonly injector;
+    connect(updateIntervalMs?: number): Signal<ILightSensorMeasurement | null>;
+}

package/build/angular/services/light-sensor.service/index.js

@@ -0,0 +1,81 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { LightSensor } from '../../../core/index.js';
+// 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.
+let LightSensorService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var LightSensorService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            LightSensorService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // 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.
+        injector = inject(Injector);
+        connect(updateIntervalMs) {
+            const measurement = signal(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();
+        }
+    };
+    return LightSensorService = _classThis;
+})();
+export { LightSensorService };