react-native-nitro-compass 1.1.0 → 1.2.1

package/lib/typescript/src/hook.d.ts

@@ -1,4 +1,4 @@
-import type { AccuracyQuality, CompassSample, SensorDiagnostics } from './specs/NitroCompass.nitro';
+import type { AccuracyQuality, CompassSample, PermissionStatus, SensorDiagnostics } from './specs/NitroCompass.nitro';
 export interface UseCompassOptions {
     /**
      * Minimum change between samples in degrees. Pass `0` for "every
@@ -47,6 +47,44 @@ export interface UseCompassResult {
     hasCompass: boolean;
     /** Which sensor backs the readings on this device. */
     diagnostics: SensorDiagnostics | undefined;
+    /**
+     * Latest platform permission status. Always `'granted'` on Android.
+     * On iOS may transition from `'unknown'` → `'granted'`/`'denied'`
+     * after `requestPermission()` resolves.
+     */
+    permission: PermissionStatus;
+    /**
+     * Synchronous read of the most recent emitted sample (with declination
+     * already applied), or `undefined` if not started yet or no sample
+     * has arrived. Useful inside event handlers without re-rendering.
+     */
+    getCurrentHeading: () => CompassSample | undefined;
+    /**
+     * Force a best-effort sensor recalibration. On Android this re-registers
+     * the sensor listeners (often nudges the magnetometer driver to
+     * re-evaluate calibration); on iOS it dismisses the heading-calibration
+     * overlay and stop/restarts heading updates.
+     */
+    recalibrate: () => void;
+    /**
+     * Set the user's geographic location for a tighter interference gate.
+     * Android uses the WMM2025 model bundled in `GeomagneticField` to
+     * derive the expected field strength at the location; iOS is a no-op
+     * because `CLLocationManager` already uses GPS-derived location
+     * internally for all field-related reasoning. Pass `NaN` or
+     * out-of-range values to revert to the generic 20–70 µT band.
+     */
+    setLocation: (latitude: number, longitude: number) => void;
+    /**
+     * Request the platform permission required to deliver headings.
+     * Android resolves immediately with `'granted'`. On iOS this prompts
+     * the system "Allow location" dialog if the status is `'unknown'`,
+     * resolving once the user makes a choice; subsequent calls resolve
+     * immediately with the cached status (iOS does not re-prompt). The
+     * hook's `permission` field updates automatically when the promise
+     * resolves.
+     */
+    requestPermission: () => Promise<PermissionStatus>;
 }
 /**
  * Ergonomic React wrapper for the NitroCompass surface. Handles

package/lib/typescript/src/hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../src/hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAQnC,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAA;IAC7B,oEAAoE;IACpE,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAA;IACpB,yDAAyD;IACzD,UAAU,EAAE,OAAO,CAAA;IACnB,sDAAsD;IACtD,WAAW,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAC3C;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CA2DlB"}
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../src/hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAQnC,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAA;IAC7B,oEAAoE;IACpE,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAA;IACpB,yDAAyD;IACzD,UAAU,EAAE,OAAO,CAAA;IACnB,sDAAsD;IACtD,WAAW,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC1C;;;;OAIG;IACH,UAAU,EAAE,gBAAgB,CAAA;IAC5B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,aAAa,GAAG,SAAS,CAAA;IAClD;;;;;OAKG;IACH,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1D;;;;;;;;OAQG;IACH,iBAAiB,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACnD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CA0JlB"}

package/lib/typescript/src/index.d.ts

@@ -1,6 +1,6 @@
-import type { AccuracyQuality, CompassSample, NitroCompass as NitroCompassSpec, PermissionStatus, SensorDiagnostics, SensorKind } from './specs/NitroCompass.nitro';
+import type { AccuracyQuality, CompassSample, DebugInfo, NitroCompass as NitroCompassSpec, PermissionStatus, SensorDiagnostics, SensorKind } from './specs/NitroCompass.nitro';
 export { NitroCompass } from './native';
-export type { AccuracyQuality, CompassSample, PermissionStatus, SensorDiagnostics, SensorKind, };
+export type { AccuracyQuality, CompassSample, DebugInfo, PermissionStatus, SensorDiagnostics, SensorKind, };
 export type { NitroCompassSpec as NitroCompassHybridObject };
 export { addCalibrationListener, addHeadingListener, addInterferenceListener, } from './multiplex';
 export { useCompass } from './hook';

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,YAAY,IAAI,gBAAgB,EAChC,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACX,MAAM,4BAA4B,CAAA;AAEnC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,YAAY,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,GACX,CAAA;AACD,YAAY,EAAE,gBAAgB,IAAI,wBAAwB,EAAE,CAAA;AAE5D,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,YAAY,IAAI,gBAAgB,EAChC,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACX,MAAM,4BAA4B,CAAA;AAEnC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,YAAY,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,GACX,CAAA;AACD,YAAY,EAAE,gBAAgB,IAAI,wBAAwB,EAAE,CAAA;AAE5D,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}

package/lib/typescript/src/multiplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplex.d.ts","sourceRoot":"","sources":["../../../src/multiplex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACd,MAAM,4BAA4B,CAAA;AAGnC,KAAK,eAAe,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAA;AACtD,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;AAC7D,KAAK,oBAAoB,GAAG,CAAC,oBAAoB,EAAE,OAAO,KAAK,IAAI,CAAA;AAyCnE;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,MAAM,IAAI,CAYlE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,mBAAmB,GACtB,MAAM,IAAI,CASZ;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,oBAAoB,GACvB,MAAM,IAAI,CASZ"}
+{"version":3,"file":"multiplex.d.ts","sourceRoot":"","sources":["../../../src/multiplex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACd,MAAM,4BAA4B,CAAA;AAGnC,KAAK,eAAe,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAA;AACtD,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;AAC7D,KAAK,oBAAoB,GAAG,CAAC,oBAAoB,EAAE,OAAO,KAAK,IAAI,CAAA;AAyCnE;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,MAAM,IAAI,CAYlE;AASD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,mBAAmB,GACtB,MAAM,IAAI,CAmBZ;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,oBAAoB,GACvB,MAAM,IAAI,CAaZ"}

package/lib/typescript/src/specs/NitroCompass.nitro.d.ts

@@ -1,7 +1,7 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 /**
  * One compass heading sample, delivered to the JS callback registered with
- * `start()`. Both fields are in degrees.
+ * `start()`. Angular fields are in degrees; field strength is in microtesla.
  *
  * - `heading`: heading clockwise from north, in `[0, 360)`. Magnetic by
  *   default; if you call `setDeclination(deg)` the offset is applied
@@ -9,41 +9,122 @@ import type { HybridObject } from 'react-native-nitro-modules';
  *   `getCurrentHeading()`).
  * - `accuracy`: estimated heading uncertainty in degrees, or `-1` when the
  *   platform has not yet reported a usable accuracy. Smaller is better.
- *   On Android this is read from `event.values[4]` of the rotation-vector
- *   sensor when available, otherwise mapped from `SensorManager.SENSOR_STATUS_*`.
- *   On iOS this is `CLHeading.headingAccuracy`.
+ *   On Android, mapped from the magnetometer's `SENSOR_STATUS_*` accuracy
+ *   bucket (the figure-8 calibration signal). On iOS this is
+ *   `CLHeading.headingAccuracy`.
+ * - `fieldStrengthMicroTesla`: magnitude of the local magnetic field in
+ *   microteslas (µT), or `-1` when no reading is available yet. Earth's
+ *   field is normally 25–65 µT; values well outside this band signal
+ *   external interference (laptops, monitors, magnets, metal). Useful
+ *   for rendering a "strength" meter à la consumer compass apps.
  */
 export interface CompassSample {
     heading: number;
     accuracy: number;
+    fieldStrengthMicroTesla: number;
 }
 /**
- * Coarse calibration bucket reported via `setOnCalibrationNeeded`. Buckets
- * are derived from numeric heading accuracy on both platforms (same
- * thresholds), so values agree across iOS and Android:
+ * Coarse calibration bucket reported via `setOnCalibrationNeeded`. The
+ * bucket is derived from a numeric heading-accuracy estimate on both
+ * platforms, but the thresholds differ because the underlying scales
+ * disagree:
  *
- *   `<5°` → `high`, `<15°` → `medium`, `<30°` → `low`, otherwise `unreliable`.
+ * - **Android** — direct mapping from `SensorManager.SENSOR_STATUS_*`:
+ *   `HIGH` → `high`, `MEDIUM` → `medium`, `LOW` → `low`,
+ *   `UNRELIABLE`/`NO_CONTACT` → `unreliable`. The numeric `accuracy`
+ *   field on `CompassSample` is a synthetic upper bound (`<5°`,
+ *   `<15°`, `<30°`, `-1`).
+ * - **iOS** — bucketed from `CLHeading.headingAccuracy` (degrees) with
+ *   relaxed thresholds because Apple's stack rarely reports under 5°
+ *   even on a perfectly-calibrated compass:
+ *   `<20°` → `high`, `<35°` → `medium`, `<55°` → `low`, otherwise
+ *   `unreliable`. `unreliable` is also reported when iOS asks to
+ *   display its built-in calibration UI (we suppress the system UI so
+ *   you can render your own banner).
  *
- * On iOS `unreliable` is also reported when the system asks to display
- * its built-in calibration UI (we suppress it).
+ * The buckets are intended for UX ("show calibrate prompt") — exact
+ * cross-platform parity isn't possible because the platforms emit
+ * different underlying signals.
  */
 export type AccuracyQuality = 'high' | 'medium' | 'low' | 'unreliable';
 /**
  * Identifies which underlying sensor / framework is producing headings.
  *
- * - `rotationVector` — Android `Sensor.TYPE_ROTATION_VECTOR` (gyro + accel
- *   + magnetometer fused). Best quality.
- * - `geomagneticRotationVector` — Android
- *   `Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR` (accel + magnetometer only).
- *   Used as fallback on gyroless / budget devices; lower update rate and
- *   more susceptible to magnetic interference.
+ * - `magnetometer` — Android raw `TYPE_MAGNETIC_FIELD` + `TYPE_ACCELEROMETER`
+ *   computed via `SensorManager.getRotationMatrix()` + `getOrientation()`.
+ *   Stateless: snaps back instantly when external interference (magnets,
+ *   electronics) is removed, instead of waiting for OS-level fusion to
+ *   re-converge.
  * - `coreLocation` — iOS `CLLocationManager` heading. Apple's stack
  *   handles fusion natively.
+ * - `rotationVector` / `geomagneticRotationVector` — legacy values kept
+ *   in the union for source compatibility; no longer returned by current
+ *   builds.
  */
