@symbiote-native/sensors 0.2.1 → 0.4.0

package/build/solid/index.js

@@ -0,0 +1,17 @@
+// @symbiote-native/sensors/solid: the Solid entry over the framework-agnostic core.
+// createAccelerometer wires the Accelerometer singleton's addListener lifecycle onto Solid's own
+// signal + onCleanup (primitives/create-accelerometer) — `primitives/` and `create*` are Solid's
+// terms for a composable reactive function, never `hooks/`/`composables/`/`runes/`, which are
+// React's, Vue's and Svelte's. Same convention as adapters/solid/src/primitives.
+//
+// Every primitive returns an `Accessor`, and each DeviceSensor-shaped one takes its update
+// interval as a number OR an accessor — see primitives/device-sensor-accessor for why.
+export { createAccelerometer } from './primitives/create-accelerometer.js';
+export { createBarometer } from './primitives/create-barometer.js';
+export { createDeviceMotion } from './primitives/create-device-motion.js';
+export { createGyroscope } from './primitives/create-gyroscope.js';
+export { createLightSensor } from './primitives/create-light-sensor.js';
+export { createMagnetometer } from './primitives/create-magnetometer.js';
+export { createMagnetometerUncalibrated } from './primitives/create-magnetometer-uncalibrated.js';
+export { createPedometer } from './primitives/create-pedometer.js';
+export * from '../core/index.js';

package/build/solid/primitives/create-accelerometer.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IAccelerometerMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createAccelerometer(updateIntervalMs?: IUpdateIntervalMs): Accessor<IAccelerometerMeasurement | null>;

package/build/solid/primitives/create-accelerometer.js

@@ -0,0 +1,5 @@
+import { Accelerometer } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createAccelerometer(updateIntervalMs) {
+    return createDeviceSensorAccessor(Accelerometer, updateIntervalMs);
+}

package/build/solid/primitives/create-barometer.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IBarometerMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createBarometer(updateIntervalMs?: IUpdateIntervalMs): Accessor<IBarometerMeasurement | null>;

package/build/solid/primitives/create-barometer.js

@@ -0,0 +1,5 @@
+import { Barometer } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createBarometer(updateIntervalMs) {
+    return createDeviceSensorAccessor(Barometer, updateIntervalMs);
+}

package/build/solid/primitives/create-device-motion.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IDeviceMotionMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createDeviceMotion(updateIntervalMs?: IUpdateIntervalMs): Accessor<IDeviceMotionMeasurement | null>;

package/build/solid/primitives/create-device-motion.js

@@ -0,0 +1,5 @@
+import { DeviceMotion } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createDeviceMotion(updateIntervalMs) {
+    return createDeviceSensorAccessor(DeviceMotion, updateIntervalMs);
+}

package/build/solid/primitives/create-gyroscope.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IGyroscopeMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createGyroscope(updateIntervalMs?: IUpdateIntervalMs): Accessor<IGyroscopeMeasurement | null>;

package/build/solid/primitives/create-gyroscope.js

@@ -0,0 +1,5 @@
+import { Gyroscope } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createGyroscope(updateIntervalMs) {
+    return createDeviceSensorAccessor(Gyroscope, updateIntervalMs);
+}

package/build/solid/primitives/create-light-sensor.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type ILightSensorMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createLightSensor(updateIntervalMs?: IUpdateIntervalMs): Accessor<ILightSensorMeasurement | null>;

package/build/solid/primitives/create-light-sensor.js

@@ -0,0 +1,5 @@
+import { LightSensor } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createLightSensor(updateIntervalMs) {
+    return createDeviceSensorAccessor(LightSensor, updateIntervalMs);
+}

package/build/solid/primitives/create-magnetometer-uncalibrated.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IMagnetometerUncalibratedMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createMagnetometerUncalibrated(updateIntervalMs?: IUpdateIntervalMs): Accessor<IMagnetometerUncalibratedMeasurement | null>;

package/build/solid/primitives/create-magnetometer-uncalibrated.js

@@ -0,0 +1,5 @@
+import { MagnetometerUncalibrated, } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createMagnetometerUncalibrated(updateIntervalMs) {
+    return createDeviceSensorAccessor(MagnetometerUncalibrated, updateIntervalMs);
+}

