react-native-nitro-compass 0.1.0

package/ios/HybridNitroCompass.swift

@@ -0,0 +1,473 @@
+//
+//  HybridNitroCompass.swift
+//  NitroCompass
+//
+//  iOS implementation of the NitroCompass HybridObject. Uses
+//  CLLocationManager for the heading source — Apple's stack already does
+//  proper sensor fusion natively, so the Swift side stays simple.
+//
+
+import Foundation
+import CoreLocation
+import CoreMotion
+import NitroModules
+import UIKit
+
+// Earth's magnetic field magnitude is typically 25–65 µT. Anything
+// outside this band (with a small grace margin) is treated as
+// external interference — laptops, monitors, car engines, and
+// structural steel routinely push readings well above 100 µT.
+private let earthFieldMinUT: Double = 20
+private let earthFieldMaxUT: Double = 70
+
+class HybridNitroCompass: HybridNitroCompassSpec {
+  // CLLocationManager must be created on a thread with an active run loop
+  // (typically main). Nitro can instantiate HybridObjects off-main, so we
+  // hop to main for construction and configuration.
+  private var manager: CLLocationManager!
+  private var delegateProxy: HeadingDelegate?
+  private var onSample: ((CompassSample) -> Void)?
+  private var orientationObserver: NSObjectProtocol?
+  private var backgroundObserver: NSObjectProtocol?
+  private var foregroundObserver: NSObjectProtocol?
+  private var declinationDeg: Double = 0
+  private var lastSample: CompassSample?
+  private var lastQuality: AccuracyQuality?
+  private var calibrationCb: ((AccuracyQuality) -> Void)?
+  private var interferenceCb: ((Bool) -> Void)?
+  private let motionManager = CMMotionManager()
+  private let motionQueue: OperationQueue = {
+    let q = OperationQueue()
+    q.name = "NitroCompass.motion"
+    q.maxConcurrentOperationCount = 1
+    return q
+  }()
+  private var lastInterference: Bool?
+  private var pauseOnBackground: Bool = true
+  private var started: Bool = false
+  private var isSubscribed: Bool = false
+  private var activeFilterDegrees: Double = 1
+  // Mirrors UIApplication.applicationState. Updated from background/foreground
+  // notification observers (delivered on main) so JS-thread callers don't
+  // have to hop to main to read it.
+  private var appIsBackgrounded: Bool = false
+  // Holds an in-flight permission request. CLLocationManager.delegate is
+  // weak, so we own the resolver here for the duration of the request.
+  private var authResolver: AuthRequestResolver?
+
+  override init() {
+    super.init()
+    let setup = {
+      let m = CLLocationManager()
+      m.headingFilter = 1
+      m.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+      self.manager = m
+    }
+    if Thread.isMainThread {
+      setup()
+    } else {
+      DispatchQueue.main.sync(execute: setup)
+    }
+  }
+
+  deinit {
+    stopInternal()
+  }
+
+  func start(filterDegrees: Double, onHeading: @escaping (_ sample: CompassSample) -> Void) throws {
+    guard CLLocationManager.headingAvailable() else {
+      throw NSError(
+        domain: "NitroCompass",
+        code: 1,
+        userInfo: [NSLocalizedDescriptionKey: "Heading unavailable on this device"]
+      )
+    }
+
+    // CLLocationManager.startUpdatingHeading silently delivers nothing
+    // when location authorization is denied. Surface that explicitly so
+    // callers don't wait on a callback that will never fire.
+    // .notDetermined still proceeds — the host may request later.
+    let authStatus = manager.authorizationStatus
+    if authStatus == .denied || authStatus == .restricted {
+      throw NSError(
+        domain: "NitroCompass",
+        code: 2,
+        userInfo: [NSLocalizedDescriptionKey: "Location authorization denied — request authorization before calling start()"]
+      )
+    }
+
+    stopInternal()
+
+    onSample = onHeading
+    activeFilterDegrees = filterDegrees
+    started = true
+
+    let proxy = HeadingDelegate(
+      onSample: { [weak self] heading, accuracy in
+        self?.deliver(heading: heading, accuracy: accuracy)
+      },
+      onCalibrationOverride: { [weak self] in
+        self?.fireCalibration(.unreliable)
+      }
+    )
+    delegateProxy = proxy
+    manager.delegate = proxy
+
+    orientationObserver = NotificationCenter.default.addObserver(
+      forName: UIDevice.orientationDidChangeNotification,
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      self?.applyHeadingOrientation()
+    }
+
+    backgroundObserver = NotificationCenter.default.addObserver(
+      forName: UIApplication.didEnterBackgroundNotification,
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      self?.handleBackground()
+    }
+
+    foregroundObserver = NotificationCenter.default.addObserver(
+      forName: UIApplication.willEnterForegroundNotification,
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      self?.handleForeground()
+    }
+
+    // Read background state synchronously so a start() call from
+    // background correctly skips the initial subscribe under
+    // pauseOnBackground=true. Without this the lifecycle observers
+    // wouldn't fire (we're already in BG) and a useless subscription
+    // would sit there until the next FG↔BG cycle.
+    let backgroundedAtStart: Bool
+    if Thread.isMainThread {
+      backgroundedAtStart = UIApplication.shared.applicationState == .background
+    } else {
+      var bg = false
+      DispatchQueue.main.sync {
+        bg = UIApplication.shared.applicationState == .background
+      }
+      backgroundedAtStart = bg
+    }
+    appIsBackgrounded = backgroundedAtStart
+
+    DispatchQueue.main.async { [weak self] in
+      UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+      self?.applyHeadingOrientation()
+    }
+
+    if !(pauseOnBackground && backgroundedAtStart) {
+      subscribe()
+    }
+  }
+
+  func stop() throws {
+    stopInternal()
+  }
+
+  func hasCompass() throws -> Bool {
+    return CLLocationManager.headingAvailable()
+  }
+
+  func isStarted() throws -> Bool {
+    return started
+  }
+
+  func setFilter(degrees: Double) throws {
+    activeFilterDegrees = degrees
+    if isSubscribed {
+      manager.headingFilter = degrees == 0 ? kCLHeadingFilterNone : degrees
+    }
+  }
+
+  func getDiagnostics() throws -> SensorDiagnostics? {
+    guard CLLocationManager.headingAvailable() else { return nil }
+    return SensorDiagnostics(sensor: .corelocation)
+  }
+
+  func getCurrentHeading() throws -> CompassSample? {
+    return lastSample
+  }
+
+  func setDeclination(degrees: Double) throws {
+    declinationDeg = degrees
+  }
+
+  func setOnCalibrationNeeded(onChange: @escaping (_ quality: AccuracyQuality) -> Void) throws {
+    calibrationCb = onChange
+  }
+
+  func setOnInterferenceDetected(onChange: @escaping (_ interferenceDetected: Bool) -> Void) throws {
+    interferenceCb = onChange
+    // Replay current state so a late-registering consumer sees the truth
+    // instead of waiting for the next transition (which may never come
+    // if the field stays stable).
+    if let last = lastInterference { onChange(last) }
+  }
+
+  func setPauseOnBackground(enabled: Bool) throws {
+    pauseOnBackground = enabled
+    if enabled, started, isSubscribed, appIsBackgrounded {
+      unsubscribe()
+    } else if !enabled, started, !isSubscribed {
+      subscribe()
+    }
+  }
+
+  func getPermissionStatus() throws -> PermissionStatus {
+    return Self.mapAuthStatus(manager.authorizationStatus)
+  }
+
+  func requestPermission() throws -> Promise<PermissionStatus> {
+    let current = manager.authorizationStatus
+    if current != .notDetermined {
+      return Promise.resolved(withResult: Self.mapAuthStatus(current))
+    }
+
+    let promise = Promise<PermissionStatus>()
+
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else {
+        promise.reject(withError: NSError(
+          domain: "NitroCompass",
+          code: 4,
+          userInfo: [NSLocalizedDescriptionKey: "Compass instance was deallocated"]
+        ))
+        return
+      }
+
+      // Cancel any in-flight request — only one outstanding system
+      // prompt makes sense.
+      self.authResolver?.cancel()
+
+      let resolver = AuthRequestResolver(promise: promise)
+      // Save the existing delegate so heading delivery can resume after
+      // the auth callback fires. CLLocationManager.delegate is weak, so
+      // we have to keep our resolver alive on `self` for the duration.
+      resolver.savedDelegate = self.manager.delegate
+      resolver.onResolved = { [weak self] in self?.authResolver = nil }
+      self.authResolver = resolver
+      self.manager.delegate = resolver
+      self.manager.requestWhenInUseAuthorization()
+    }
+
+    return promise
+  }
+
+  private static func mapAuthStatus(_ status: CLAuthorizationStatus) -> PermissionStatus {
+    switch status {
+    case .authorizedAlways, .authorizedWhenInUse:
+      return .granted
+    case .denied, .restricted:
+      return .denied
+    case .notDetermined:
+      return .unknown
+    @unknown default:
+      return .unknown
+    }
+  }
+
+  // MARK: - Helpers
+
+  private func subscribe() {
+    guard !isSubscribed else { return }
+    manager.headingFilter = activeFilterDegrees == 0 ? kCLHeadingFilterNone : activeFilterDegrees
+    manager.startUpdatingHeading()
+    startMagnetometerIfAvailable()
+    isSubscribed = true
+  }
+
+  private func unsubscribe() {
+    guard isSubscribed else { return }
+    manager.stopUpdatingHeading()
+    stopMagnetometerIfRunning()
+    isSubscribed = false
+  }
+
+  private func startMagnetometerIfAvailable() {
+    guard motionManager.isDeviceMotionAvailable,
+          !motionManager.isDeviceMotionActive else { return }
+    motionManager.deviceMotionUpdateInterval = 0.2 // 5Hz
+    motionManager.startDeviceMotionUpdates(to: motionQueue) { [weak self] motion, _ in
+      guard let self = self, let m = motion else { return }
+      let cal = m.magneticField
+      if cal.accuracy == .uncalibrated { return }
+      let f = cal.field
+      let magnitude = sqrt(f.x * f.x + f.y * f.y + f.z * f.z)
+      self.evaluateInterference(magnitude: magnitude)
+    }
+  }
+
+  private func stopMagnetometerIfRunning() {
+    if motionManager.isDeviceMotionActive {
+      motionManager.stopDeviceMotionUpdates()
+    }
+  }
+
+  private func evaluateInterference(magnitude: Double) {
+    let isInterference = magnitude < earthFieldMinUT || magnitude > earthFieldMaxUT
+    if lastInterference == isInterference { return }
+    lastInterference = isInterference
+    interferenceCb?(isInterference)
+  }
+
+  private func handleBackground() {
+    appIsBackgrounded = true
+    if pauseOnBackground, started, isSubscribed {
+      unsubscribe()
+    }
+  }
+
+  private func handleForeground() {
+    appIsBackgrounded = false
+    if pauseOnBackground, started, !isSubscribed {
+      subscribe()
+    }
+  }
+
+  private func stopInternal() {
+    started = false
+    unsubscribe()
+    if delegateProxy != nil {
+      manager.delegate = nil
+      delegateProxy = nil
+    }
+    if let observer = orientationObserver {
+      NotificationCenter.default.removeObserver(observer)
+      orientationObserver = nil
+      DispatchQueue.main.async {
+        UIDevice.current.endGeneratingDeviceOrientationNotifications()
+      }
+    }
+    if let observer = backgroundObserver {
+      NotificationCenter.default.removeObserver(observer)
+      backgroundObserver = nil
+    }
+    if let observer = foregroundObserver {
+      NotificationCenter.default.removeObserver(observer)
+      foregroundObserver = nil
+    }
+    onSample = nil
+    lastSample = nil
+    lastQuality = nil
+    lastInterference = nil
+  }
+
+  private func deliver(heading magnetic: Double, accuracy: Double) {
+    var heading = magnetic + declinationDeg
+    heading = heading.truncatingRemainder(dividingBy: 360)
+    if heading < 0 { heading += 360 }
+    let sample = CompassSample(heading: heading, accuracy: accuracy)
+    lastSample = sample
+
+    let quality: AccuracyQuality
+    if accuracy < 0 {
+      quality = .unreliable
+    } else if accuracy < 5 {
+      quality = .high
+    } else if accuracy < 15 {
+      quality = .medium
+    } else if accuracy < 30 {
+      quality = .low
+    } else {
+      quality = .unreliable
+    }
+    fireCalibration(quality)
+
+    onSample?(sample)
+  }
+
+  private func fireCalibration(_ quality: AccuracyQuality) {
+    guard quality != lastQuality else { return }
+    lastQuality = quality
+    calibrationCb?(quality)
+  }
+
+  private func applyHeadingOrientation() {
+    let scene = UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .first
+    let clOrientation: CLDeviceOrientation
+    switch scene?.interfaceOrientation {
+    case .landscapeLeft:
+      clOrientation = .landscapeRight
+    case .landscapeRight:
+      clOrientation = .landscapeLeft
+    case .portraitUpsideDown:
+      clOrientation = .portraitUpsideDown
+    default:
+      clOrientation = .portrait
+    }
+    manager.headingOrientation = clOrientation
+  }
+}
+
+/// One-shot delegate that drives a `requestPermission()` call. It owns
+/// the `Promise` until the system delivers the user's choice via
+/// `locationManagerDidChangeAuthorization`, then restores the prior
+/// delegate so heading delivery resumes if a subscription was active.
+private class AuthRequestResolver: NSObject, CLLocationManagerDelegate {
+  private let promise: Promise<PermissionStatus>
+  weak var savedDelegate: CLLocationManagerDelegate?
+  var onResolved: (() -> Void)?
+  private var resolved = false
+
+  init(promise: Promise<PermissionStatus>) {
+    self.promise = promise
+  }
+
+  func cancel() {
+    guard !resolved else { return }
+    resolved = true
+    promise.reject(withError: NSError(
+      domain: "NitroCompass",
+      code: 3,
+      userInfo: [NSLocalizedDescriptionKey: "Permission request superseded"]
+    ))
+    onResolved?()
+  }
+
+  func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+    let status = manager.authorizationStatus
+    if status == .notDetermined { return }
+    if resolved { return }
+    resolved = true
+    manager.delegate = savedDelegate
+    let mapped: PermissionStatus
+    switch status {
+    case .authorizedAlways, .authorizedWhenInUse: mapped = .granted
+    case .denied, .restricted: mapped = .denied
+    default: mapped = .unknown
+    }
+    promise.resolve(withResult: mapped)
+    onResolved?()
+  }
+}
+
+/// CLLocationManager requires an NSObject delegate. Wrapping it lets the
+/// HybridObject stay a pure Swift class.
+private class HeadingDelegate: NSObject, CLLocationManagerDelegate {
+  private let onSample: (Double, Double) -> Void
+  private let onCalibrationOverride: () -> Void
+
+  init(
+    onSample: @escaping (Double, Double) -> Void,
+    onCalibrationOverride: @escaping () -> Void
+  ) {
+    self.onSample = onSample
+    self.onCalibrationOverride = onCalibrationOverride
+  }
+
+  func locationManager(_ manager: CLLocationManager, didUpdateHeading newHeading: CLHeading) {
+    guard newHeading.headingAccuracy >= 0 else { return }
+    onSample(newHeading.magneticHeading, newHeading.headingAccuracy)
+  }
+
+  func locationManagerShouldDisplayHeadingCalibration(_ manager: CLLocationManager) -> Bool {
+    onCalibrationOverride()
+    return false
+  }
+}