-export type SensorKind = 'rotationVector' | 'geomagneticRotationVector' | 'coreLocation';
+export type SensorKind = 'magnetometer' | 'coreLocation' | 'rotationVector' | 'geomagneticRotationVector';
 export interface SensorDiagnostics {
     sensor: SensorKind;
 }
+/**
+ * Live introspection of the native compass pipeline. Use for
+ * diagnosing user-reported issues (heading wrong, banner stuck,
+ * compass frozen) — none of these fields are needed for normal
+ * operation.
+ *
+ * Numeric fields use `-1` (or `NaN` for `fusedYawDeg`) as a
+ * "not-applicable / not-yet-available" sentinel; consumers should
+ * treat those as missing rather than literal values. Most fields
+ * are Android-only — iOS uses `CLLocationManager` and doesn't expose
+ * the underlying state, so the iOS implementation reports a minimal
+ * subset (`lastFieldMicroTesla`, `interferenceActive`).
+ */
+export interface DebugInfo {
+    /**
+     * Whether the library currently considers external interference to
+     * be active. Driven by field-magnitude band checks AND (Android,
+     * uncalibrated mag only) recent OS hard-iron-bias jumps.
+     */
+    interferenceActive: boolean;
+    /**
+     * Milliseconds since the most recent OS hard-iron bias jump on
+     * Android's uncalibrated magnetometer. `-1` if never seen.
+     * iOS / fallback path: always `-1`.
+     */
+    msSinceLastBiasJump: number;
+    /**
+     * The expected magnetic field magnitude (µT) at the user's
+     * location, derived from `setLocation()`. Used to tighten the
+     * interference band. `-1` if `setLocation()` hasn't been called
+     * with valid coordinates.
+     */
+    expectedFieldMicroTesla: number;
+    /**
+     * Most recent measured field magnitude (µT) — same value surfaced
+     * on `CompassSample.fieldStrengthMicroTesla`. `-1` if no reading.
+     */
+    lastFieldMicroTesla: number;
+    /**
+     * Current value of the gyro-corrected fused yaw (deg, [0, 360)).
+     * `NaN` before any sample has been processed, or on iOS where
+     * gyro fusion is handled inside CLLocationManager.
+     */
+    fusedYawDeg: number;
+    /**
+     * Latest yaw rate (deg/s) derived from game-rotation-vector
+     * deltas. Used to drive the adaptive input low-pass filter.
+     * `0` if game-RV is unavailable / hasn't fired yet.
+     */
+    lastYawRateDegPerS: number;
+    /** Whether `TYPE_GAME_ROTATION_VECTOR` is currently producing events. Always `false` on iOS. */
+    hasGameRotationVector: boolean;
+    /**
+     * Whether Android is sourcing magnetometer data from
+     * `TYPE_MAGNETIC_FIELD_UNCALIBRATED` (preferred — bias-jump
+     * detection works) vs. the `TYPE_MAGNETIC_FIELD` fallback. Always
+     * `false` on iOS.
+     */
+    usingUncalibratedMag: boolean;
+}
 /**
  * Platform permission state required to deliver headings.
  *
@@ -117,9 +198,16 @@ export interface NitroCompass extends HybridObject<{
      * (equivalent to `hasCompass() === false`). Safe to call before `start()`.
      */
     getDiagnostics(): SensorDiagnostics | undefined;