package/build/solid/primitives/create-magnetometer.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import { type IMagnetometerMeasurement } from '../../core';
+import { type IUpdateIntervalMs } from './device-sensor-accessor';
+export declare function createMagnetometer(updateIntervalMs?: IUpdateIntervalMs): Accessor<IMagnetometerMeasurement | null>;

package/build/solid/primitives/create-magnetometer.js

@@ -0,0 +1,5 @@
+import { Magnetometer } from '../../core/index.js';
+import { createDeviceSensorAccessor, } from './device-sensor-accessor.js';
+export function createMagnetometer(updateIntervalMs) {
+    return createDeviceSensorAccessor(Magnetometer, updateIntervalMs);
+}

package/build/solid/primitives/create-pedometer.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+import { type IPedometerResult } from '../../core';
+export declare function createPedometer(): Accessor<IPedometerResult | null>;

package/build/solid/primitives/create-pedometer.js

@@ -0,0 +1,22 @@
+// Solid lifecycle wiring over the framework-agnostic watchStepCount free function (core/) — the
+// Solid twin of react/hooks/use-pedometer, vue/composables/use-pedometer and
+// svelte/runes/use-pedometer.svelte.ts. Pedometer is the one sensor here that is not a
+// DeviceSensor subclass (core/pedometer.ts's header), so it has no setUpdateInterval and takes no
+// interval argument — hence its own body instead of ./device-sensor-accessor.
+//
+// `primitives/` and `create*`, and an ACCESSOR rather than a snapshot, for the reasons recorded in
+// adapters/solid/src/primitives/create-color-scheme.ts.
+import { createSignal, onCleanup } from 'solid-js';
+import { watchStepCount, } from '../../core/index.js';
+export function createPedometer() {
+    const [result, setResult] = createSignal(null);
+    // Subscribed from the primitive body, not from an effect: React/Vue/Svelte start listening a
+    // tick after their seed runs, so a step count landing in that window is lost.
+    const subscription = watchStepCount(next => {
+        setResult(next);
+    });
+    onCleanup(() => {
+        subscription.remove();
+    });
+    return result;
+}

package/build/solid/primitives/device-sensor-accessor.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor } from 'solid-js';
+import type { EventSubscription, IListener } from '../../core';
+export type IUpdateIntervalMs = number | Accessor<number | undefined> | undefined;
+type ISensorHandle<Measurement> = {
+    addListener(listener: IListener<Measurement>): EventSubscription;
+    setUpdateInterval(intervalMs: number): void;
+};
+export declare function createDeviceSensorAccessor<Measurement>(sensor: ISensorHandle<Measurement>, updateIntervalMs?: IUpdateIntervalMs): Accessor<Measurement | null>;
+export {};

package/build/solid/primitives/device-sensor-accessor.js

