@symbiote-native/sensors 0.2.1 → 0.4.0

package/src/svelte/index.ts

@@ -0,0 +1,33 @@
+// @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 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/src/svelte/runes/use-accelerometer.svelte.ts

@@ -0,0 +1,40 @@
+// 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,
+  type EventSubscription,
+  type IAccelerometerMeasurement,
+} from '../../core';
+
+export function useAccelerometer(updateIntervalMs?: number): {
+  readonly current: IAccelerometerMeasurement | null;
+} {
+  let measurement = $state<IAccelerometerMeasurement | null>(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: EventSubscription = Accelerometer.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IAccelerometerMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-barometer.svelte.ts

@@ -0,0 +1,31 @@
+// 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,
+  type EventSubscription,
+  type IBarometerMeasurement,
+} from '../../core';
+
+export function useBarometer(updateIntervalMs?: number): {
+  readonly current: IBarometerMeasurement | null;
+} {
+  let measurement = $state<IBarometerMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      Barometer.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = Barometer.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IBarometerMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-device-motion.svelte.ts

@@ -0,0 +1,31 @@
+// 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,
+  type EventSubscription,
+  type IDeviceMotionMeasurement,
+} from '../../core';
+
+export function useDeviceMotion(updateIntervalMs?: number): {
+  readonly current: IDeviceMotionMeasurement | null;
+} {
+  let measurement = $state<IDeviceMotionMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      DeviceMotion.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = DeviceMotion.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IDeviceMotionMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-gyroscope.svelte.ts

@@ -0,0 +1,31 @@
+// 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,
+  type EventSubscription,
+  type IGyroscopeMeasurement,
+} from '../../core';
+
+export function useGyroscope(updateIntervalMs?: number): {
+  readonly current: IGyroscopeMeasurement | null;
+} {
+  let measurement = $state<IGyroscopeMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      Gyroscope.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = Gyroscope.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IGyroscopeMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-light-sensor.svelte.ts

@@ -0,0 +1,31 @@
+// 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,
+  type EventSubscription,
+  type ILightSensorMeasurement,
+} from '../../core';
+
+export function useLightSensor(updateIntervalMs?: number): {
+  readonly current: ILightSensorMeasurement | null;
+} {
+  let measurement = $state<ILightSensorMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      LightSensor.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = LightSensor.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): ILightSensorMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-magnetometer-uncalibrated.svelte.ts

@@ -0,0 +1,32 @@
+// 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,
+  type EventSubscription,
+  type IMagnetometerUncalibratedMeasurement,
+} from '../../core';
+
+export function useMagnetometerUncalibrated(updateIntervalMs?: number): {
+  readonly current: IMagnetometerUncalibratedMeasurement | null;
+} {
+  let measurement = $state<IMagnetometerUncalibratedMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription =
+      MagnetometerUncalibrated.addListener(next => {
+        measurement = next;
+      });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IMagnetometerUncalibratedMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-magnetometer.svelte.ts

@@ -0,0 +1,31 @@
+// 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,
+  type EventSubscription,
+  type IMagnetometerMeasurement,
+} from '../../core';
+
+export function useMagnetometer(updateIntervalMs?: number): {
+  readonly current: IMagnetometerMeasurement | null;
+} {
+  let measurement = $state<IMagnetometerMeasurement | null>(null);
+
+  $effect(() => {
+    if (updateIntervalMs !== undefined) {
+      Magnetometer.setUpdateInterval(updateIntervalMs);
+    }
+    const subscription: EventSubscription = Magnetometer.addListener(next => {
+      measurement = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IMagnetometerMeasurement | null {
+      return measurement;
+    },
+  };
+}

package/src/svelte/runes/use-pedometer.svelte.ts

@@ -0,0 +1,27 @@
+// 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,
+  type EventSubscription,
+  type IPedometerResult,
+} from '../../core';
+
+export function usePedometer(): { readonly current: IPedometerResult | null } {
+  let result = $state<IPedometerResult | null>(null);
+
+  $effect(() => {
+    const subscription: EventSubscription = watchStepCount(next => {
+      result = next;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): IPedometerResult | null {
+      return result;
+    },
+  };
+}

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,6 @@
+// Pulls in svelte's ambient global declarations ($state/$effect/...) for this package's tsc
+// program. adapters/svelte gets these for free because render.ts does a real value import from
+// 'svelte' (any file in a program importing a module loads its ambient globals for the whole
+// program); this package has no such import, so a triple-slash reference does the same job
+// explicitly rather than relying on an incidental side-effect.
+/// <reference types="svelte" />

package/src/vue/composables/use-accelerometer/index.ts

@@ -12,7 +12,9 @@ import {
   type IAccelerometerMeasurement,
 } from '../../../core';
 
-export function useAccelerometer(updateIntervalMs?: number): Ref<IAccelerometerMeasurement | null> {
+export function useAccelerometer(
+  updateIntervalMs?: number,
+): Ref<IAccelerometerMeasurement | null> {
   // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
   const measurement = ref<IAccelerometerMeasurement | null>(null);
   let subscription: EventSubscription | undefined;

package/src/vue/composables/use-barometer/index.ts

@@ -6,9 +6,15 @@
 // a later change of updateIntervalMs, so a plain numeric param is enough.
 
 import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
-import { Barometer, type EventSubscription, type IBarometerMeasurement } from '../../../core';
+import {
+  Barometer,
+  type EventSubscription,
+  type IBarometerMeasurement,
+} from '../../../core';
 
-export function useBarometer(updateIntervalMs?: number): Ref<IBarometerMeasurement | null> {
+export function useBarometer(
+  updateIntervalMs?: number,
+): Ref<IBarometerMeasurement | null> {
   // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
   const measurement = ref<IBarometerMeasurement | null>(null);
   let subscription: EventSubscription | undefined;

package/src/vue/composables/use-device-motion/index.ts

@@ -6,9 +6,15 @@
 // a later change of updateIntervalMs, so a plain numeric param is enough.
 
 import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
-import { DeviceMotion, type EventSubscription, type IDeviceMotionMeasurement } from '../../../core';
+import {
+  DeviceMotion,
+  type EventSubscription,
+  type IDeviceMotionMeasurement,
+} from '../../../core';
 
-export function useDeviceMotion(updateIntervalMs?: number): Ref<IDeviceMotionMeasurement | null> {
+export function useDeviceMotion(
+  updateIntervalMs?: number,
+): Ref<IDeviceMotionMeasurement | null> {
   // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
   const measurement = ref<IDeviceMotionMeasurement | null>(null);
   let subscription: EventSubscription | undefined;

package/src/vue/composables/use-gyroscope/index.ts

@@ -6,9 +6,15 @@
 // a later change of updateIntervalMs, so a plain numeric param is enough.
 
 import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
-import { Gyroscope, type EventSubscription, type IGyroscopeMeasurement } from '../../../core';
+import {
+  Gyroscope,
+  type EventSubscription,
+  type IGyroscopeMeasurement,
+} from '../../../core';
 
-export function useGyroscope(updateIntervalMs?: number): Ref<IGyroscopeMeasurement | null> {
+export function useGyroscope(
+  updateIntervalMs?: number,
+): Ref<IGyroscopeMeasurement | null> {
   // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
   const measurement = ref<IGyroscopeMeasurement | null>(null);
   let subscription: EventSubscription | undefined;

package/src/vue/composables/use-light-sensor/index.ts

@@ -6,9 +6,15 @@
 // a later change of updateIntervalMs, so a plain numeric param is enough.
 
 import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
-import { LightSensor, type EventSubscription, type ILightSensorMeasurement } from '../../../core';
+import {
+  LightSensor,
+  type EventSubscription,
+  type ILightSensorMeasurement,
+} from '../../../core';
 
-export function useLightSensor(updateIntervalMs?: number): Ref<ILightSensorMeasurement | null> {
+export function useLightSensor(
+  updateIntervalMs?: number,
+): Ref<ILightSensorMeasurement | null> {
   // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
   const measurement = ref<ILightSensorMeasurement | null>(null);
   let subscription: EventSubscription | undefined;

package/src/vue/composables/use-magnetometer/index.ts

@@ -6,9 +6,15 @@
 // a later change of updateIntervalMs, so a plain numeric param is enough.
 
 import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
-import { Magnetometer, type EventSubscription, type IMagnetometerMeasurement } from '../../../core';
+import {
+  Magnetometer,
+  type EventSubscription,
+  type IMagnetometerMeasurement,
+} from '../../../core';
 
-export function useMagnetometer(updateIntervalMs?: number): Ref<IMagnetometerMeasurement | null> {
+export function useMagnetometer(
+  updateIntervalMs?: number,
+): Ref<IMagnetometerMeasurement | null> {
   // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
   const measurement = ref<IMagnetometerMeasurement | null>(null);
   let subscription: EventSubscription | undefined;

package/src/vue/composables/use-pedometer/index.ts

@@ -4,7 +4,11 @@
 // unlike useAccelerometer there is no interval param to apply at subscribe time.
 
 import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
-import { watchStepCount, type EventSubscription, type IPedometerResult } from '../../../core';
+import {
+  watchStepCount,
+  type EventSubscription,
+  type IPedometerResult,
+} from '../../../core';
 
 export function usePedometer(): Ref<IPedometerResult | null> {
   // A plain ref: the value is a POJO result, not an engine node, so no shallowRef needed.

package/src/vue/index.ts

@@ -8,7 +8,11 @@ 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';