package/lib/commonjs/hook.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCompass = useCompass;
+var _react = require("react");
+var _native = require("./native");
+var _multiplex = require("./multiplex");
+/**
+ * Ergonomic React wrapper for the NitroCompass surface. Handles
+ * subscription lifecycle, callback registration, and the live-tuneable
+ * knobs. Multiple instances mounted at once safely share the same
+ * underlying native subscription via the multi-listener primitives in
+ * `./multiplex`.
+ */
+function useCompass(options = {}) {
+  const {
+    filterDegrees = 1,
+    declination = 0,
+    pauseOnBackground = true,
+    enabled = true
+  } = options;
+  const [reading, setReading] = (0, _react.useState)(null);
+  const [quality, setQuality] = (0, _react.useState)(null);
+  const [interfering, setInterfering] = (0, _react.useState)(false);
+  const [hasCompass] = (0, _react.useState)(() => _native.NitroCompass.hasCompass());
+  const [diagnostics] = (0, _react.useState)(() => _native.NitroCompass.getDiagnostics());
+
+  // Tracked via ref so the heading-subscription effect can re-apply
+  // the user's filter after a stop/start cycle without restarting on
+  // every filterDegrees change.
+  const filterRef = (0, _react.useRef)(filterDegrees);
+  filterRef.current = filterDegrees;
+  (0, _react.useEffect)(() => {
+    _native.NitroCompass.setFilter(filterDegrees);
+  }, [filterDegrees]);
+  (0, _react.useEffect)(() => {
+    _native.NitroCompass.setDeclination(declination);
+  }, [declination]);
+  (0, _react.useEffect)(() => {
+    _native.NitroCompass.setPauseOnBackground(pauseOnBackground);
+  }, [pauseOnBackground]);
+  (0, _react.useEffect)(() => {
+    if (!hasCompass) return;
+    return (0, _multiplex.addCalibrationListener)(setQuality);
+  }, [hasCompass]);
+  (0, _react.useEffect)(() => {
+    if (!hasCompass) return;
+    return (0, _multiplex.addInterferenceListener)(setInterfering);
+  }, [hasCompass]);
+  (0, _react.useEffect)(() => {
+    if (!hasCompass || !enabled) return;
+    const off = (0, _multiplex.addHeadingListener)(setReading);
+    // Multiplex starts the sensor with a default filter; re-apply the
+    // current option after subscribing.
+    _native.NitroCompass.setFilter(filterRef.current);
+    return off;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [hasCompass, enabled]);
+  return {
+    reading,
+    quality,
+    interfering,
+    hasCompass,
+    diagnostics
+  };
+}
+//# sourceMappingURL=hook.js.map

package/lib/commonjs/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_native","_multiplex","useCompass","options","filterDegrees","declination","pauseOnBackground","enabled","reading","setReading","useState","quality","setQuality","interfering","setInterfering","hasCompass","NitroCompass","diagnostics","getDiagnostics","filterRef","useRef","current","useEffect","setFilter","setDeclination","setPauseOnBackground","addCalibrationListener","addInterferenceListener","off","addHeadingListener"],"sourceRoot":"../../src","sources":["hook.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AA+CA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CACxBC,OAA0B,GAAG,CAAC,CAAC,EACb;EAClB,MAAM;IACJC,aAAa,GAAG,CAAC;IACjBC,WAAW,GAAG,CAAC;IACfC,iBAAiB,GAAG,IAAI;IACxBC,OAAO,GAAG;EACZ,CAAC,GAAGJ,OAAO;EAEX,MAAM,CAACK,OAAO,EAAEC,UAAU,CAAC,GAAG,IAAAC,eAAQ,EAAuB,IAAI,CAAC;EAClE,MAAM,CAACC,OAAO,EAAEC,UAAU,CAAC,GAAG,IAAAF,eAAQ,EAAyB,IAAI,CAAC;EACpE,MAAM,CAACG,WAAW,EAAEC,cAAc,CAAC,GAAG,IAAAJ,eAAQ,EAAC,KAAK,CAAC;EAErD,MAAM,CAACK,UAAU,CAAC,GAAG,IAAAL,eAAQ,EAAC,MAAMM,oBAAY,CAACD,UAAU,CAAC,CAAC,CAAC;EAC9D,MAAM,CAACE,WAAW,CAAC,GAAG,IAAAP,eAAQ,EAAC,MAAMM,oBAAY,CAACE,cAAc,CAAC,CAAC,CAAC;;EAEnE;EACA;EACA;EACA,MAAMC,SAAS,GAAG,IAAAC,aAAM,EAAChB,aAAa,CAAC;EACvCe,SAAS,CAACE,OAAO,GAAGjB,aAAa;EAEjC,IAAAkB,gBAAS,EAAC,MAAM;IACdN,oBAAY,CAACO,SAAS,CAACnB,aAAa,CAAC;EACvC,CAAC,EAAE,CAACA,aAAa,CAAC,CAAC;EAEnB,IAAAkB,gBAAS,EAAC,MAAM;IACdN,oBAAY,CAACQ,cAAc,CAACnB,WAAW,CAAC;EAC1C,CAAC,EAAE,CAACA,WAAW,CAAC,CAAC;EAEjB,IAAAiB,gBAAS,EAAC,MAAM;IACdN,oBAAY,CAACS,oBAAoB,CAACnB,iBAAiB,CAAC;EACtD,CAAC,EAAE,CAACA,iBAAiB,CAAC,CAAC;EAEvB,IAAAgB,gBAAS,EAAC,MAAM;IACd,IAAI,CAACP,UAAU,EAAE;IACjB,OAAO,IAAAW,iCAAsB,EAACd,UAAU,CAAC;EAC3C,CAAC,EAAE,CAACG,UAAU,CAAC,CAAC;EAEhB,IAAAO,gBAAS,EAAC,MAAM;IACd,IAAI,CAACP,UAAU,EAAE;IACjB,OAAO,IAAAY,kCAAuB,EAACb,cAAc,CAAC;EAChD,CAAC,EAAE,CAACC,UAAU,CAAC,CAAC;EAEhB,IAAAO,gBAAS,EAAC,MAAM;IACd,IAAI,CAACP,UAAU,IAAI,CAACR,OAAO,EAAE;IAC7B,MAAMqB,GAAG,GAAG,IAAAC,6BAAkB,EAACpB,UAAU,CAAC;IAC1C;IACA;IACAO,oBAAY,CAACO,SAAS,CAACJ,SAAS,CAACE,OAAO,CAAC;IACzC,OAAOO,GAAG;IACV;EACF,CAAC,EAAE,CAACb,UAAU,EAAER,OAAO,CAAC,CAAC;EAEzB,OAAO;IAAEC,OAAO;IAAEG,OAAO;IAAEE,WAAW;IAAEE,UAAU;IAAEE;EAAY,CAAC;AACnE","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "NitroCompass", {
+  enumerable: true,
+  get: function () {
+    return _native.NitroCompass;
+  }
+});
+Object.defineProperty(exports, "addCalibrationListener", {
+  enumerable: true,
+  get: function () {
+    return _multiplex.addCalibrationListener;
+  }
+});
+Object.defineProperty(exports, "addHeadingListener", {
+  enumerable: true,
+  get: function () {
+    return _multiplex.addHeadingListener;
+  }
+});
+Object.defineProperty(exports, "addInterferenceListener", {
+  enumerable: true,
+  get: function () {
+    return _multiplex.addInterferenceListener;
+  }
+});
+Object.defineProperty(exports, "useCompass", {
+  enumerable: true,
+  get: function () {
+    return _hook.useCompass;
+  }
+});
+var _native = require("./native");
+var _multiplex = require("./multiplex");
+var _hook = require("./hook");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_native","require","_multiplex","_hook"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,IAAAA,OAAA,GAAAC,OAAA;AAWA,IAAAC,UAAA,GAAAD,OAAA;AAMA,IAAAE,KAAA,GAAAF,OAAA","ignoreList":[]}

