@symbiote-native/sensors 0.2.1 → 0.4.0

package/src/core/device-sensor.ts

@@ -13,7 +13,10 @@ import {
 export type IListener<Measurement> = (measurement: Measurement) => void;
 
 export type INativeSensorModule<Measurement> = {
-  addListener(eventName: string, listener: IListener<Measurement>): EventSubscription;
+  addListener(
+    eventName: string,
+    listener: IListener<Measurement>,
+  ): EventSubscription;
   listenerCount(eventName: string): number;
   removeAllListeners(eventName: string): void;
   setUpdateInterval?(intervalMs: number): void;
@@ -33,7 +36,10 @@ export class DeviceSensor<Measurement> {
   readonly nativeModule: INativeSensorModule<Measurement>;
   readonly nativeEventName: string;
 
-  constructor(nativeModule: INativeSensorModule<Measurement>, nativeEventName: string) {
+  constructor(
+    nativeModule: INativeSensorModule<Measurement>,
+    nativeEventName: string,
+  ) {
     this.nativeModule = nativeModule;
     this.nativeEventName = nativeEventName;
   }

package/src/core/gyroscope.ts

@@ -13,4 +13,7 @@ export class GyroscopeSensor extends DeviceSensor<IGyroscopeMeasurement> {}
 
 const GYROSCOPE_DID_UPDATE_EVENT_NAME = 'gyroscopeDidUpdate';
 
-export const Gyroscope = new GyroscopeSensor(exponentGyroscope, GYROSCOPE_DID_UPDATE_EVENT_NAME);
+export const Gyroscope = new GyroscopeSensor(
+  exponentGyroscope,
+  GYROSCOPE_DID_UPDATE_EVENT_NAME,
+);

package/src/core/index.ts

@@ -3,7 +3,11 @@ export {
   AccelerometerSensor,
   type IAccelerometerMeasurement,
 } from './accelerometer';
-export { Barometer, BarometerSensor, type IBarometerMeasurement } from './barometer';
+export {
+  Barometer,
+  BarometerSensor,
+  type IBarometerMeasurement,
+} from './barometer';
 export {
   DeviceMotion,
   DeviceMotionSensor,
@@ -11,9 +15,21 @@ export {
   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 {
+  Gyroscope,
+  GyroscopeSensor,
+  type IGyroscopeMeasurement,
+} from './gyroscope';
+export {
+  LightSensor,
+  LightSensorSensor,
+  type ILightSensorMeasurement,
+} from './light-sensor';
+export {
+  Magnetometer,
+  MagnetometerSensor,
+  type IMagnetometerMeasurement,
+} from './magnetometer';
 export {
   MagnetometerUncalibrated,
   MagnetometerUncalibratedSensor,
@@ -28,7 +44,11 @@ export {
   type IPedometerResult,
   type IPedometerUpdateCallback,
 } from './pedometer';
-export { DeviceSensor, type IListener, type INativeSensorModule } from './device-sensor';
+export {
+  DeviceSensor,
+  type IListener,
+  type INativeSensorModule,
+} from './device-sensor';
 export type {
   EventSubscription,
   PermissionExpiration,

package/src/core/magnetometer-uncalibrated.ts

@@ -12,7 +12,8 @@ export type IMagnetometerUncalibratedMeasurement = {
 
 export class MagnetometerUncalibratedSensor extends DeviceSensor<IMagnetometerUncalibratedMeasurement> {}
 
-const MAGNETOMETER_UNCALIBRATED_DID_UPDATE_EVENT_NAME = 'magnetometerUncalibratedDidUpdate';
+const MAGNETOMETER_UNCALIBRATED_DID_UPDATE_EVENT_NAME =
+  'magnetometerUncalibratedDidUpdate';
 
 export const MagnetometerUncalibrated = new MagnetometerUncalibratedSensor(
   exponentMagnetometerUncalibrated,

package/src/core/native/exponent-barometer.ts

@@ -4,6 +4,6 @@ import type { IBarometerMeasurement } from '../barometer';
 
 const EXPO_BAROMETER_MODULE_NAME = 'ExpoBarometer';
 
-export const exponentBarometer = requireNativeModule<INativeSensorModule<IBarometerMeasurement>>(
-  EXPO_BAROMETER_MODULE_NAME,
-);
+export const exponentBarometer = requireNativeModule<
+  INativeSensorModule<IBarometerMeasurement>
+>(EXPO_BAROMETER_MODULE_NAME);

package/src/core/native/exponent-device-motion.ts

@@ -6,10 +6,12 @@ const EXPONENT_DEVICE_MOTION_MODULE_NAME = 'ExponentDeviceMotion';
 
 // The native module also exposes a `Gravity` numeric constant (standard gravitational
 // acceleration, 9.80665 m/s^2) alongside the shared sensor surface.
-type IExponentDeviceMotionModule = INativeSensorModule<IDeviceMotionMeasurement> & {
-  Gravity: number;
-};
+type IExponentDeviceMotionModule =
+  INativeSensorModule<IDeviceMotionMeasurement> & {
+    Gravity: number;
+  };
 
-export const exponentDeviceMotion = requireNativeModule<IExponentDeviceMotionModule>(
-  EXPONENT_DEVICE_MOTION_MODULE_NAME,
-);
+export const exponentDeviceMotion =
+  requireNativeModule<IExponentDeviceMotionModule>(
+    EXPONENT_DEVICE_MOTION_MODULE_NAME,
+  );

package/src/core/native/exponent-gyroscope.ts

@@ -4,6 +4,6 @@ import type { IGyroscopeMeasurement } from '../gyroscope';
 
 const EXPONENT_GYROSCOPE_MODULE_NAME = 'ExponentGyroscope';
 
-export const exponentGyroscope = requireNativeModule<INativeSensorModule<IGyroscopeMeasurement>>(
-  EXPONENT_GYROSCOPE_MODULE_NAME,
-);
+export const exponentGyroscope = requireNativeModule<
+  INativeSensorModule<IGyroscopeMeasurement>
+>(EXPONENT_GYROSCOPE_MODULE_NAME);

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

@@ -4,9 +4,10 @@
 import type { INativeSensorModule } from '../../device-sensor';
 import type { ILightSensorMeasurement } from '../../light-sensor';
 
-export const exponentLightSensor: INativeSensorModule<ILightSensorMeasurement> = {
-  addListener: () => ({ remove: () => {} }),
-  listenerCount: () => 0,
-  removeAllListeners: () => {},
-  isAvailableAsync: async () => false,
-};
+export const exponentLightSensor: INativeSensorModule<ILightSensorMeasurement> =
+  {
+    addListener: () => ({ remove: () => {} }),
+    listenerCount: () => 0,
+    removeAllListeners: () => {},
+    isAvailableAsync: async () => false,
+  };

package/src/core/native/exponent-magnetometer-uncalibrated.ts

@@ -2,7 +2,8 @@ import { requireNativeModule } from 'expo-modules-core';
 import type { INativeSensorModule } from '../device-sensor';
 import type { IMagnetometerUncalibratedMeasurement } from '../magnetometer-uncalibrated';
 
-const EXPONENT_MAGNETOMETER_UNCALIBRATED_MODULE_NAME = 'ExponentMagnetometerUncalibrated';
+const EXPONENT_MAGNETOMETER_UNCALIBRATED_MODULE_NAME =
+  'ExponentMagnetometerUncalibrated';
 
 export const exponentMagnetometerUncalibrated = requireNativeModule<
   INativeSensorModule<IMagnetometerUncalibratedMeasurement>

package/src/core/native/exponent-pedometer.ts

@@ -5,7 +5,10 @@ import type { IPedometerResult } from '../pedometer';
 const EXPONENT_PEDOMETER_MODULE_NAME = 'ExponentPedometer';
 
 export type IExponentPedometerModule = {
-  addListener(eventName: string, listener: (result: IPedometerResult) => void): EventSubscription;
+  addListener(
+    eventName: string,
+    listener: (result: IPedometerResult) => void,
+  ): EventSubscription;
   getStepCountAsync?(startMs: number, endMs: number): Promise<IPedometerResult>;
   isAvailableAsync(): Promise<boolean>;
   getPermissionsAsync?(): Promise<PermissionResponse>;

package/src/core/pedometer.ts

@@ -27,13 +27,18 @@ const DEFAULT_PERMISSION_RESPONSE: PermissionResponse = {
   status: PermissionStatus.GRANTED,
 };
 
-export function watchStepCount(callback: IPedometerUpdateCallback): EventSubscription {
+export function watchStepCount(
+  callback: IPedometerUpdateCallback,
+): EventSubscription {
   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: Date, end: Date): Promise<IPedometerResult> {
+export async function getStepCountAsync(
+  start: Date,
+  end: Date,
+): Promise<IPedometerResult> {
   if (!exponentPedometer.getStepCountAsync) {
     throw new UnavailabilityError('ExponentPedometer', 'getStepCountAsync');
   }

package/src/react/hooks/use-accelerometer/index.ts

@@ -3,8 +3,11 @@
 import { useEffect, useState } from 'react';
 import { Accelerometer, type IAccelerometerMeasurement } from '../../../core';
 
-export function useAccelerometer(updateIntervalMs?: number): IAccelerometerMeasurement | null {
-  const [measurement, setMeasurement] = useState<IAccelerometerMeasurement | null>(null);
+export function useAccelerometer(
+  updateIntervalMs?: number,
+): IAccelerometerMeasurement | null {
+  const [measurement, setMeasurement] =
+    useState<IAccelerometerMeasurement | null>(null);
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/hooks/use-barometer/index.ts

@@ -3,8 +3,12 @@
 import { useEffect, useState } from 'react';
 import { Barometer, type IBarometerMeasurement } from '../../../core';
 
-export function useBarometer(updateIntervalMs?: number): IBarometerMeasurement | null {
-  const [measurement, setMeasurement] = useState<IBarometerMeasurement | null>(null);
+export function useBarometer(
+  updateIntervalMs?: number,
+): IBarometerMeasurement | null {
+  const [measurement, setMeasurement] = useState<IBarometerMeasurement | null>(
+    null,
+  );
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/hooks/use-device-motion/index.ts

@@ -3,8 +3,11 @@
 import { useEffect, useState } from 'react';
 import { DeviceMotion, type IDeviceMotionMeasurement } from '../../../core';
 
-export function useDeviceMotion(updateIntervalMs?: number): IDeviceMotionMeasurement | null {
-  const [measurement, setMeasurement] = useState<IDeviceMotionMeasurement | null>(null);
+export function useDeviceMotion(
+  updateIntervalMs?: number,
+): IDeviceMotionMeasurement | null {
+  const [measurement, setMeasurement] =
+    useState<IDeviceMotionMeasurement | null>(null);
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/hooks/use-gyroscope/index.ts

@@ -3,8 +3,12 @@
 import { useEffect, useState } from 'react';
 import { Gyroscope, type IGyroscopeMeasurement } from '../../../core';
 
-export function useGyroscope(updateIntervalMs?: number): IGyroscopeMeasurement | null {
-  const [measurement, setMeasurement] = useState<IGyroscopeMeasurement | null>(null);
+export function useGyroscope(
+  updateIntervalMs?: number,
+): IGyroscopeMeasurement | null {
+  const [measurement, setMeasurement] = useState<IGyroscopeMeasurement | null>(
+    null,
+  );
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/hooks/use-light-sensor/index.ts

@@ -3,8 +3,11 @@
 import { useEffect, useState } from 'react';
 import { LightSensor, type ILightSensorMeasurement } from '../../../core';
 
-export function useLightSensor(updateIntervalMs?: number): ILightSensorMeasurement | null {
-  const [measurement, setMeasurement] = useState<ILightSensorMeasurement | null>(null);
+export function useLightSensor(
+  updateIntervalMs?: number,
+): ILightSensorMeasurement | null {
+  const [measurement, setMeasurement] =
+    useState<ILightSensorMeasurement | null>(null);
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/hooks/use-magnetometer/index.ts

@@ -3,8 +3,11 @@
 import { useEffect, useState } from 'react';
 import { Magnetometer, type IMagnetometerMeasurement } from '../../../core';
 
-export function useMagnetometer(updateIntervalMs?: number): IMagnetometerMeasurement | null {
-  const [measurement, setMeasurement] = useState<IMagnetometerMeasurement | null>(null);
+export function useMagnetometer(
+  updateIntervalMs?: number,
+): IMagnetometerMeasurement | null {
+  const [measurement, setMeasurement] =
+    useState<IMagnetometerMeasurement | null>(null);
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/hooks/use-magnetometer-uncalibrated/index.ts

@@ -1,12 +1,16 @@
 // 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, type IMagnetometerUncalibratedMeasurement } from '../../../core';
+import {
+  MagnetometerUncalibrated,
+  type IMagnetometerUncalibratedMeasurement,
+} from '../../../core';
 
 export function useMagnetometerUncalibrated(
   updateIntervalMs?: number,
 ): IMagnetometerUncalibratedMeasurement | null {
-  const [measurement, setMeasurement] = useState<IMagnetometerUncalibratedMeasurement | null>(null);
+  const [measurement, setMeasurement] =
+    useState<IMagnetometerUncalibratedMeasurement | null>(null);
 
   useEffect(() => {
     // Re-subscribing on interval change keeps the native update rate in sync with the

package/src/react/index.ts

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

package/src/solid/index.ts

@@ -0,0 +1,19 @@
+// @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';
+export { createBarometer } from './primitives/create-barometer';
+export { createDeviceMotion } from './primitives/create-device-motion';
+export { createGyroscope } from './primitives/create-gyroscope';
+export { createLightSensor } from './primitives/create-light-sensor';
+export { createMagnetometer } from './primitives/create-magnetometer';
+export { createMagnetometerUncalibrated } from './primitives/create-magnetometer-uncalibrated';
+export { createPedometer } from './primitives/create-pedometer';
+export type { IUpdateIntervalMs } from './primitives/device-sensor-accessor';
+export * from '../core';

package/src/solid/primitives/create-accelerometer.ts

@@ -0,0 +1,16 @@
+// Solid lifecycle wiring over the framework-agnostic Accelerometer singleton (core/) — the Solid
+// twin of react/hooks/use-accelerometer, vue/composables/use-accelerometer and
+// svelte/runes/use-accelerometer.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import { Accelerometer, type IAccelerometerMeasurement } from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createAccelerometer(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<IAccelerometerMeasurement | null> {
+  return createDeviceSensorAccessor(Accelerometer, updateIntervalMs);
+}

package/src/solid/primitives/create-barometer.ts

@@ -0,0 +1,16 @@
+// Solid lifecycle wiring over the framework-agnostic Barometer singleton (core/) — the Solid
+// twin of react/hooks/use-barometer, vue/composables/use-barometer and
+// svelte/runes/use-barometer.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import { Barometer, type IBarometerMeasurement } from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createBarometer(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<IBarometerMeasurement | null> {
+  return createDeviceSensorAccessor(Barometer, updateIntervalMs);
+}

package/src/solid/primitives/create-device-motion.ts

@@ -0,0 +1,16 @@
+// Solid lifecycle wiring over the framework-agnostic DeviceMotion singleton (core/) — the Solid
+// twin of react/hooks/use-device-motion, vue/composables/use-device-motion and
+// svelte/runes/use-device-motion.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import { DeviceMotion, type IDeviceMotionMeasurement } from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createDeviceMotion(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<IDeviceMotionMeasurement | null> {
+  return createDeviceSensorAccessor(DeviceMotion, updateIntervalMs);
+}

package/src/solid/primitives/create-gyroscope.ts

@@ -0,0 +1,16 @@
+// Solid lifecycle wiring over the framework-agnostic Gyroscope singleton (core/) — the Solid
+// twin of react/hooks/use-gyroscope, vue/composables/use-gyroscope and
+// svelte/runes/use-gyroscope.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import { Gyroscope, type IGyroscopeMeasurement } from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createGyroscope(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<IGyroscopeMeasurement | null> {
+  return createDeviceSensorAccessor(Gyroscope, updateIntervalMs);
+}

package/src/solid/primitives/create-light-sensor.ts

@@ -0,0 +1,16 @@
+// Solid lifecycle wiring over the framework-agnostic LightSensor singleton (core/) — the Solid
+// twin of react/hooks/use-light-sensor, vue/composables/use-light-sensor and
+// svelte/runes/use-light-sensor.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import { LightSensor, type ILightSensorMeasurement } from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createLightSensor(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<ILightSensorMeasurement | null> {
+  return createDeviceSensorAccessor(LightSensor, updateIntervalMs);
+}

package/src/solid/primitives/create-magnetometer-uncalibrated.ts

@@ -0,0 +1,19 @@
+// Solid lifecycle wiring over the framework-agnostic MagnetometerUncalibrated singleton (core/) — the Solid
+// twin of react/hooks/use-magnetometer-uncalibrated, vue/composables/use-magnetometer-uncalibrated and
+// svelte/runes/use-magnetometer-uncalibrated.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import {
+  MagnetometerUncalibrated,
+  type IMagnetometerUncalibratedMeasurement,
+} from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createMagnetometerUncalibrated(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<IMagnetometerUncalibratedMeasurement | null> {
+  return createDeviceSensorAccessor(MagnetometerUncalibrated, updateIntervalMs);
+}

package/src/solid/primitives/create-magnetometer.ts

@@ -0,0 +1,16 @@
+// Solid lifecycle wiring over the framework-agnostic Magnetometer singleton (core/) — the Solid
+// twin of react/hooks/use-magnetometer, vue/composables/use-magnetometer and
+// svelte/runes/use-magnetometer.svelte.ts. The lifecycle itself, and why the interval takes an
+// accessor as well as a number, live once in ./device-sensor-accessor.
+import type { Accessor } from 'solid-js';
+import { Magnetometer, type IMagnetometerMeasurement } from '../../core';
+import {
+  createDeviceSensorAccessor,
+  type IUpdateIntervalMs,
+} from './device-sensor-accessor';
+
+export function createMagnetometer(
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<IMagnetometerMeasurement | null> {
+  return createDeviceSensorAccessor(Magnetometer, updateIntervalMs);
+}

package/src/solid/primitives/create-pedometer.ts

@@ -0,0 +1,31 @@
+// 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, type Accessor } from 'solid-js';
+import {
+  watchStepCount,
+  type EventSubscription,
+  type IPedometerResult,
+} from '../../core';
+
+export function createPedometer(): Accessor<IPedometerResult | null> {
+  const [result, setResult] = createSignal<IPedometerResult | null>(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: EventSubscription = watchStepCount(next => {
+    setResult(next);
+  });
+
+  onCleanup(() => {
+    subscription.remove();
+  });
+
+  return result;
+}

package/src/solid/primitives/device-sensor-accessor.ts

@@ -0,0 +1,105 @@
+// 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,
+  type Accessor,
+} from 'solid-js';
+import type { EventSubscription, IListener } from '../../core';
+
+export type IUpdateIntervalMs =
+  number | Accessor<number | undefined> | undefined;
+
+// Structural, not `DeviceSensor<Measurement>`: this needs exactly two methods, and every test in
+// this folder passes a plain object in place of the singleton.
+type ISensorHandle<Measurement> = {
+  addListener(listener: IListener<Measurement>): EventSubscription;
+  setUpdateInterval(intervalMs: number): void;
+};
+
+export function createDeviceSensorAccessor<Measurement>(
+  sensor: ISensorHandle<Measurement>,
+  updateIntervalMs?: IUpdateIntervalMs,
+): Accessor<Measurement | null> {
+  const [measurement, setMeasurement] = createSignal<Measurement | null>(null);
+
+  function applyInterval(intervalMs: number | undefined): void {
+    // `!== 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: EventSubscription = 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;
+}