@symbiote-native/sensors 0.1.0

package/build/angular/services/magnetometer-uncalibrated.service/index.d.ts

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

package/build/angular/services/magnetometer-uncalibrated.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 { MagnetometerUncalibrated } from '../../../core/index.js';
+// Angular twin of React's `useMagnetometerUncalibrated` hook and Vue's
+// `useMagnetometerUncalibrated` 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(MagnetometerUncalibratedService).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 MagnetometerUncalibratedService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var MagnetometerUncalibratedService = 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);
+            MagnetometerUncalibratedService = _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) {
+                    MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+                }
+                const subscription = MagnetometerUncalibrated.addListener(next => measurement.set(next));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return measurement.asReadonly();
+        }
+    };
+    return MagnetometerUncalibratedService = _classThis;
+})();
+export { MagnetometerUncalibratedService };

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

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

package/build/angular/services/magnetometer.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 { Magnetometer } from '../../../core/index.js';
+// Angular twin of React's `useMagnetometer` hook and Vue's `useMagnetometer` 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(MagnetometerService).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 MagnetometerService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var MagnetometerService = 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);
+            MagnetometerService = _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) {
+                    Magnetometer.setUpdateInterval(updateIntervalMs);
+                }
+                const subscription = Magnetometer.addListener(next => measurement.set(next));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return measurement.asReadonly();
+        }
+    };
+    return MagnetometerService = _classThis;
+})();
+export { MagnetometerService };

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

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

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

@@ -0,0 +1,76 @@
+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 { watchStepCount } from '../../../core/index.js';
+// Angular twin of React's `usePedometer` hook and Vue's `usePedometer` 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 result = inject(PedometerService).connect();
+//   // template: {{ result()?.steps }}
+//
+// Unlike AccelerometerService.connect(), there is no updateIntervalMs to apply — Pedometer has
+// no setUpdateInterval — so a single effect() that subscribes once and cleans up once is enough.
+let PedometerService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PedometerService = 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);
+            PedometerService = _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 AccelerometerService.
+        injector = inject(Injector);
+        connect() {
+            const result = signal(null);
+            effect(onCleanup => {
+                const subscription = watchStepCount(next => result.set(next));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return result.asReadonly();
+        }
+    };
+    return PedometerService = _classThis;
+})();
+export { PedometerService };

package/build/core/accelerometer.d.ts

@@ -0,0 +1,10 @@
+import { DeviceSensor } from './device-sensor';
+export type IAccelerometerMeasurement = {
+    x: number;
+    y: number;
+    z: number;
+    timestamp: number;
+};
+export declare class AccelerometerSensor extends DeviceSensor<IAccelerometerMeasurement> {
+}
+export declare const Accelerometer: AccelerometerSensor;

package/build/core/accelerometer.js

@@ -0,0 +1,6 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentAccelerometer } from './native/exponent-accelerometer.js';
+export class AccelerometerSensor extends DeviceSensor {
+}
+const ACCELEROMETER_DID_UPDATE_EVENT_NAME = 'accelerometerDidUpdate';
+export const Accelerometer = new AccelerometerSensor(exponentAccelerometer, ACCELEROMETER_DID_UPDATE_EVENT_NAME);

package/build/core/barometer.d.ts

@@ -0,0 +1,9 @@
+import { DeviceSensor } from './device-sensor';
+export type IBarometerMeasurement = {
+    pressure: number;
+    relativeAltitude?: number;
+    timestamp: number;
+};
+export declare class BarometerSensor extends DeviceSensor<IBarometerMeasurement> {
+}
+export declare const Barometer: BarometerSensor;

package/build/core/barometer.js

@@ -0,0 +1,6 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentBarometer } from './native/exponent-barometer.js';
+export class BarometerSensor extends DeviceSensor {
+}
+const BAROMETER_DID_UPDATE_EVENT_NAME = 'barometerDidUpdate';
+export const Barometer = new BarometerSensor(exponentBarometer, BAROMETER_DID_UPDATE_EVENT_NAME);

package/build/core/device-motion.d.ts