@@ -0,0 +1,66 @@
+// The one lifecycle body every DeviceSensor-shaped primitive in this folder delegates to
+// (Accelerometer, Barometer, DeviceMotion, Gyroscope, LightSensor, Magnetometer,
+// MagnetometerUncalibrated). Internal — not re-exported from ../index.ts, whose surface stays at
+// parity with the react/vue/svelte entries.
+//
+// `primitives/` and `create*`, never `hooks/` + `use*`: Solid's ecosystem calls a composable
+// reactive function a PRIMITIVE and reserves `use*` for consuming something that already exists.
+// Full rationale in adapters/solid/src/primitives/create-color-scheme.ts.
+//
+// Returns an ACCESSOR, never a snapshot: a Solid component body runs ONCE, so a returned
+// measurement would pin the caller to `null` forever.
+//
+// ## Why the interval is `number | Accessor<number | undefined>`
+//
+// React re-reads `updateIntervalMs` on every render and re-runs its effect when it changes; Vue
+// and Svelte read it once at subscribe time. Neither shape ports: a Solid body runs once, so a
+// plain parameter freezes the sample rate at whatever the caller passed at mount, and nothing
+// reports it — the caller's `intervalMs` state moves and the native rate does not. So the
+// parameter accepts EITHER form (solid-primitives' `MaybeAccessor` convention): a literal for the
+// common static case, keeping the call site identical to the other adapters, or an accessor when
+// the rate is derived from state. The accessor form is the reactive one and is the only one that
+// creates an effect.
+//
+// Applying it splits in two on purpose. The mount-time value is applied SYNCHRONOUSLY, before
+// `addListener`, so the very first native sample already arrives at the requested rate; the
+// tracking effect is then `defer`red so it fires only on a LATER change. Without the defer the
+// interval would be set twice at mount, and the second call would land a tick after the first
+// samples.
+//
+// Outside a component or `createRoot` there is no owner for `onCleanup` — Solid warns and the
+// native listener lives for the process. The accessor still tracks; only the teardown is lost.
+import { createEffect, createSignal, on, onCleanup, untrack, } from 'solid-js';
+export function createDeviceSensorAccessor(sensor, updateIntervalMs) {
+    const [measurement, setMeasurement] = createSignal(null);
+    function applyInterval(intervalMs) {
+        // `!== undefined`, not truthiness: 0 is a legitimate "as fast as possible" rate, and an
+        // unconditional call would stomp the rate another consumer of this shared singleton set.
+        if (intervalMs !== undefined) {
+            sensor.setUpdateInterval(intervalMs);
+        }
+    }
+    // untracked: a primitive built inside a tracked scope must not re-run — and re-subscribe —
+    // just because it read the caller's interval accessor once.
+    applyInterval(untrack(() => typeof updateIntervalMs === 'function'
+        ? updateIntervalMs()
+        : updateIntervalMs));
+    // Subscribed from the primitive body, not from an effect: React/Vue/Svelte start listening a
+    // tick after their seed runs, so an event landing in that window is lost. Both statements here
+    // run in one synchronous tick and nothing can interleave.
+    const subscription = sensor.addListener(next => {
+        // The updater form, because `Measurement` is unconstrained — a bare value would be read as a
+        // reducer for any measurement type that could itself be callable.
+        setMeasurement(() => next);
+    });
+    onCleanup(() => {
+        subscription.remove();
+    });
+    if (typeof updateIntervalMs === 'function') {
+        // Only the rate changes — the native listener is per-sensor and unaffected, so re-subscribing
+        // (as React's interval-keyed effect does) would drop events for nothing.
+        createEffect(on(updateIntervalMs, intervalMs => {
+            applyInterval(intervalMs);
+        }, { defer: true }));
+    }
+    return measurement;
+}

package/build/svelte/index.d.ts

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

package/build/svelte/index.js

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

package/build/svelte/runes/use-accelerometer.svelte.d.ts

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

package/build/svelte/runes/use-accelerometer.svelte.js

@@ -0,0 +1,31 @@
+// Svelte lifecycle wiring over the framework-agnostic Accelerometer singleton (core/).
+// `.svelte.ts` (not `.ts`): runes ($state/$effect) only work in files with this extension
+// outside an actual `.svelte` component; `runes/` is the framework's own lifecycle-bucket term
+// (CLAUDE.md's <adapter_src_follows_framework_idioms>).
+//
+// Returns a boxed getter, not a bare `$state`: Svelte 5 reactivity is lexically scoped to the
+// declaring module and doesn't survive being returned as a raw value, so callers read `.current`
+// like unwrapping Vue's `Ref.value`.
+//
+// `updateIntervalMs` is a plain number, not a getter: it applies once at subscribe time and
+// never reacts to a later change, matching the Vue/React twins.
+import { Accelerometer, } from '../../core/index.js';
+export function useAccelerometer(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Accelerometer.setUpdateInterval(updateIntervalMs);
+        }
+        // `measurement` is only ever written here, never read, so the effect has an empty dependency
+        // set and runs exactly once on mount, cleaning up exactly once on unmount.
+        const subscription = Accelerometer.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-barometer.svelte.d.ts

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