package/lib/commonjs/multiplex.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addCalibrationListener = addCalibrationListener;
+exports.addHeadingListener = addHeadingListener;
+exports.addInterferenceListener = addInterferenceListener;
+var _native = require("./native");
+/**
+ * JS-side fan-out so multiple consumers can subscribe to the same
+ * compass stream without clobbering each other. The native API is
+ * single-callback by design (start, setOnCalibrationNeeded,
+ * setOnInterferenceDetected each own one slot); these helpers wrap
+ * that into multi-listener primitives with reference-counted
+ * lifecycle.
+ *
+ * Mixing direct `NitroCompass.start()` / `setOnCalibrationNeeded()` /
+ * `setOnInterferenceDetected()` calls with these helpers will
+ * clobber the multiplex's internal callback slot — pick one path.
+ */
+
+const headingListeners = new Set();
+const calibrationListeners = new Set();
+const interferenceListeners = new Set();
+let calibrationRegistered = false;
+let interferenceRegistered = false;
+const DEFAULT_FILTER_DEG = 1;
+function dispatchHeading(sample) {
+  for (const cb of Array.from(headingListeners)) {
+    try {
+      cb(sample);
+    } catch (e) {
+      console.error('[NitroCompass] heading listener threw:', e);
+    }
+  }
+}
+function dispatchCalibration(quality) {
+  for (const cb of Array.from(calibrationListeners)) {
+    try {
+      cb(quality);
+    } catch (e) {
+      console.error('[NitroCompass] calibration listener threw:', e);
+    }
+  }
+}
+function dispatchInterference(detected) {
+  for (const cb of Array.from(interferenceListeners)) {
+    try {
+      cb(detected);
+    } catch (e) {
+      console.error('[NitroCompass] interference listener threw:', e);
+    }
+  }
+}
+
+/**
+ * Subscribe to heading samples. The first listener implicitly calls
+ * `NitroCompass.start()`; the last `unsubscribe()` calls
+ * `NitroCompass.stop()`. Returns the unsubscribe function.
+ *
+ * Filter, declination, and pauseOnBackground remain global state on
+ * `NitroCompass` and are shared across all listeners — call
+ * `NitroCompass.setFilter()` etc. directly to tune them.
+ */
+function addHeadingListener(cb) {
+  const wasEmpty = headingListeners.size === 0;
+  headingListeners.add(cb);
+  if (wasEmpty) {
+    _native.NitroCompass.start(DEFAULT_FILTER_DEG, dispatchHeading);
+  }
+  return () => {
+    if (!headingListeners.delete(cb)) return;
+    if (headingListeners.size === 0) {
+      _native.NitroCompass.stop();
+    }
+  };
+}
+
+/**
+ * Subscribe to calibration-bucket transitions. Only fires while a
+ * heading subscription is active. Returns the unsubscribe function.
+ */
+function addCalibrationListener(cb) {
+  if (!calibrationRegistered) {
+    _native.NitroCompass.setOnCalibrationNeeded(dispatchCalibration);
+    calibrationRegistered = true;
+  }
+  calibrationListeners.add(cb);
+  return () => {
+    calibrationListeners.delete(cb);
+  };
+}
+
+/**
+ * Subscribe to magnetic-interference transitions. Only fires while a
+ * heading subscription is active. Returns the unsubscribe function.
+ */
+function addInterferenceListener(cb) {
+  if (!interferenceRegistered) {
+    _native.NitroCompass.setOnInterferenceDetected(dispatchInterference);
+    interferenceRegistered = true;
+  }
+  interferenceListeners.add(cb);
+  return () => {
+    interferenceListeners.delete(cb);
+  };
+}
+//# sourceMappingURL=multiplex.js.map