@@ -0,0 +1,40 @@
+import { DeviceSensor } from './device-sensor';
+export type IDeviceMotionMeasurement = {
+    acceleration: null | {
+        x: number;
+        y: number;
+        z: number;
+        timestamp: number;
+    };
+    accelerationIncludingGravity: {
+        x: number;
+        y: number;
+        z: number;
+        timestamp: number;
+    };
+    rotation: {
+        alpha: number;
+        beta: number;
+        gamma: number;
+        timestamp: number;
+    };
+    rotationRate: null | {
+        alpha: number;
+        beta: number;
+        gamma: number;
+        timestamp: number;
+    };
+    interval: number;
+    orientation: DeviceMotionOrientation;
+};
+export declare enum DeviceMotionOrientation {
+    Portrait = 0,
+    RightLandscape = 90,
+    UpsideDown = 180,
+    LeftLandscape = -90
+}
+export declare class DeviceMotionSensor extends DeviceSensor<IDeviceMotionMeasurement> {
+    readonly gravity: number;
+}
+export declare const DeviceMotion: DeviceMotionSensor;
+export declare const gravity: number;

package/build/core/device-motion.js

@@ -0,0 +1,21 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentDeviceMotion } from './native/exponent-device-motion.js';
+// Device orientation based on screen rotation.
+export var DeviceMotionOrientation;
+(function (DeviceMotionOrientation) {
+    DeviceMotionOrientation[DeviceMotionOrientation["Portrait"] = 0] = "Portrait";
+    DeviceMotionOrientation[DeviceMotionOrientation["RightLandscape"] = 90] = "RightLandscape";
+    DeviceMotionOrientation[DeviceMotionOrientation["UpsideDown"] = 180] = "UpsideDown";
+    DeviceMotionOrientation[DeviceMotionOrientation["LeftLandscape"] = -90] = "LeftLandscape";
+})(DeviceMotionOrientation || (DeviceMotionOrientation = {}));
+export class DeviceMotionSensor extends DeviceSensor {
+    // Standard gravitational acceleration for Earth (m/s^2), read off the native module rather
+    // than hardcoded — mirrors upstream's dual exposure as both an instance property and the
+    // standalone `gravity` export below.
+    gravity = exponentDeviceMotion.Gravity;
+}
+const DEVICE_MOTION_DID_UPDATE_EVENT_NAME = 'deviceMotionDidUpdate';
+export const DeviceMotion = new DeviceMotionSensor(exponentDeviceMotion, DEVICE_MOTION_DID_UPDATE_EVENT_NAME);
+// Standalone export mirroring the instance property above, for callers that only need the
+// constant and not the full sensor singleton.
+export const gravity = exponentDeviceMotion.Gravity;

package/build/core/device-sensor.d.ts

