@symbiote-native/sensors 0.1.0

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

@@ -0,0 +1,100 @@
+// Co-located Vue-driven test (ADR 0025) for useBarometer. 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 { IBarometerMeasurement } from '../../../core';
+import { useBarometer } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (measurement: IBarometerMeasurement) => 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', () => ({
+  Barometer: {
+    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 mountBarometer(updateIntervalMs?: number): Ref<IBarometerMeasurement | null> {
+  let measurement: Ref<IBarometerMeasurement | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        measurement = useBarometer(updateIntervalMs);
+        return () => h('symbiote-text', {}, 'sensor');
+      },
+    }),
+  );
+  if (measurement === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return measurement;
+}
+
+describe('useBarometer (Vue)', () => {
+  it('starts null before any measurement arrives', () => {
+    const measurement = mountBarometer();
+
+    expect(measurement.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const measurement = mountBarometer();
+    const reading: IBarometerMeasurement = {
+      pressure: 1013.25,
+      relativeAltitude: 12.3,
+      timestamp: 123,
+    };
+
+    registeredListener?.(reading);
+
+    expect(measurement.value).toEqual(reading);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountBarometer();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('sets the update interval once at subscribe time when provided', () => {
+    mountBarometer(50);
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(50);
+    expect(setUpdateIntervalMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not touch the update interval when omitted', () => {
+    mountBarometer();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,30 @@
+// 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, type Ref } from '@vue/runtime-core';
+import { DeviceMotion, type EventSubscription, type IDeviceMotionMeasurement } from '../../../core';
+
+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;
+
+  onMounted(() => {
+    if (updateIntervalMs !== undefined) {
+      DeviceMotion.setUpdateInterval(updateIntervalMs);
+    }
+    subscription = DeviceMotion.addListener(next => {
+      measurement.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return measurement;
+}

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

@@ -0,0 +1,104 @@
+// Co-located Vue-driven test (ADR 0025) for useDeviceMotion. 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 { IDeviceMotionMeasurement } from '../../../core';
+import { useDeviceMotion } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (measurement: IDeviceMotionMeasurement) => 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', () => ({
+  DeviceMotion: {
+    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 mountDeviceMotion(updateIntervalMs?: number): Ref<IDeviceMotionMeasurement | null> {
+  let measurement: Ref<IDeviceMotionMeasurement | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        measurement = useDeviceMotion(updateIntervalMs);
+        return () => h('symbiote-text', {}, 'sensor');
+      },
+    }),
+  );
+  if (measurement === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return measurement;
+}
+
+const READING: IDeviceMotionMeasurement = {
+  acceleration: { x: 0.1, y: 0.2, z: 0.3, timestamp: 123 },
+  accelerationIncludingGravity: { x: 0.1, y: 0.2, z: 9.9, timestamp: 123 },
+  rotation: { alpha: 1, beta: 2, gamma: 3, timestamp: 123 },
+  rotationRate: { alpha: 0.1, beta: 0.2, gamma: 0.3, timestamp: 123 },
+  interval: 16,
+  orientation: 0, // DeviceMotionOrientation.Portrait
+};
+
+describe('useDeviceMotion (Vue)', () => {
+  it('starts null before any measurement arrives', () => {
+    const measurement = mountDeviceMotion();
+
+    expect(measurement.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const measurement = mountDeviceMotion();
+
+    registeredListener?.(READING);
+
+    expect(measurement.value).toEqual(READING);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountDeviceMotion();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('sets the update interval once at subscribe time when provided', () => {
+    mountDeviceMotion(50);
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(50);
+    expect(setUpdateIntervalMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not touch the update interval when omitted', () => {
+    mountDeviceMotion();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,30 @@
+// 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, type Ref } from '@vue/runtime-core';
+import { Gyroscope, type EventSubscription, type IGyroscopeMeasurement } from '../../../core';
+
+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;
+
+  onMounted(() => {
+    if (updateIntervalMs !== undefined) {
+      Gyroscope.setUpdateInterval(updateIntervalMs);
+    }
+    subscription = Gyroscope.addListener(next => {
+      measurement.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return measurement;
+}

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

@@ -0,0 +1,96 @@
+// Co-located Vue-driven test (ADR 0025) for useGyroscope. 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 { IGyroscopeMeasurement } from '../../../core';
+import { useGyroscope } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (measurement: IGyroscopeMeasurement) => 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', () => ({
+  Gyroscope: {
+    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 mountGyroscope(updateIntervalMs?: number): Ref<IGyroscopeMeasurement | null> {
+  let measurement: Ref<IGyroscopeMeasurement | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        measurement = useGyroscope(updateIntervalMs);
+        return () => h('symbiote-text', {}, 'sensor');
+      },
+    }),
+  );
+  if (measurement === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return measurement;
+}
+
+describe('useGyroscope (Vue)', () => {
+  it('starts null before any measurement arrives', () => {
+    const measurement = mountGyroscope();
+
+    expect(measurement.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const measurement = mountGyroscope();
+    const reading: IGyroscopeMeasurement = { x: 0.1, y: 0.2, z: 0.9, timestamp: 123 };
+
+    registeredListener?.(reading);
+
+    expect(measurement.value).toEqual(reading);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountGyroscope();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('sets the update interval once at subscribe time when provided', () => {
+    mountGyroscope(50);
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(50);
+    expect(setUpdateIntervalMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not touch the update interval when omitted', () => {
+    mountGyroscope();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,30 @@
+// 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, type Ref } from '@vue/runtime-core';
+import { LightSensor, type EventSubscription, type ILightSensorMeasurement } from '../../../core';
+
+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;
+
+  onMounted(() => {
+    if (updateIntervalMs !== undefined) {
+      LightSensor.setUpdateInterval(updateIntervalMs);
+    }
+    subscription = LightSensor.addListener(next => {
+      measurement.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return measurement;
+}

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

@@ -0,0 +1,96 @@
+// Co-located Vue-driven test (ADR 0025) for useLightSensor. 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 { ILightSensorMeasurement } from '../../../core';
+import { useLightSensor } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (measurement: ILightSensorMeasurement) => 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', () => ({
+  LightSensor: {
+    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 mountLightSensor(updateIntervalMs?: number): Ref<ILightSensorMeasurement | null> {
+  let measurement: Ref<ILightSensorMeasurement | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        measurement = useLightSensor(updateIntervalMs);
+        return () => h('symbiote-text', {}, 'sensor');
+      },
+    }),
+  );
+  if (measurement === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return measurement;
+}
+
+describe('useLightSensor (Vue)', () => {
+  it('starts null before any measurement arrives', () => {
+    const measurement = mountLightSensor();
+
+    expect(measurement.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const measurement = mountLightSensor();
+    const reading: ILightSensorMeasurement = { illuminance: 42, timestamp: 123 };
+
+    registeredListener?.(reading);
+
+    expect(measurement.value).toEqual(reading);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountLightSensor();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('sets the update interval once at subscribe time when provided', () => {
+    mountLightSensor(50);
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(50);
+    expect(setUpdateIntervalMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not touch the update interval when omitted', () => {
+    mountLightSensor();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,30 @@
+// 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, type Ref } from '@vue/runtime-core';
+import { Magnetometer, type EventSubscription, type IMagnetometerMeasurement } from '../../../core';
+
+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;
+
+  onMounted(() => {
+    if (updateIntervalMs !== undefined) {
+      Magnetometer.setUpdateInterval(updateIntervalMs);
+    }
+    subscription = Magnetometer.addListener(next => {
+      measurement.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return measurement;
+}

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

@@ -0,0 +1,96 @@
+// Co-located Vue-driven test (ADR 0025) for useMagnetometer. 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 { IMagnetometerMeasurement } from '../../../core';
+import { useMagnetometer } from './index';
+
+const ROOT_TAG = 9822;
+
+type IListener = (measurement: IMagnetometerMeasurement) => 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', () => ({
+  Magnetometer: {
+    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 mountMagnetometer(updateIntervalMs?: number): Ref<IMagnetometerMeasurement | null> {
+  let measurement: Ref<IMagnetometerMeasurement | null> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        measurement = useMagnetometer(updateIntervalMs);
+        return () => h('symbiote-text', {}, 'sensor');
+      },
+    }),
+  );
+  if (measurement === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return measurement;
+}
+
+describe('useMagnetometer (Vue)', () => {
+  it('starts null before any measurement arrives', () => {
+    const measurement = mountMagnetometer();
+
+    expect(measurement.value).toBeNull();
+  });
+
+  it('updates the ref when the native listener fires', () => {
+    const measurement = mountMagnetometer();
+    const reading: IMagnetometerMeasurement = { x: 0.1, y: 0.2, z: 0.9, timestamp: 123 };
+
+    registeredListener?.(reading);
+
+    expect(measurement.value).toEqual(reading);
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountMagnetometer();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('sets the update interval once at subscribe time when provided', () => {
+    mountMagnetometer(50);
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(50);
+    expect(setUpdateIntervalMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not touch the update interval when omitted', () => {
+    mountMagnetometer();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,36 @@
+// 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, type Ref } from '@vue/runtime-core';
+import {
+  MagnetometerUncalibrated,
+  type EventSubscription,
+  type IMagnetometerUncalibratedMeasurement,
+} from '../../../core';
+
+export function useMagnetometerUncalibrated(
+  updateIntervalMs?: number,
+): Ref<IMagnetometerUncalibratedMeasurement | null> {
+  // A plain ref: the value is a POJO measurement, not an engine node, so no shallowRef needed.
+  const measurement = ref<IMagnetometerUncalibratedMeasurement | null>(null);
+  let subscription: EventSubscription | undefined;
+
+  onMounted(() => {
+    if (updateIntervalMs !== undefined) {
+      MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+    }
+    subscription = MagnetometerUncalibrated.addListener(next => {
+      measurement.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return measurement;
+}