@symbiote-native/sensors 0.1.0

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

@@ -0,0 +1,5 @@
+// Base resolution for plain Node/vitest imports of './native/exponent-light-sensor', which
+// don't go through Metro's platform-extension picking — re-exports the iOS stub so headless
+// resolution stays side-effect-free and never calls requireNativeModule() outside a real RN
+// runtime. Metro still picks index.ios.ts/index.android.ts per real platform at bundle time.
+export { exponentLightSensor } from './index.ios.js';

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

@@ -0,0 +1,3 @@
+import type { INativeSensorModule } from '../device-sensor';
+import type { IMagnetometerUncalibratedMeasurement } from '../magnetometer-uncalibrated';
+export declare const exponentMagnetometerUncalibrated: INativeSensorModule<IMagnetometerUncalibratedMeasurement>;

package/build/core/native/exponent-magnetometer-uncalibrated.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_MAGNETOMETER_UNCALIBRATED_MODULE_NAME = 'ExponentMagnetometerUncalibrated';
+export const exponentMagnetometerUncalibrated = requireNativeModule(EXPONENT_MAGNETOMETER_UNCALIBRATED_MODULE_NAME);

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

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

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

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_MAGNETOMETER_MODULE_NAME = 'ExponentMagnetometer';
+export const exponentMagnetometer = requireNativeModule(EXPONENT_MAGNETOMETER_MODULE_NAME);

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