@@ -0,0 +1,27 @@
+import { PermissionStatus, type EventSubscription, type PermissionExpiration, type PermissionResponse } from 'expo-modules-core';
+export type IListener<Measurement> = (measurement: Measurement) => void;
+export type INativeSensorModule<Measurement> = {
+    addListener(eventName: string, listener: IListener<Measurement>): EventSubscription;
+    listenerCount(eventName: string): number;
+    removeAllListeners(eventName: string): void;
+    setUpdateInterval?(intervalMs: number): void;
+    isAvailableAsync?(): Promise<boolean>;
+    getPermissionsAsync?(): Promise<PermissionResponse>;
+    requestPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare class DeviceSensor<Measurement> {
+    readonly nativeModule: INativeSensorModule<Measurement>;
+    readonly nativeEventName: string;
+    constructor(nativeModule: INativeSensorModule<Measurement>, nativeEventName: string);
+    addListener(listener: IListener<Measurement>): EventSubscription;
+    hasListeners(): boolean;
+    getListenerCount(): number;
+    removeAllListeners(): void;
+    removeSubscription(subscription: EventSubscription): void;
+    setUpdateInterval(intervalMs: number): void;
+    isAvailableAsync(): Promise<boolean>;
+    getPermissionsAsync(): Promise<PermissionResponse>;
+    requestPermissionsAsync(): Promise<PermissionResponse>;
+}
+export { PermissionStatus };
+export type { EventSubscription, PermissionExpiration, PermissionResponse };

package/build/core/device-sensor.js

@@ -0,0 +1,61 @@
+// expo-sensors' own DeviceSensor imports PermissionResponse/PermissionExpiration/PermissionStatus
+// from the `expo` meta-package. We never depend on `expo` itself (it drags in a second
+// Metro/babel pipeline — see the symbiote-expo-native-module skill) so this pulls the same
+// three exports straight from expo-modules-core, which is where `expo` re-exports them from.
+import { Platform, PermissionStatus, } from 'expo-modules-core';
+const DEFAULT_PERMISSION_RESPONSE = {
+    granted: true,
+    expires: 'never',
+    canAskAgain: true,
+    status: PermissionStatus.GRANTED,
+};
+export class DeviceSensor {
+    nativeModule;
+    nativeEventName;
+    constructor(nativeModule, nativeEventName) {
+        this.nativeModule = nativeModule;
+        this.nativeEventName = nativeEventName;
+    }
+    addListener(listener) {
+        return this.nativeModule.addListener(this.nativeEventName, listener);
+    }
+    hasListeners() {
+        return this.getListenerCount() > 0;
+    }
+    getListenerCount() {
+        return this.nativeModule.listenerCount(this.nativeEventName);
+    }
+    removeAllListeners() {
+        this.nativeModule.removeAllListeners(this.nativeEventName);
+    }
+    // upstream keeps this only for callers still holding a pre-subscription-object reference.
+    removeSubscription(subscription) {
+        subscription.remove();
+    }
+    setUpdateInterval(intervalMs) {
+        if (!this.nativeModule.setUpdateInterval) {
+            console.warn(`@symbiote-native/sensors: setUpdateInterval() is not supported on ${Platform.OS}`);
+            return;
+        }
+        this.nativeModule.setUpdateInterval(intervalMs);
+    }
+    async isAvailableAsync() {
+        if (!this.nativeModule.isAvailableAsync) {
+            return false;
+        }
+        return this.nativeModule.isAvailableAsync();
+    }
+    async getPermissionsAsync() {
+        if (!this.nativeModule.getPermissionsAsync) {
+            return DEFAULT_PERMISSION_RESPONSE;
+        }
+        return this.nativeModule.getPermissionsAsync();
+    }
+    async requestPermissionsAsync() {
+        if (!this.nativeModule.requestPermissionsAsync) {
+            return DEFAULT_PERMISSION_RESPONSE;
+        }
+        return this.nativeModule.requestPermissionsAsync();
+    }
+}
+export { PermissionStatus };

package/build/core/gyroscope.d.ts

@@ -0,0 +1,10 @@
+import { DeviceSensor } from './device-sensor';
+export type IGyroscopeMeasurement = {
+    x: number;
+    y: number;
+    z: number;
+    timestamp: number;
+};
+export declare class GyroscopeSensor extends DeviceSensor<IGyroscopeMeasurement> {
+}
+export declare const Gyroscope: GyroscopeSensor;

package/build/core/gyroscope.js

@@ -0,0 +1,6 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentGyroscope } from './native/exponent-gyroscope.js';
+export class GyroscopeSensor extends DeviceSensor {
+}
+const GYROSCOPE_DID_UPDATE_EVENT_NAME = 'gyroscopeDidUpdate';
+export const Gyroscope = new GyroscopeSensor(exponentGyroscope, GYROSCOPE_DID_UPDATE_EVENT_NAME);

package/build/core/index.d.ts

