@bquery/bquery 1.7.0 → 1.8.1

package/src/media/device-sensors.ts

@@ -1,158 +1,158 @@
-/**
- * Reactive device motion and orientation sensors.
- *
- * Provides reactive signals for accelerometer, gyroscope, and
- * compass data via the DeviceMotion and DeviceOrientation APIs.
- *
- * @module bquery/media
- */
-
-import { signal, readonly } from '../reactive/index';
-import type {
-  DeviceMotionSignal,
-  DeviceMotionState,
-  DeviceOrientationSignal,
-  DeviceOrientationState,
-} from './types';
-
-/** Default device motion state. */
-const DEFAULT_MOTION_STATE: DeviceMotionState = {
-  acceleration: { x: null, y: null, z: null },
-  accelerationIncludingGravity: { x: null, y: null, z: null },
-  rotationRate: { alpha: null, beta: null, gamma: null },
-  interval: 0,
-};
-
-/** Default device orientation state. */
-const DEFAULT_ORIENTATION_STATE: DeviceOrientationState = {
-  alpha: null,
-  beta: null,
-  gamma: null,
-  absolute: false,
-};
-
-/**
- * Returns a reactive signal tracking device motion (accelerometer + gyroscope).
- *
- * Uses the `devicemotion` event to provide acceleration, acceleration
- * including gravity, and rotation rate data.
- *
- * @returns A readonly reactive signal with motion sensor data and a `destroy()`
- * method to remove the underlying event listener
- *
- * @example
- * ```ts
- * import { useDeviceMotion } from '@bquery/bquery/media';
- * import { effect } from '@bquery/bquery/reactive';
- *
- * const motion = useDeviceMotion();
- * effect(() => {
- *   const { acceleration } = motion.value;
- *   console.log(`Acceleration: x=${acceleration.x}, y=${acceleration.y}, z=${acceleration.z}`);
- * });
- * ```
- */
-export const useDeviceMotion = (): DeviceMotionSignal => {
-  const s = signal<DeviceMotionState>({ ...DEFAULT_MOTION_STATE });
-  let cleanup: (() => void) | undefined;
-
-  if (typeof window !== 'undefined') {
-    const handler = (e: DeviceMotionEvent): void => {
-      s.value = {
-        acceleration: {
-          x: e.acceleration?.x ?? null,
-          y: e.acceleration?.y ?? null,
-          z: e.acceleration?.z ?? null,
-        },
-        accelerationIncludingGravity: {
-          x: e.accelerationIncludingGravity?.x ?? null,
-          y: e.accelerationIncludingGravity?.y ?? null,
-          z: e.accelerationIncludingGravity?.z ?? null,
-        },
-        rotationRate: {
-          alpha: e.rotationRate?.alpha ?? null,
-          beta: e.rotationRate?.beta ?? null,
-          gamma: e.rotationRate?.gamma ?? null,
-        },
-        interval: e.interval ?? 0,
-      };
-    };
-
-    window.addEventListener('devicemotion', handler);
-    cleanup = () => {
-      window.removeEventListener('devicemotion', handler);
-    };
-  }
-
-  const ro = readonly(s) as DeviceMotionSignal;
-  let destroyed = false;
-  Object.defineProperty(ro, 'destroy', {
-    enumerable: false,
-    configurable: true,
-    value(): void {
-      if (destroyed) return;
-      destroyed = true;
-      cleanup?.();
-      s.dispose();
-    },
-  });
-
-  return ro;
-};
-
-/**
- * Returns a reactive signal tracking device orientation (compass/gyroscope).
- *
- * Uses the `deviceorientation` event to provide alpha (compass heading),
- * beta (front-to-back tilt), and gamma (left-to-right tilt) data.
- *
- * @returns A readonly reactive signal with orientation data and a `destroy()`
- * method to remove the underlying event listener
- *
- * @example
- * ```ts
- * import { useDeviceOrientation } from '@bquery/bquery/media';
- * import { effect } from '@bquery/bquery/reactive';
- *
- * const orientation = useDeviceOrientation();
- * effect(() => {
- *   console.log(`Compass heading: ${orientation.value.alpha}°`);
- *   console.log(`Tilt: ${orientation.value.beta}° / ${orientation.value.gamma}°`);
- * });
- * ```
- */
-export const useDeviceOrientation = (): DeviceOrientationSignal => {
-  const s = signal<DeviceOrientationState>({ ...DEFAULT_ORIENTATION_STATE });
-  let cleanup: (() => void) | undefined;
-
-  if (typeof window !== 'undefined') {
-    const handler = (e: DeviceOrientationEvent): void => {
-      s.value = {
-        alpha: e.alpha ?? null,
-        beta: e.beta ?? null,
-        gamma: e.gamma ?? null,
-        absolute: e.absolute ?? false,
-      };
-    };
-
-    window.addEventListener('deviceorientation', handler);
-    cleanup = () => {
-      window.removeEventListener('deviceorientation', handler);
-    };
-  }
-
-  const ro = readonly(s) as DeviceOrientationSignal;
-  let destroyed = false;
-  Object.defineProperty(ro, 'destroy', {
-    enumerable: false,
-    configurable: true,
-    value(): void {
-      if (destroyed) return;
-      destroyed = true;
-      cleanup?.();
-      s.dispose();
-    },
-  });
-
-  return ro;
-};
+/**
+ * Reactive device motion and orientation sensors.
+ *
+ * Provides reactive signals for accelerometer, gyroscope, and
+ * compass data via the DeviceMotion and DeviceOrientation APIs.
+ *
+ * @module bquery/media
+ */
+
+import { signal, readonly } from '../reactive/index';
+import type {
+  DeviceMotionSignal,
+  DeviceMotionState,
+  DeviceOrientationSignal,
+  DeviceOrientationState,
+} from './types';
+
+/** Default device motion state. */
+const DEFAULT_MOTION_STATE: DeviceMotionState = {
+  acceleration: { x: null, y: null, z: null },
+  accelerationIncludingGravity: { x: null, y: null, z: null },
+  rotationRate: { alpha: null, beta: null, gamma: null },
+  interval: 0,
+};
+
+/** Default device orientation state. */
+const DEFAULT_ORIENTATION_STATE: DeviceOrientationState = {
+  alpha: null,
+  beta: null,
+  gamma: null,
+  absolute: false,
+};
+
+/**
+ * Returns a reactive signal tracking device motion (accelerometer + gyroscope).
+ *
+ * Uses the `devicemotion` event to provide acceleration, acceleration
+ * including gravity, and rotation rate data.
+ *
+ * @returns A readonly reactive signal with motion sensor data and a `destroy()`
+ * method to remove the underlying event listener
+ *
+ * @example
+ * ```ts
+ * import { useDeviceMotion } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * const motion = useDeviceMotion();
+ * effect(() => {
+ *   const { acceleration } = motion.value;
+ *   console.log(`Acceleration: x=${acceleration.x}, y=${acceleration.y}, z=${acceleration.z}`);
+ * });
+ * ```
+ */
+export const useDeviceMotion = (): DeviceMotionSignal => {
+  const s = signal<DeviceMotionState>({ ...DEFAULT_MOTION_STATE });
+  let cleanup: (() => void) | undefined;
+
+  if (typeof window !== 'undefined') {
+    const handler = (e: DeviceMotionEvent): void => {
+      s.value = {
+        acceleration: {
+          x: e.acceleration?.x ?? null,
+          y: e.acceleration?.y ?? null,
+          z: e.acceleration?.z ?? null,
+        },
+        accelerationIncludingGravity: {
+          x: e.accelerationIncludingGravity?.x ?? null,
+          y: e.accelerationIncludingGravity?.y ?? null,
+          z: e.accelerationIncludingGravity?.z ?? null,
+        },
+        rotationRate: {
+          alpha: e.rotationRate?.alpha ?? null,
+          beta: e.rotationRate?.beta ?? null,
+          gamma: e.rotationRate?.gamma ?? null,
+        },
+        interval: e.interval ?? 0,
+      };
+    };
+
+    window.addEventListener('devicemotion', handler);
+    cleanup = () => {
+      window.removeEventListener('devicemotion', handler);
+    };
+  }
+
+  const ro = readonly(s) as DeviceMotionSignal;
+  let destroyed = false;
+  Object.defineProperty(ro, 'destroy', {
+    enumerable: false,
+    configurable: true,
+    value(): void {
+      if (destroyed) return;
+      destroyed = true;
+      cleanup?.();
+      s.dispose();
+    },
+  });
+
+  return ro;
+};
+
+/**
+ * Returns a reactive signal tracking device orientation (compass/gyroscope).
+ *
+ * Uses the `deviceorientation` event to provide alpha (compass heading),
+ * beta (front-to-back tilt), and gamma (left-to-right tilt) data.
+ *
+ * @returns A readonly reactive signal with orientation data and a `destroy()`
+ * method to remove the underlying event listener
+ *
+ * @example
+ * ```ts
+ * import { useDeviceOrientation } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * const orientation = useDeviceOrientation();
+ * effect(() => {
+ *   console.log(`Compass heading: ${orientation.value.alpha}°`);
+ *   console.log(`Tilt: ${orientation.value.beta}° / ${orientation.value.gamma}°`);
+ * });
+ * ```
+ */
+export const useDeviceOrientation = (): DeviceOrientationSignal => {
+  const s = signal<DeviceOrientationState>({ ...DEFAULT_ORIENTATION_STATE });
+  let cleanup: (() => void) | undefined;
+
+  if (typeof window !== 'undefined') {
+    const handler = (e: DeviceOrientationEvent): void => {
+      s.value = {
+        alpha: e.alpha ?? null,
+        beta: e.beta ?? null,
+        gamma: e.gamma ?? null,
+        absolute: e.absolute ?? false,
+      };
+    };
+
+    window.addEventListener('deviceorientation', handler);
+    cleanup = () => {
+      window.removeEventListener('deviceorientation', handler);
+    };
+  }
+
+  const ro = readonly(s) as DeviceOrientationSignal;
+  let destroyed = false;
+  Object.defineProperty(ro, 'destroy', {
+    enumerable: false,
+    configurable: true,
+    value(): void {
+      if (destroyed) return;
+      destroyed = true;
+      cleanup?.();
+      s.dispose();
+    },
+  });
+
+  return ro;
+};