package/build/svelte/runes/use-barometer.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic Barometer singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { Barometer, } from '../../core/index.js';
+export function useBarometer(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Barometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Barometer.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-device-motion.svelte.d.ts

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

package/build/svelte/runes/use-device-motion.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic DeviceMotion singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { DeviceMotion, } from '../../core/index.js';
+export function useDeviceMotion(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            DeviceMotion.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = DeviceMotion.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-gyroscope.svelte.d.ts

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

package/build/svelte/runes/use-gyroscope.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic Gyroscope singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { Gyroscope, } from '../../core/index.js';
+export function useGyroscope(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Gyroscope.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Gyroscope.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-light-sensor.svelte.d.ts

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

package/build/svelte/runes/use-light-sensor.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic LightSensor singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { LightSensor, } from '../../core/index.js';
+export function useLightSensor(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            LightSensor.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = LightSensor.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-magnetometer-uncalibrated.svelte.d.ts

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

package/build/svelte/runes/use-magnetometer-uncalibrated.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic MagnetometerUncalibrated singleton (core/) —
+// mirrors use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in
+// `runes/` with a `.svelte.ts` extension, returns a boxed getter object, and takes a plain
+// `updateIntervalMs` rather than a getter.
+import { MagnetometerUncalibrated, } from '../../core/index.js';
+export function useMagnetometerUncalibrated(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = MagnetometerUncalibrated.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-magnetometer.svelte.d.ts

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

package/build/svelte/runes/use-magnetometer.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic Magnetometer singleton (core/) — mirrors
+// use-accelerometer.svelte.ts's shape exactly. See its header for why this lives in `runes/` with
+// a `.svelte.ts` extension, returns a boxed getter object, and takes a plain `updateIntervalMs`
+// rather than a getter.
+import { Magnetometer, } from '../../core/index.js';
+export function useMagnetometer(updateIntervalMs) {
+    let measurement = $state(null);
+    $effect(() => {
+        if (updateIntervalMs !== undefined) {
+            Magnetometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Magnetometer.addListener(next => {
+            measurement = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return measurement;
+        },
+    };
+}

package/build/svelte/runes/use-pedometer.svelte.d.ts

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

package/build/svelte/runes/use-pedometer.svelte.js

@@ -0,0 +1,20 @@
+// Svelte lifecycle wiring over the framework-agnostic watchStepCount free function (core/) —
+// mirrors use-accelerometer.svelte.ts's shape. Pedometer has no setUpdateInterval, so unlike
+// useAccelerometer there is no interval param to apply at subscribe time. See
+// use-accelerometer.svelte.ts's header for why this lives in `runes/` with a `.svelte.ts`
+// extension and returns a boxed getter object.
+import { watchStepCount, } from '../../core/index.js';
+export function usePedometer() {
+    let result = $state(null);
+    $effect(() => {
+        const subscription = watchStepCount(next => {
+            result = next;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return result;
+        },
+    };
+}

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

@@ -5,7 +5,7 @@
 // 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';
+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);

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

@@ -5,7 +5,7 @@
 // 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';
+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);

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

@@ -5,7 +5,7 @@
 // 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';
+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);

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

@@ -5,7 +5,7 @@
 // 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';
+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);

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

@@ -5,7 +5,7 @@
 // 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';
+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);

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

@@ -3,7 +3,7 @@
 // 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';
+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);

package/build/vue/index.d.ts

@@ -3,7 +3,7 @@ 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 { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement, } from '../core';
 export { useGyroscope } from './composables/use-gyroscope';
 export type { IGyroscopeMeasurement } from '../core';
 export { useLightSensor } from './composables/use-light-sensor';

package/build/vue/index.js

@@ -5,7 +5,7 @@
 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 { 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';

package/build-ngc/angular/index.d.ts

@@ -3,7 +3,7 @@ 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 { DeviceMotionOrientation, gravity, type IDeviceMotionMeasurement, } from '../core';
 export { GyroscopeService } from './services/gyroscope.service';
 export type { IGyroscopeMeasurement } from '../core';
 export { LightSensorService } from './services/light-sensor.service';

package/build-ngc/angular/index.js

@@ -3,7 +3,7 @@
 export { AccelerometerService } from './services/accelerometer.service';
 export { BarometerService } from './services/barometer.service';
 export { DeviceMotionService } from './services/device-motion.service';
-export { DeviceMotionOrientation, gravity } from '../core';
+export { DeviceMotionOrientation, gravity, } from '../core';
 export { GyroscopeService } from './services/gyroscope.service';
 export { LightSensorService } from './services/light-sensor.service';
 export { MagnetometerService } from './services/magnetometer.service';

package/build-ngc/angular/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,iEAAiE;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,OAAO,EAAiC,MAAM,SAAS,CAAC;AAC1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAE/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,uBAAuB,GAGxB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,iEAAiE;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EACL,uBAAuB,EACvB,OAAO,GAER,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAE/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,uBAAuB,GAGxB,MAAM,SAAS,CAAC"}