@@ -0,0 +1,11 @@
+export { Accelerometer, AccelerometerSensor, type IAccelerometerMeasurement, } from './accelerometer';
+export { Barometer, BarometerSensor, type IBarometerMeasurement } from './barometer';
+export { DeviceMotion, DeviceMotionSensor, DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement, } from './device-motion';
+export { Gyroscope, GyroscopeSensor, type IGyroscopeMeasurement } from './gyroscope';
+export { LightSensor, LightSensorSensor, type ILightSensorMeasurement } from './light-sensor';
+export { Magnetometer, MagnetometerSensor, type IMagnetometerMeasurement } from './magnetometer';
+export { MagnetometerUncalibrated, MagnetometerUncalibratedSensor, type IMagnetometerUncalibratedMeasurement, } from './magnetometer-uncalibrated';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, type IPedometerResult, type IPedometerUpdateCallback, } from './pedometer';
+export { DeviceSensor, type IListener, type INativeSensorModule } from './device-sensor';
+export type { EventSubscription, PermissionExpiration, PermissionResponse, } from 'expo-modules-core';
+export { PermissionStatus } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,10 @@
+export { Accelerometer, AccelerometerSensor, } from './accelerometer.js';
+export { Barometer, BarometerSensor } from './barometer.js';
+export { DeviceMotion, DeviceMotionSensor, DeviceMotionOrientation, gravity, } from './device-motion.js';
+export { Gyroscope, GyroscopeSensor } from './gyroscope.js';
+export { LightSensor, LightSensorSensor } from './light-sensor.js';
+export { Magnetometer, MagnetometerSensor } from './magnetometer.js';
+export { MagnetometerUncalibrated, MagnetometerUncalibratedSensor, } from './magnetometer-uncalibrated.js';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, } from './pedometer.js';
+export { DeviceSensor } from './device-sensor.js';
+export { PermissionStatus } from 'expo-modules-core';

package/build/core/light-sensor.d.ts

@@ -0,0 +1,8 @@
+import { DeviceSensor } from './device-sensor';
+export type ILightSensorMeasurement = {
+    illuminance: number;
+    timestamp: number;
+};
+export declare class LightSensorSensor extends DeviceSensor<ILightSensorMeasurement> {
+}
+export declare const LightSensor: LightSensorSensor;

package/build/core/light-sensor.js

@@ -0,0 +1,6 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentLightSensor } from './native/exponent-light-sensor';
+export class LightSensorSensor extends DeviceSensor {
+}
+const LIGHT_SENSOR_DID_UPDATE_EVENT_NAME = 'lightSensorDidUpdate';
+export const LightSensor = new LightSensorSensor(exponentLightSensor, LIGHT_SENSOR_DID_UPDATE_EVENT_NAME);

package/build/core/magnetometer-uncalibrated.d.ts

@@ -0,0 +1,10 @@
+import { DeviceSensor } from './device-sensor';
+export type IMagnetometerUncalibratedMeasurement = {
+    x: number;
+    y: number;
+    z: number;
+    timestamp: number;
+};
+export declare class MagnetometerUncalibratedSensor extends DeviceSensor<IMagnetometerUncalibratedMeasurement> {
+}
+export declare const MagnetometerUncalibrated: MagnetometerUncalibratedSensor;

package/build/core/magnetometer-uncalibrated.js

@@ -0,0 +1,6 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentMagnetometerUncalibrated } from './native/exponent-magnetometer-uncalibrated.js';
+export class MagnetometerUncalibratedSensor extends DeviceSensor {
+}
+const MAGNETOMETER_UNCALIBRATED_DID_UPDATE_EVENT_NAME = 'magnetometerUncalibratedDidUpdate';
+export const MagnetometerUncalibrated = new MagnetometerUncalibratedSensor(exponentMagnetometerUncalibrated, MAGNETOMETER_UNCALIBRATED_DID_UPDATE_EVENT_NAME);

package/build/core/magnetometer.d.ts

@@ -0,0 +1,10 @@
+import { DeviceSensor } from './device-sensor';
+export type IMagnetometerMeasurement = {
+    x: number;
+    y: number;
+    z: number;
+    timestamp: number;
+};
+export declare class MagnetometerSensor extends DeviceSensor<IMagnetometerMeasurement> {
+}
+export declare const Magnetometer: MagnetometerSensor;

package/build/core/magnetometer.js