package/src/media/geolocation.ts

@@ -1,119 +1,119 @@
-/**
- * Reactive geolocation.
- *
- * Provides a reactive signal tracking the device's geographic position
- * via the Geolocation API.
- *
- * @module bquery/media
- */
-
-import { signal, readonly } from '../reactive/index';
-import type { GeolocationOptions, GeolocationSignal, GeolocationState } from './types';
-
-/** Default geolocation state. */
-const DEFAULT_GEO_STATE: GeolocationState = {
-  supported: false,
-  loading: false,
-  latitude: null,
-  longitude: null,
-  accuracy: null,
-  altitude: null,
-  altitudeAccuracy: null,
-  heading: null,
-  speed: null,
-  timestamp: null,
-  error: null,
-};
-
-/**
- * Returns a reactive signal tracking the device's geographic position.
- *
- * Uses the Geolocation API (`navigator.geolocation`) where available.
- * Can operate in one-shot mode (default) or continuous watch mode.
- *
- * @param options - Configuration for the geolocation request
- * @returns A readonly reactive signal with position data and loading/error state,
- * plus a `destroy()` method to stop an active watcher
- *
- * @example
- * ```ts
- * import { useGeolocation } from '@bquery/bquery/media';
- * import { effect } from '@bquery/bquery/reactive';
- *
- * // One-shot position
- * const geo = useGeolocation();
- * effect(() => {
- *   if (geo.value.loading) return console.log('Getting position...');
- *   if (geo.value.error) return console.error(geo.value.error);
- *   console.log(`Lat: ${geo.value.latitude}, Lng: ${geo.value.longitude}`);
- * });
- *
- * // Continuous watch with high accuracy
- * const geoWatch = useGeolocation({ watch: true, enableHighAccuracy: true });
- * ```
- */
-export const useGeolocation = (options: GeolocationOptions = {}): GeolocationSignal => {
-  const { enableHighAccuracy = false, maximumAge = 0, timeout = Infinity, watch = false } = options;
-
-  const s = signal<GeolocationState>({ ...DEFAULT_GEO_STATE });
-
-  let destroyWatcher: (() => void) | undefined;
-
-  if (typeof navigator !== 'undefined' && 'geolocation' in navigator) {
-    s.value = { ...DEFAULT_GEO_STATE, supported: true, loading: true };
-
-    const posOptions: PositionOptions = {
-      enableHighAccuracy,
-      maximumAge,
-      timeout: timeout === Infinity ? undefined : timeout,
-    };
-
-    const onSuccess = (pos: GeolocationPosition): void => {
-      s.value = {
-        supported: true,
-        loading: false,
-        latitude: pos.coords.latitude,
-        longitude: pos.coords.longitude,
-        accuracy: pos.coords.accuracy,
-        altitude: pos.coords.altitude,
-        altitudeAccuracy: pos.coords.altitudeAccuracy,
-        heading: pos.coords.heading,
-        speed: pos.coords.speed,
-        timestamp: pos.timestamp,
-        error: null,
-      };
-    };
-
-    const onError = (err: GeolocationPositionError): void => {
-      s.value = {
-        ...s.value,
-        loading: false,
-        error: err.message,
-      };
-    };
-
-    if (watch) {
-      const watchId = navigator.geolocation.watchPosition(onSuccess, onError, posOptions);
-      destroyWatcher = () => {
-        navigator.geolocation.clearWatch(watchId);
-      };
-    } else {
-      navigator.geolocation.getCurrentPosition(onSuccess, onError, posOptions);
-    }
-  }
-
-  const ro = readonly(s) as GeolocationSignal;
-  let destroyed = false;
-  Object.defineProperty(ro, 'destroy', {
-    enumerable: false,
-    configurable: true,
-    value(): void {
-      if (destroyed) return;
-      destroyed = true;
-      destroyWatcher?.();
-      s.dispose();
-    },
-  });
-
-  return ro;
-};
+/**
+ * Reactive geolocation.
+ *
+ * Provides a reactive signal tracking the device's geographic position
+ * via the Geolocation API.
+ *
+ * @module bquery/media
+ */
+
+import { signal, readonly } from '../reactive/index';
+import type { GeolocationOptions, GeolocationSignal, GeolocationState } from './types';
+
+/** Default geolocation state. */
+const DEFAULT_GEO_STATE: GeolocationState = {
+  supported: false,
+  loading: false,
+  latitude: null,
+  longitude: null,
+  accuracy: null,
+  altitude: null,
+  altitudeAccuracy: null,
+  heading: null,
+  speed: null,
+  timestamp: null,
+  error: null,
+};
+
+/**
+ * Returns a reactive signal tracking the device's geographic position.
+ *
+ * Uses the Geolocation API (`navigator.geolocation`) where available.
+ * Can operate in one-shot mode (default) or continuous watch mode.
+ *
+ * @param options - Configuration for the geolocation request
+ * @returns A readonly reactive signal with position data and loading/error state,
+ * plus a `destroy()` method to stop an active watcher
+ *
+ * @example
+ * ```ts
+ * import { useGeolocation } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * // One-shot position
+ * const geo = useGeolocation();
+ * effect(() => {
+ *   if (geo.value.loading) return console.log('Getting position...');
+ *   if (geo.value.error) return console.error(geo.value.error);
+ *   console.log(`Lat: ${geo.value.latitude}, Lng: ${geo.value.longitude}`);
+ * });
+ *
+ * // Continuous watch with high accuracy
+ * const geoWatch = useGeolocation({ watch: true, enableHighAccuracy: true });
+ * ```
+ */
+export const useGeolocation = (options: GeolocationOptions = {}): GeolocationSignal => {
+  const { enableHighAccuracy = false, maximumAge = 0, timeout = Infinity, watch = false } = options;
+
+  const s = signal<GeolocationState>({ ...DEFAULT_GEO_STATE });
+
+  let destroyWatcher: (() => void) | undefined;
+
+  if (typeof navigator !== 'undefined' && 'geolocation' in navigator) {
+    s.value = { ...DEFAULT_GEO_STATE, supported: true, loading: true };
+
+    const posOptions: PositionOptions = {
+      enableHighAccuracy,
+      maximumAge,
+      timeout: timeout === Infinity ? undefined : timeout,
+    };
+
+    const onSuccess = (pos: GeolocationPosition): void => {
+      s.value = {
+        supported: true,
+        loading: false,
+        latitude: pos.coords.latitude,
+        longitude: pos.coords.longitude,
+        accuracy: pos.coords.accuracy,
+        altitude: pos.coords.altitude,
+        altitudeAccuracy: pos.coords.altitudeAccuracy,
+        heading: pos.coords.heading,
+        speed: pos.coords.speed,
+        timestamp: pos.timestamp,
+        error: null,
+      };
+    };
+
+    const onError = (err: GeolocationPositionError): void => {
+      s.value = {
+        ...s.value,
+        loading: false,
+        error: err.message,
+      };
+    };
+
+    if (watch) {
+      const watchId = navigator.geolocation.watchPosition(onSuccess, onError, posOptions);
+      destroyWatcher = () => {
+        navigator.geolocation.clearWatch(watchId);
+      };
+    } else {
+      navigator.geolocation.getCurrentPosition(onSuccess, onError, posOptions);
+    }
+  }
+
+  const ro = readonly(s) as GeolocationSignal;
+  let destroyed = false;
+  Object.defineProperty(ro, 'destroy', {
+    enumerable: false,
+    configurable: true,
+    value(): void {
+      if (destroyed) return;
+      destroyed = true;
+      destroyWatcher?.();
+      s.dispose();
+    },
+  });
+
+  return ro;
+};