+    /**
+     * Snapshot of the internal compass pipeline. Only intended for
+     * diagnosing user-reported issues — see {@link DebugInfo} for
+     * field-by-field semantics. Cheap to call (no allocations beyond
+     * the returned object); poll at any rate the host UI prefers.
+     */
+    getDebugInfo(): DebugInfo;
     /**
      * Whether the device has the hardware required for a compass reading.
-     * Android: a rotation-vector sensor (fused or geomagnetic) is present.
+     * Android: both a magnetometer and an accelerometer are present.
      * iOS: `CLLocationManager.headingAvailable()`.
      */
     hasCompass(): boolean;
@@ -136,6 +224,24 @@ export interface NitroCompass extends HybridObject<{
      * model like `geomagnetism` keyed on the user's lat/lon.
      */
     setDeclination(degrees: number): void;
+    /**
+     * Set the user's geographic location for a tighter interference
+     * gate. With a valid location, the library replaces the generic
+     * 20–70 µT "Earth field band" with `expectedField ± 15 µT`, where
+     * `expectedField` comes from the WMM2025 model shipped on Android
+     * (`GeomagneticField`). This catches weak interference the generic
+     * band misses — especially at high/low latitudes where Earth's
+     * field is naturally near or above 60 µT.
+     *
+     * Pass `NaN` for either coordinate, or values outside the valid
+     * range (`|lat| > 90`, `|lon| > 180`), to revert to the generic
+     * band. Survives across `start`/`stop`.
+     *
+     * **No-op on iOS.** `CLLocationManager` uses GPS-derived location
+     * internally for all field-related reasoning; layering our own
+     * lookup on top would be redundant.
+     */
+    setLocation(latitude: number, longitude: number): void;
     /**
      * Register a callback fired when the calibration bucket transitions.
      * Replaces any previously registered callback. Pass a no-op to mute.
@@ -173,6 +279,24 @@ export interface NitroCompass extends HybridObject<{
      * `start()`; takes effect immediately.
      */
     setPauseOnBackground(enabled: boolean): void;
+    /**
+     * Force a best-effort sensor recalibration. Resets internal smoothing
+     * and quality-bucket state, then re-registers the underlying sensor
+     * listeners. On many Android OEMs the re-registration nudges the
+     * magnetometer driver to re-evaluate soft/hard-iron calibration, which
+     * unsticks an `UNRELIABLE` bucket that's lingering after a strong
+     * magnetic excursion (e.g. another phone placed on top, then removed).
+     *
+     * On iOS this dismisses the system heading-calibration overlay and
+     * stops/restarts heading updates. Apple's stack handles the
+     * underlying calibration internally.
+     *
+     * Idempotent — safe to call when not started, in which case it's a
+     * no-op. Calibration recovery still requires the user to move the
+     * device through varying orientations; this method just clears the
+     * library's cached state so progress is reflected promptly.
+     */
+    recalibrate(): void;
     /**
      * Read the current platform permission state synchronously.
      * On Android this is always `'granted'` (sensors require no permission);

package/lib/typescript/src/specs/NitroCompass.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NitroCompass.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/NitroCompass.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,YAAY,CAAA;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,2BAA2B,GAC3B,cAAc,CAAA;AAElB,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAa,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACrF;;;;;;;;;;OAUG;IACH,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,IAAI,CAAA;IAE9E,8GAA8G;IAC9G,IAAI,IAAI,IAAI,CAAA;IAEZ,qEAAqE;IACrE,SAAS,IAAI,OAAO,CAAA;IAEpB;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAEhC;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAEjC;;;;OAIG;IACH,cAAc,IAAI,iBAAiB,GAAG,SAAS,CAAA;IAE/C;;;;OAIG;IACH,UAAU,IAAI,OAAO,CAAA;IAErB;;;;OAIG;IACH,iBAAiB,IAAI,aAAa,GAAG,SAAS,CAAA;IAE9C;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAErC;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,GAAG,IAAI,CAAA;IAE1E;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,yBAAyB,CAAC,QAAQ,EAAE,CAAC,oBAAoB,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAA;IAElF;;;;;;;OAOG;IACH,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAE5C;;;;OAIG;IACH,mBAAmB,IAAI,gBAAgB,CAAA;IAEvC;;;;;;;OAOG;IACH,iBAAiB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAC/C"}
+{"version":3,"file":"NitroCompass.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/NitroCompass.nitro.ts"],"names":[],"mappings":"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"}

package/nitrogen/generated/android/c++/JCompassSample.hpp

@@ -35,9 +35,12 @@ namespace margelo::nitro::nitrocompass {
       double heading = this->getFieldValue(fieldHeading);
       static const auto fieldAccuracy = clazz->getField<double>("accuracy");
       double accuracy = this->getFieldValue(fieldAccuracy);
+      static const auto fieldFieldStrengthMicroTesla = clazz->getField<double>("fieldStrengthMicroTesla");
+      double fieldStrengthMicroTesla = this->getFieldValue(fieldFieldStrengthMicroTesla);
       return CompassSample(
         heading,
-        accuracy
+        accuracy,
+        fieldStrengthMicroTesla
       );
     }
 
@@ -47,13 +50,14 @@ namespace margelo::nitro::nitrocompass {
      */
     [[maybe_unused]]
     static jni::local_ref<JCompassSample::javaobject> fromCpp(const CompassSample& value) {
-      using JSignature = JCompassSample(double, double);
+      using JSignature = JCompassSample(double, double, double);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.heading,
-        value.accuracy
+        value.accuracy,
+        value.fieldStrengthMicroTesla
       );
     }
   };

