@symbiote-native/sensors 0.1.0

package/src/vue/composables/use-magnetometer-uncalibrated/use-magnetometer-uncalibrated.test.ts

@@ -0,0 +1,103 @@
+// Co-located Vue-driven test (ADR 0025) for useMagnetometerUncalibrated. Mocks the whole core
+// module (never expo-modules-core internals) since this exercises composable mount/unmount
+// lifecycle timing, not any native view — there is none here, so no ViewConfig fixture is needed.
+
+import { defineComponent, h, type Ref } from '@vue/runtime-core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/vue';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IMagnetometerUncalibratedMeasurement } from '../../../core';
+import { useMagnetometerUncalibrated } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (measurement: IMagnetometerUncalibratedMeasurement) => void;
+
+let registeredListener: IListener | undefined;
+const removeMock = vi.fn();
+const addListenerMock = vi.fn((listener: IListener) => {
+  registeredListener = listener;
+  return { remove: removeMock };
+});
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  MagnetometerUncalibrated: {
+    addListener: (listener: IListener) => addListenerMock(listener),
+    removeAllListeners: vi.fn(),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  registeredListener = undefined;
+  addListenerMock.mockClear();
+  removeMock.mockClear();
+  setUpdateIntervalMock.mockClear();
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+function mountMagnetometerUncalibrated(
+  updateIntervalMs?: number,
+): Ref<IMagnetometerUncalibratedMeasurement | null> {
+  let measurement: Ref<IMagnetometerUncalibratedMeasurement | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        measurement = useMagnetometerUncalibrated(updateIntervalMs);
+        return () => h('symbiote-text', {}, 'sensor');
+      },
+    }),
+  );
+  if (measurement === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return measurement;
+}
+
+describe('useMagnetometerUncalibrated (Vue)', () => {
+  it('starts null before any measurement arrives', () => {
+    const measurement = mountMagnetometerUncalibrated();
+
+    expect(measurement.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const measurement = mountMagnetometerUncalibrated();
+    const reading: IMagnetometerUncalibratedMeasurement = {
+      x: 0.1,
+      y: 0.2,
+      z: 0.9,
+      timestamp: 123,
+    };
+
+    registeredListener?.(reading);
+
+    expect(measurement.value).toEqual(reading);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountMagnetometerUncalibrated();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('sets the update interval once at subscribe time when provided', () => {
+    mountMagnetometerUncalibrated(50);
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(50);
+    expect(setUpdateIntervalMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not touch the update interval when omitted', () => {
+    mountMagnetometerUncalibrated();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,25 @@
+// 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, type Ref } from '@vue/runtime-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.
+  const result = ref<IPedometerResult | null>(null);
+  let subscription: EventSubscription | undefined;
+
+  onMounted(() => {
+    subscription = watchStepCount(next => {
+      result.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return result;
+}

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

@@ -0,0 +1,77 @@
+// Co-located Vue-driven test (ADR 0025) for usePedometer. Mocks the whole core module (never
+// expo-modules-core internals) since this exercises composable mount/unmount lifecycle timing,
+// not any native view — there is none here, so no ViewConfig fixture is needed.
+
+import { defineComponent, h, type Ref } from '@vue/runtime-core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/vue';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IPedometerResult } from '../../../core';
+import { usePedometer } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (result: IPedometerResult) => void;
+
+let registeredListener: IListener | undefined;
+const removeMock = vi.fn();
+const watchStepCountMock = vi.fn((listener: IListener) => {
+  registeredListener = listener;
+  return { remove: removeMock };
+});
+
+vi.mock('../../../core', () => ({
+  watchStepCount: (listener: IListener) => watchStepCountMock(listener),
+}));
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  registeredListener = undefined;
+  watchStepCountMock.mockClear();
+  removeMock.mockClear();
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+function mountPedometer(): Ref<IPedometerResult | null> {
+  let result: Ref<IPedometerResult | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        result = usePedometer();
+        return () => h('symbiote-text', {}, 'pedometer');
+      },
+    }),
+  );
+  if (result === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return result;
+}
+
+describe('usePedometer (Vue)', () => {
+  it('starts null before any step count arrives', () => {
+    const result = mountPedometer();
+
+    expect(result.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const result = mountPedometer();
+    const reading: IPedometerResult = { steps: 456 };
+
+    registeredListener?.(reading);
+
+    expect(result.value).toEqual(reading);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountPedometer();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/vue/index.ts

@@ -0,0 +1,29 @@
+// @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';
+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';