@@ -0,0 +1,10 @@
+import type { EventSubscription, PermissionResponse } from 'expo-modules-core';
+import type { IPedometerResult } from '../pedometer';
+export type IExponentPedometerModule = {
+    addListener(eventName: string, listener: (result: IPedometerResult) => void): EventSubscription;
+    getStepCountAsync?(startMs: number, endMs: number): Promise<IPedometerResult>;
+    isAvailableAsync(): Promise<boolean>;
+    getPermissionsAsync?(): Promise<PermissionResponse>;
+    requestPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare const exponentPedometer: IExponentPedometerModule;

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

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPONENT_PEDOMETER_MODULE_NAME = 'ExponentPedometer';
+export const exponentPedometer = requireNativeModule(EXPONENT_PEDOMETER_MODULE_NAME);

package/build/core/pedometer.d.ts

@@ -0,0 +1,10 @@
+import { type EventSubscription, type PermissionResponse } from 'expo-modules-core';
+export type IPedometerResult = {
+    steps: number;
+};
+export type IPedometerUpdateCallback = (result: IPedometerResult) => void;
+export declare function watchStepCount(callback: IPedometerUpdateCallback): EventSubscription;
+export declare function getStepCountAsync(start: Date, end: Date): Promise<IPedometerResult>;
+export declare function isAvailableAsync(): Promise<boolean>;
+export declare function getPermissionsAsync(): Promise<PermissionResponse>;
+export declare function requestPermissionsAsync(): Promise<PermissionResponse>;

package/build/core/pedometer.js

@@ -0,0 +1,44 @@
+// Pedometer's upstream API (.vendors/expo/packages/expo-sensors/src/Pedometer.ts) is a set of
+// free functions, not a class — unlike every other sensor here it has no shared instance to hang
+// addListener/removeAllListeners/setUpdateInterval off, so it intentionally does NOT extend
+// DeviceSensor (see device-sensor.ts for that shared shape).
+import { PermissionStatus, UnavailabilityError, } from 'expo-modules-core';
+import { exponentPedometer } from './native/exponent-pedometer.js';
+// Upstream event name — the only sensor event in this package carrying a dot, because it is
+// Exponent's original (pre-Expo-rename) native module identifier.
+const PEDOMETER_UPDATE_EVENT_NAME = 'Exponent.pedometerUpdate';
+const DEFAULT_PERMISSION_RESPONSE = {
+    granted: true,
+    expires: 'never',
+    canAskAgain: true,
+    status: PermissionStatus.GRANTED,
+};
+export function watchStepCount(callback) {
+    return exponentPedometer.addListener(PEDOMETER_UPDATE_EVENT_NAME, callback);
+}
+// iOS only in practice (Android has no native getStepCountAsync) — proven by the same
+// optional-native-method check upstream uses, not a Platform.OS branch.
+export async function getStepCountAsync(start, end) {
+    if (!exponentPedometer.getStepCountAsync) {
+        throw new UnavailabilityError('ExponentPedometer', 'getStepCountAsync');
+    }
+    if (start > end) {
+        throw new Error('Pedometer: the start date must precede the end date.');
+    }
+    return exponentPedometer.getStepCountAsync(start.getTime(), end.getTime());
+}
+export async function isAvailableAsync() {
+    return exponentPedometer.isAvailableAsync();
+}
+export async function getPermissionsAsync() {
+    if (!exponentPedometer.getPermissionsAsync) {
+        return DEFAULT_PERMISSION_RESPONSE;
+    }
+    return exponentPedometer.getPermissionsAsync();
+}
+export async function requestPermissionsAsync() {
+    if (!exponentPedometer.requestPermissionsAsync) {
+        return DEFAULT_PERMISSION_RESPONSE;
+    }
+    return exponentPedometer.requestPermissionsAsync();
+}

package/build/react/hooks/use-accelerometer/index.d.ts

@@ -0,0 +1,2 @@
+import { type IAccelerometerMeasurement } from '../../../core';
+export declare function useAccelerometer(updateIntervalMs?: number): IAccelerometerMeasurement | null;

package/build/react/hooks/use-accelerometer/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic Accelerometer singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { Accelerometer } from '../../../core/index.js';
+export function useAccelerometer(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            Accelerometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Accelerometer.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-barometer/index.d.ts

@@ -0,0 +1,2 @@
+import { type IBarometerMeasurement } from '../../../core';
+export declare function useBarometer(updateIntervalMs?: number): IBarometerMeasurement | null;

package/build/react/hooks/use-barometer/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic Barometer singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { Barometer } from '../../../core/index.js';
+export function useBarometer(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            Barometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Barometer.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-device-motion/index.d.ts

@@ -0,0 +1,2 @@
+import { type IDeviceMotionMeasurement } from '../../../core';
+export declare function useDeviceMotion(updateIntervalMs?: number): IDeviceMotionMeasurement | null;

package/build/react/hooks/use-device-motion/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic DeviceMotion singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { DeviceMotion } from '../../../core/index.js';
+export function useDeviceMotion(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            DeviceMotion.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = DeviceMotion.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-gyroscope/index.d.ts

@@ -0,0 +1,2 @@
+import { type IGyroscopeMeasurement } from '../../../core';
+export declare function useGyroscope(updateIntervalMs?: number): IGyroscopeMeasurement | null;

package/build/react/hooks/use-gyroscope/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic Gyroscope singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { Gyroscope } from '../../../core/index.js';
+export function useGyroscope(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            Gyroscope.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Gyroscope.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-light-sensor/index.d.ts

@@ -0,0 +1,2 @@
+import { type ILightSensorMeasurement } from '../../../core';
+export declare function useLightSensor(updateIntervalMs?: number): ILightSensorMeasurement | null;

package/build/react/hooks/use-light-sensor/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic LightSensor singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { LightSensor } from '../../../core/index.js';
+export function useLightSensor(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            LightSensor.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = LightSensor.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-magnetometer/index.d.ts

@@ -0,0 +1,2 @@
+import { type IMagnetometerMeasurement } from '../../../core';
+export declare function useMagnetometer(updateIntervalMs?: number): IMagnetometerMeasurement | null;

package/build/react/hooks/use-magnetometer/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic Magnetometer singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { Magnetometer } from '../../../core/index.js';
+export function useMagnetometer(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            Magnetometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Magnetometer.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-magnetometer-uncalibrated/index.d.ts

@@ -0,0 +1,2 @@
+import { type IMagnetometerUncalibratedMeasurement } from '../../../core';
+export declare function useMagnetometerUncalibrated(updateIntervalMs?: number): IMagnetometerUncalibratedMeasurement | null;

package/build/react/hooks/use-magnetometer-uncalibrated/index.js

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic MagnetometerUncalibrated singleton
+// (core/) — mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
+import { useEffect, useState } from 'react';
+import { MagnetometerUncalibrated } from '../../../core/index.js';
+export function useMagnetometerUncalibrated(updateIntervalMs) {
+    const [measurement, setMeasurement] = useState(null);
+    useEffect(() => {
+        // Re-subscribing on interval change keeps the native update rate in sync with the
+        // caller's latest `updateIntervalMs` rather than only ever honoring the first mount's.
+        if (updateIntervalMs !== undefined) {
+            MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = MagnetometerUncalibrated.addListener(setMeasurement);
+        return () => subscription.remove();
+    }, [updateIntervalMs]);
+    return measurement;
+}

package/build/react/hooks/use-pedometer/index.d.ts

@@ -0,0 +1,2 @@
+import { type IPedometerResult } from '../../../core';
+export declare function usePedometer(): IPedometerResult | null;

package/build/react/hooks/use-pedometer/index.js

@@ -0,0 +1,14 @@
+// React lifecycle wiring over the framework-agnostic watchStepCount free function (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks. Unlike
+// useAccelerometer, Pedometer has no setUpdateInterval, so there is no updateIntervalMs param
+// to sync on re-render.
+import { useEffect, useState } from 'react';
+import { watchStepCount } from '../../../core/index.js';
+export function usePedometer() {
+    const [result, setResult] = useState(null);
+    useEffect(() => {
+        const subscription = watchStepCount(setResult);
+        return () => subscription.remove();
+    }, []);
+    return result;
+}

package/build/react/index.d.ts

@@ -0,0 +1,16 @@
+export { useAccelerometer } from './hooks/use-accelerometer';
+export type { IAccelerometerMeasurement } from '../core';
+export { useBarometer } from './hooks/use-barometer';
+export type { IBarometerMeasurement } from '../core';
+export { useDeviceMotion } from './hooks/use-device-motion';
+export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement } from '../core';
+export { useGyroscope } from './hooks/use-gyroscope';
+export type { IGyroscopeMeasurement } from '../core';
+export { useLightSensor } from './hooks/use-light-sensor';
+export type { ILightSensorMeasurement } from '../core';
+export { useMagnetometer } from './hooks/use-magnetometer';
+export type { IMagnetometerMeasurement } from '../core';
+export { useMagnetometerUncalibrated } from './hooks/use-magnetometer-uncalibrated';
+export type { IMagnetometerUncalibratedMeasurement } from '../core';
+export { usePedometer } from './hooks/use-pedometer';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, type IPedometerResult, type IPedometerUpdateCallback, } from '../core';

package/build/react/index.js

@@ -0,0 +1,14 @@
+// @symbiote-native/sensors/react: the React entry over the framework-agnostic core.
+// useAccelerometer wraps the Accelerometer singleton with React's own lifecycle
+// (hooks/use-accelerometer) — mirrors the lifecycle-bucket naming convention of
+// adapters/react/src/hooks (never `composables`, that's Vue's term).
+export { useAccelerometer } from './hooks/use-accelerometer/index.js';
+export { useBarometer } from './hooks/use-barometer/index.js';
+export { useDeviceMotion } from './hooks/use-device-motion/index.js';
+export { DeviceMotionOrientation, gravity } from '../core/index.js';
+export { useGyroscope } from './hooks/use-gyroscope/index.js';
+export { useLightSensor } from './hooks/use-light-sensor/index.js';
+export { useMagnetometer } from './hooks/use-magnetometer/index.js';
+export { useMagnetometerUncalibrated } from './hooks/use-magnetometer-uncalibrated/index.js';
+export { usePedometer } from './hooks/use-pedometer/index.js';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, } from '../core/index.js';

package/build/vue/composables/use-accelerometer/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IAccelerometerMeasurement } from '../../../core';
+export declare function useAccelerometer(updateIntervalMs?: number): Ref<IAccelerometerMeasurement | null>;

package/build/vue/composables/use-accelerometer/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic Accelerometer singleton (core/) — mirrors
+// the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { Accelerometer, } from '../../../core/index.js';
+export function useAccelerometer(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            Accelerometer.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = Accelerometer.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-barometer/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IBarometerMeasurement } from '../../../core';
+export declare function useBarometer(updateIntervalMs?: number): Ref<IBarometerMeasurement | null>;

package/build/vue/composables/use-barometer/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic Barometer singleton (core/) — mirrors
+// the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { Barometer } from '../../../core/index.js';
+export function useBarometer(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            Barometer.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = Barometer.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-device-motion/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IDeviceMotionMeasurement } from '../../../core';
+export declare function useDeviceMotion(updateIntervalMs?: number): Ref<IDeviceMotionMeasurement | null>;

package/build/vue/composables/use-device-motion/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic DeviceMotion singleton (core/) — mirrors
+// the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { DeviceMotion } from '../../../core/index.js';
+export function useDeviceMotion(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            DeviceMotion.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = DeviceMotion.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-gyroscope/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IGyroscopeMeasurement } from '../../../core';
+export declare function useGyroscope(updateIntervalMs?: number): Ref<IGyroscopeMeasurement | null>;

package/build/vue/composables/use-gyroscope/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic Gyroscope singleton (core/) — mirrors
+// the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { Gyroscope } from '../../../core/index.js';
+export function useGyroscope(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            Gyroscope.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = Gyroscope.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-light-sensor/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type ILightSensorMeasurement } from '../../../core';
+export declare function useLightSensor(updateIntervalMs?: number): Ref<ILightSensorMeasurement | null>;

package/build/vue/composables/use-light-sensor/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic LightSensor singleton (core/) — mirrors
+// the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { LightSensor } from '../../../core/index.js';
+export function useLightSensor(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            LightSensor.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = LightSensor.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-magnetometer/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IMagnetometerMeasurement } from '../../../core';
+export declare function useMagnetometer(updateIntervalMs?: number): Ref<IMagnetometerMeasurement | null>;

package/build/vue/composables/use-magnetometer/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic Magnetometer singleton (core/) — mirrors
+// the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { Magnetometer } from '../../../core/index.js';
+export function useMagnetometer(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            Magnetometer.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = Magnetometer.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-magnetometer-uncalibrated/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IMagnetometerUncalibratedMeasurement } from '../../../core';
+export declare function useMagnetometerUncalibrated(updateIntervalMs?: number): Ref<IMagnetometerUncalibratedMeasurement | null>;

package/build/vue/composables/use-magnetometer-uncalibrated/index.js

@@ -0,0 +1,25 @@
+// Vue lifecycle wiring over the framework-agnostic MagnetometerUncalibrated singleton (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of use-color-scheme.ts's subscription handle. Unlike
+// use-hide-animation.ts (which takes a config getter because its consumer's config changes
+// across reactive updates), this subscribes exactly once at mount and never needs to react to
+// a later change of updateIntervalMs, so a plain numeric param is enough.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { MagnetometerUncalibrated, } from '../../../core/index.js';
+export function useMagnetometerUncalibrated(updateIntervalMs) {
+    // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+    const measurement = ref(null);
+    let subscription;
+    onMounted(() => {
+        if (updateIntervalMs !== undefined) {
+            MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+        }
+        subscription = MagnetometerUncalibrated.addListener(next => {
+            measurement.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return measurement;
+}

package/build/vue/composables/use-pedometer/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type IPedometerResult } from '../../../core';
+export declare function usePedometer(): Ref<IPedometerResult | null>;

package/build/vue/composables/use-pedometer/index.js

@@ -0,0 +1,20 @@
+// Vue lifecycle wiring over the framework-agnostic watchStepCount free function (core/) —
+// mirrors the lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of useAccelerometer. Pedometer has no setUpdateInterval, so
+// unlike useAccelerometer there is no interval param to apply at subscribe time.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { watchStepCount } from '../../../core/index.js';
+export function usePedometer() {
+    // A plain ref: the value is a POJO result, not an engine node, so no shallowRef needed.
+    const result = ref(null);
+    let subscription;
+    onMounted(() => {
+        subscription = watchStepCount(next => {
+            result.value = next;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return result;
+}

package/build/vue/index.d.ts

@@ -0,0 +1,16 @@
+export { useAccelerometer } from './composables/use-accelerometer';
+export type { IAccelerometerMeasurement } from '../core';
+export { useBarometer } from './composables/use-barometer';
+export type { IBarometerMeasurement } from '../core';
+export { useDeviceMotion } from './composables/use-device-motion';
+export { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement } from '../core';
+export { useGyroscope } from './composables/use-gyroscope';
+export type { IGyroscopeMeasurement } from '../core';
+export { useLightSensor } from './composables/use-light-sensor';
+export type { ILightSensorMeasurement } from '../core';
+export { useMagnetometer } from './composables/use-magnetometer';
+export type { IMagnetometerMeasurement } from '../core';
+export { useMagnetometerUncalibrated } from './composables/use-magnetometer-uncalibrated';
+export type { IMagnetometerUncalibratedMeasurement } from '../core';
+export { usePedometer } from './composables/use-pedometer';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, type IPedometerResult, type IPedometerUpdateCallback, } from '../core';

package/build/vue/index.js

@@ -0,0 +1,14 @@
+// @symbiote-native/sensors/vue: the Vue entry over the framework-agnostic core. useAccelerometer
+// wires the Accelerometer singleton's addListener lifecycle onto Vue's own onMounted/onUnmounted
+// (composables/use-accelerometer) — mirrors the lifecycle-bucket naming convention of
+// adapters/vue/src/composables (never `hooks/`, that's React's term).
+export { useAccelerometer } from './composables/use-accelerometer/index.js';
+export { useBarometer } from './composables/use-barometer/index.js';
+export { useDeviceMotion } from './composables/use-device-motion/index.js';
+export { DeviceMotionOrientation, gravity } from '../core/index.js';
+export { useGyroscope } from './composables/use-gyroscope/index.js';
+export { useLightSensor } from './composables/use-light-sensor/index.js';
+export { useMagnetometer } from './composables/use-magnetometer/index.js';
+export { useMagnetometerUncalibrated } from './composables/use-magnetometer-uncalibrated/index.js';
+export { usePedometer } from './composables/use-pedometer/index.js';
+export { watchStepCount, getStepCountAsync, isAvailableAsync, getPermissionsAsync, requestPermissionsAsync, } from '../core/index.js';

package/build-ngc/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';