package/nitrogen/generated/android/c++/JDebugInfo.hpp

@@ -0,0 +1,85 @@
+///
+/// JDebugInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DebugInfo.hpp"
+
+
+
+namespace margelo::nitro::nitrocompass {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DebugInfo" and the the Kotlin data class "DebugInfo".
+   */
+  struct JDebugInfo final: public jni::JavaClass<JDebugInfo> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/DebugInfo;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DebugInfo by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DebugInfo toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldInterferenceActive = clazz->getField<jboolean>("interferenceActive");
+      jboolean interferenceActive = this->getFieldValue(fieldInterferenceActive);
+      static const auto fieldMsSinceLastBiasJump = clazz->getField<double>("msSinceLastBiasJump");
+      double msSinceLastBiasJump = this->getFieldValue(fieldMsSinceLastBiasJump);
+      static const auto fieldExpectedFieldMicroTesla = clazz->getField<double>("expectedFieldMicroTesla");
+      double expectedFieldMicroTesla = this->getFieldValue(fieldExpectedFieldMicroTesla);
+      static const auto fieldLastFieldMicroTesla = clazz->getField<double>("lastFieldMicroTesla");
+      double lastFieldMicroTesla = this->getFieldValue(fieldLastFieldMicroTesla);
+      static const auto fieldFusedYawDeg = clazz->getField<double>("fusedYawDeg");
+      double fusedYawDeg = this->getFieldValue(fieldFusedYawDeg);
+      static const auto fieldLastYawRateDegPerS = clazz->getField<double>("lastYawRateDegPerS");
+      double lastYawRateDegPerS = this->getFieldValue(fieldLastYawRateDegPerS);
+      static const auto fieldHasGameRotationVector = clazz->getField<jboolean>("hasGameRotationVector");
+      jboolean hasGameRotationVector = this->getFieldValue(fieldHasGameRotationVector);
+      static const auto fieldUsingUncalibratedMag = clazz->getField<jboolean>("usingUncalibratedMag");
+      jboolean usingUncalibratedMag = this->getFieldValue(fieldUsingUncalibratedMag);
+      return DebugInfo(
+        static_cast<bool>(interferenceActive),
+        msSinceLastBiasJump,
+        expectedFieldMicroTesla,
+        lastFieldMicroTesla,
+        fusedYawDeg,
+        lastYawRateDegPerS,
+        static_cast<bool>(hasGameRotationVector),
+        static_cast<bool>(usingUncalibratedMag)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDebugInfo::javaobject> fromCpp(const DebugInfo& value) {
+      using JSignature = JDebugInfo(jboolean, double, double, double, double, double, jboolean, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.interferenceActive,
+        value.msSinceLastBiasJump,
+        value.expectedFieldMicroTesla,
+        value.lastFieldMicroTesla,
+        value.fusedYawDeg,
+        value.lastYawRateDegPerS,
+        value.hasGameRotationVector,
+        value.usingUncalibratedMag
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrocompass

package/nitrogen/generated/android/c++/JHybridNitroCompassSpec.cpp

@@ -11,6 +11,8 @@
 namespace margelo::nitro::nitrocompass { struct SensorDiagnostics; }
 // Forward declaration of `SensorKind` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { enum class SensorKind; }
+// Forward declaration of `DebugInfo` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct DebugInfo; }
 // Forward declaration of `CompassSample` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { struct CompassSample; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
@@ -23,6 +25,8 @@ namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
 #include "JSensorDiagnostics.hpp"
 #include "SensorKind.hpp"
 #include "JSensorKind.hpp"
+#include "DebugInfo.hpp"
+#include "JDebugInfo.hpp"
 #include "CompassSample.hpp"
 #include "JCompassSample.hpp"
 #include "PermissionStatus.hpp"
@@ -96,6 +100,11 @@ namespace margelo::nitro::nitrocompass {
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
+  DebugInfo JHybridNitroCompassSpec::getDebugInfo() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JDebugInfo>()>("getDebugInfo");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
   bool JHybridNitroCompassSpec::hasCompass() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("hasCompass");
     auto __result = method(_javaPart);
@@ -110,6 +119,10 @@ namespace margelo::nitro::nitrocompass {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* degrees */)>("setDeclination");
     method(_javaPart, degrees);
   }
+  void JHybridNitroCompassSpec::setLocation(double latitude, double longitude) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* latitude */, double /* longitude */)>("setLocation");
+    method(_javaPart, latitude, longitude);
+  }
   void JHybridNitroCompassSpec::setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_AccuracyQuality::javaobject> /* onChange */)>("setOnCalibrationNeeded_cxx");
     method(_javaPart, JFunc_void_AccuracyQuality_cxx::fromCpp(onChange));
@@ -122,6 +135,10 @@ namespace margelo::nitro::nitrocompass {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setPauseOnBackground");
     method(_javaPart, enabled);
   }
+  void JHybridNitroCompassSpec::recalibrate() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("recalibrate");
+    method(_javaPart);
+  }
   PermissionStatus JHybridNitroCompassSpec::getPermissionStatus() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPermissionStatus>()>("getPermissionStatus");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridNitroCompassSpec.hpp