@@ -0,0 +1,6 @@
+import { DeviceSensor } from './device-sensor.js';
+import { exponentMagnetometer } from './native/exponent-magnetometer.js';
+export class MagnetometerSensor extends DeviceSensor {
+}
+const MAGNETOMETER_DID_UPDATE_EVENT_NAME = 'magnetometerDidUpdate';
+export const Magnetometer = new MagnetometerSensor(exponentMagnetometer, MAGNETOMETER_DID_UPDATE_EVENT_NAME);

package/build/core/native/exponent-accelerometer.d.ts

@@ -0,0 +1,3 @@
+import type { INativeSensorModule } from '../device-sensor';
+import type { IAccelerometerMeasurement } from '../accelerometer';
+export declare const exponentAccelerometer: INativeSensorModule<IAccelerometerMeasurement>;

package/build/core/native/exponent-accelerometer.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_ACCELEROMETER_MODULE_NAME = 'ExponentAccelerometer';
+export const exponentAccelerometer = requireNativeModule(EXPONENT_ACCELEROMETER_MODULE_NAME);

package/build/core/native/exponent-barometer.d.ts

@@ -0,0 +1,3 @@
+import type { INativeSensorModule } from '../device-sensor';
+import type { IBarometerMeasurement } from '../barometer';
+export declare const exponentBarometer: INativeSensorModule<IBarometerMeasurement>;

package/build/core/native/exponent-barometer.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_BAROMETER_MODULE_NAME = 'ExpoBarometer';
+export const exponentBarometer = requireNativeModule(EXPO_BAROMETER_MODULE_NAME);

package/build/core/native/exponent-device-motion.d.ts

@@ -0,0 +1,7 @@
+import type { INativeSensorModule } from '../device-sensor';
+import type { IDeviceMotionMeasurement } from '../device-motion';
+type IExponentDeviceMotionModule = INativeSensorModule<IDeviceMotionMeasurement> & {
+    Gravity: number;
+};
+export declare const exponentDeviceMotion: IExponentDeviceMotionModule;
+export {};

package/build/core/native/exponent-device-motion.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_DEVICE_MOTION_MODULE_NAME = 'ExponentDeviceMotion';
+export const exponentDeviceMotion = requireNativeModule(EXPONENT_DEVICE_MOTION_MODULE_NAME);

package/build/core/native/exponent-gyroscope.d.ts

@@ -0,0 +1,3 @@
+import type { INativeSensorModule } from '../device-sensor';
+import type { IGyroscopeMeasurement } from '../gyroscope';
+export declare const exponentGyroscope: INativeSensorModule<IGyroscopeMeasurement>;

package/build/core/native/exponent-gyroscope.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_GYROSCOPE_MODULE_NAME = 'ExponentGyroscope';
+export const exponentGyroscope = requireNativeModule(EXPONENT_GYROSCOPE_MODULE_NAME);

package/build/core/native/exponent-light-sensor/index.android.d.ts

@@ -0,0 +1,3 @@
+import type { INativeSensorModule } from '../../device-sensor';
+import type { ILightSensorMeasurement } from '../../light-sensor';
+export declare const exponentLightSensor: INativeSensorModule<ILightSensorMeasurement>;

package/build/core/native/exponent-light-sensor/index.android.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_LIGHT_SENSOR_MODULE_NAME = 'ExpoLightSensor';
+export const exponentLightSensor = requireNativeModule(EXPONENT_LIGHT_SENSOR_MODULE_NAME);

package/build/core/native/exponent-light-sensor/index.d.ts

@@ -0,0 +1 @@
+export { exponentLightSensor } from './index.ios';

package/build/core/native/exponent-light-sensor/index.ios.d.ts

@@ -0,0 +1,3 @@
+import type { INativeSensorModule } from '../../device-sensor';
+import type { ILightSensorMeasurement } from '../../light-sensor';
+export declare const exponentLightSensor: INativeSensorModule<ILightSensorMeasurement>;

package/build/core/native/exponent-light-sensor/index.ios.js

@@ -0,0 +1,6 @@
+export const exponentLightSensor = {
+    addListener: () => ({ remove: () => { } }),
+    listenerCount: () => 0,
+    removeAllListeners: () => { },
+    isAvailableAsync: async () => false,
+};