@@ -60,12 +60,15 @@ namespace margelo::nitro::nitrocompass {
     void setFilter(double degrees) override;
     void setSmoothing(double alpha) override;
     std::optional<SensorDiagnostics> getDiagnostics() override;
+    DebugInfo getDebugInfo() override;
     bool hasCompass() override;
     std::optional<CompassSample> getCurrentHeading() override;
     void setDeclination(double degrees) override;
+    void setLocation(double latitude, double longitude) override;
     void setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) override;
     void setOnInterferenceDetected(const std::function<void(bool /* interferenceDetected */)>& onChange) override;
     void setPauseOnBackground(bool enabled) override;
+    void recalibrate() override;
     PermissionStatus getPermissionStatus() override;
     std::shared_ptr<Promise<PermissionStatus>> requestPermission() override;
 

package/nitrogen/generated/android/c++/JSensorKind.hpp

@@ -42,15 +42,18 @@ namespace margelo::nitro::nitrocompass {
     static jni::alias_ref<JSensorKind> fromCpp(SensorKind value) {
       static const auto clazz = javaClassStatic();
       switch (value) {
+        case SensorKind::MAGNETOMETER:
+          static const auto fieldMAGNETOMETER = clazz->getStaticField<JSensorKind>("MAGNETOMETER");
+          return clazz->getStaticFieldValue(fieldMAGNETOMETER);
+        case SensorKind::CORELOCATION:
+          static const auto fieldCORELOCATION = clazz->getStaticField<JSensorKind>("CORELOCATION");
+          return clazz->getStaticFieldValue(fieldCORELOCATION);
         case SensorKind::ROTATIONVECTOR:
           static const auto fieldROTATIONVECTOR = clazz->getStaticField<JSensorKind>("ROTATIONVECTOR");
           return clazz->getStaticFieldValue(fieldROTATIONVECTOR);
         case SensorKind::GEOMAGNETICROTATIONVECTOR:
           static const auto fieldGEOMAGNETICROTATIONVECTOR = clazz->getStaticField<JSensorKind>("GEOMAGNETICROTATIONVECTOR");
           return clazz->getStaticFieldValue(fieldGEOMAGNETICROTATIONVECTOR);
-        case SensorKind::CORELOCATION:
-          static const auto fieldCORELOCATION = clazz->getStaticField<JSensorKind>("CORELOCATION");
-          return clazz->getStaticFieldValue(fieldCORELOCATION);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));
           throw std::invalid_argument("Invalid enum value (" + stringValue + "!");

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocompass/CompassSample.kt

@@ -23,7 +23,10 @@ data class CompassSample(
   val heading: Double,
   @DoNotStrip
   @Keep
-  val accuracy: Double
+  val accuracy: Double,
+  @DoNotStrip
+  @Keep
+  val fieldStrengthMicroTesla: Double
 ) {
   /* primary constructor */
 
@@ -32,12 +35,14 @@ data class CompassSample(
     if (other !is CompassSample) return false
     return Objects.deepEquals(this.heading, other.heading)
       && Objects.deepEquals(this.accuracy, other.accuracy)
+      && Objects.deepEquals(this.fieldStrengthMicroTesla, other.fieldStrengthMicroTesla)
   }
 
   override fun hashCode(): Int {
     return arrayOf(
       heading,
-      accuracy
+      accuracy,
+      fieldStrengthMicroTesla
     ).contentDeepHashCode()
   }
 
@@ -49,8 +54,8 @@ data class CompassSample(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(heading: Double, accuracy: Double): CompassSample {
-      return CompassSample(heading, accuracy)
+    private fun fromCpp(heading: Double, accuracy: Double, fieldStrengthMicroTesla: Double): CompassSample {
+      return CompassSample(heading, accuracy, fieldStrengthMicroTesla)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocompass/DebugInfo.kt

@@ -0,0 +1,86 @@
+///
+/// DebugInfo.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrocompass
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "DebugInfo".
+ */
+@DoNotStrip
+@Keep
+data class DebugInfo(
+  @DoNotStrip
+  @Keep
+  val interferenceActive: Boolean,
+  @DoNotStrip
+  @Keep
+  val msSinceLastBiasJump: Double,
+  @DoNotStrip
+  @Keep
+  val expectedFieldMicroTesla: Double,
+  @DoNotStrip
+  @Keep
+  val lastFieldMicroTesla: Double,
+  @DoNotStrip
+  @Keep
+  val fusedYawDeg: Double,
+  @DoNotStrip
+  @Keep
+  val lastYawRateDegPerS: Double,
+  @DoNotStrip
+  @Keep
+  val hasGameRotationVector: Boolean,
+  @DoNotStrip
+  @Keep
+  val usingUncalibratedMag: Boolean
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is DebugInfo) return false
+    return Objects.deepEquals(this.interferenceActive, other.interferenceActive)
+      && Objects.deepEquals(this.msSinceLastBiasJump, other.msSinceLastBiasJump)
+      && Objects.deepEquals(this.expectedFieldMicroTesla, other.expectedFieldMicroTesla)
+      && Objects.deepEquals(this.lastFieldMicroTesla, other.lastFieldMicroTesla)
+      && Objects.deepEquals(this.fusedYawDeg, other.fusedYawDeg)
+      && Objects.deepEquals(this.lastYawRateDegPerS, other.lastYawRateDegPerS)
+      && Objects.deepEquals(this.hasGameRotationVector, other.hasGameRotationVector)
+      && Objects.deepEquals(this.usingUncalibratedMag, other.usingUncalibratedMag)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      interferenceActive,
+      msSinceLastBiasJump,
+      expectedFieldMicroTesla,
+      lastFieldMicroTesla,
+      fusedYawDeg,
+      lastYawRateDegPerS,
+      hasGameRotationVector,
+      usingUncalibratedMag
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(interferenceActive: Boolean, msSinceLastBiasJump: Double, expectedFieldMicroTesla: Double, lastFieldMicroTesla: Double, fusedYawDeg: Double, lastYawRateDegPerS: Double, hasGameRotationVector: Boolean, usingUncalibratedMag: Boolean): DebugInfo {
+      return DebugInfo(interferenceActive, msSinceLastBiasJump, expectedFieldMicroTesla, lastFieldMicroTesla, fusedYawDeg, lastYawRateDegPerS, hasGameRotationVector, usingUncalibratedMag)
+    }
+  }
+}