react-native-nitro-compass 0.1.0

package/lib/commonjs/multiplex.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_native","require","headingListeners","Set","calibrationListeners","interferenceListeners","calibrationRegistered","interferenceRegistered","DEFAULT_FILTER_DEG","dispatchHeading","sample","cb","Array","from","e","console","error","dispatchCalibration","quality","dispatchInterference","detected","addHeadingListener","wasEmpty","size","add","NitroCompass","start","delete","stop","addCalibrationListener","setOnCalibrationNeeded","addInterferenceListener","setOnInterferenceDetected"],"sourceRoot":"../../src","sources":["multiplex.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/native.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NitroCompass = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+const NitroCompass = exports.NitroCompass = _reactNativeNitroModules.NitroModules.createHybridObject('NitroCompass');
+//# sourceMappingURL=native.js.map

package/lib/commonjs/native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","NitroCompass","exports","NitroModules","createHybridObject"],"sourceRoot":"../../src","sources":["native.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAGO,MAAMC,YAAY,GAAAC,OAAA,CAAAD,YAAA,GACvBE,qCAAY,CAACC,kBAAkB,CAAmB,cAAc,CAAC","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/specs/NitroCompass.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=NitroCompass.nitro.js.map

package/lib/commonjs/specs/NitroCompass.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/NitroCompass.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/hook.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import { useEffect, useRef, useState } from 'react';
+import { NitroCompass } from './native';
+import { addCalibrationListener, addHeadingListener, addInterferenceListener } from './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`.
+ */
+export function useCompass(options = {}) {
+  const {
+    filterDegrees = 1,
+    declination = 0,
+    pauseOnBackground = true,
+    enabled = true
+  } = options;
+  const [reading, setReading] = useState(null);
+  const [quality, setQuality] = useState(null);
+  const [interfering, setInterfering] = useState(false);
+  const [hasCompass] = useState(() => NitroCompass.hasCompass());
+  const [diagnostics] = useState(() => 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 = useRef(filterDegrees);
+  filterRef.current = filterDegrees;
+  useEffect(() => {
+    NitroCompass.setFilter(filterDegrees);
+  }, [filterDegrees]);
+  useEffect(() => {
+    NitroCompass.setDeclination(declination);
+  }, [declination]);
+  useEffect(() => {
+    NitroCompass.setPauseOnBackground(pauseOnBackground);
+  }, [pauseOnBackground]);
+  useEffect(() => {
+    if (!hasCompass) return;
+    return addCalibrationListener(setQuality);
+  }, [hasCompass]);
+  useEffect(() => {
+    if (!hasCompass) return;
+    return addInterferenceListener(setInterfering);
+  }, [hasCompass]);
+  useEffect(() => {
+    if (!hasCompass || !enabled) return;
+    const off = addHeadingListener(setReading);
+    // Multiplex starts the sensor with a default filter; re-apply the
+    // current option after subscribing.
+    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/module/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useRef","useState","NitroCompass","addCalibrationListener","addHeadingListener","addInterferenceListener","useCompass","options","filterDegrees","declination","pauseOnBackground","enabled","reading","setReading","quality","setQuality","interfering","setInterfering","hasCompass","diagnostics","getDiagnostics","filterRef","current","setFilter","setDeclination","setPauseOnBackground","off"],"sourceRoot":"../../src","sources":["hook.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AAMnD,SAASC,YAAY,QAAQ,UAAU;AACvC,SACEC,sBAAsB,EACtBC,kBAAkB,EAClBC,uBAAuB,QAClB,aAAa;AA2CpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,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,GAAGZ,QAAQ,CAAuB,IAAI,CAAC;EAClE,MAAM,CAACa,OAAO,EAAEC,UAAU,CAAC,GAAGd,QAAQ,CAAyB,IAAI,CAAC;EACpE,MAAM,CAACe,WAAW,EAAEC,cAAc,CAAC,GAAGhB,QAAQ,CAAC,KAAK,CAAC;EAErD,MAAM,CAACiB,UAAU,CAAC,GAAGjB,QAAQ,CAAC,MAAMC,YAAY,CAACgB,UAAU,CAAC,CAAC,CAAC;EAC9D,MAAM,CAACC,WAAW,CAAC,GAAGlB,QAAQ,CAAC,MAAMC,YAAY,CAACkB,cAAc,CAAC,CAAC,CAAC;;EAEnE;EACA;EACA;EACA,MAAMC,SAAS,GAAGrB,MAAM,CAACQ,aAAa,CAAC;EACvCa,SAAS,CAACC,OAAO,GAAGd,aAAa;EAEjCT,SAAS,CAAC,MAAM;IACdG,YAAY,CAACqB,SAAS,CAACf,aAAa,CAAC;EACvC,CAAC,EAAE,CAACA,aAAa,CAAC,CAAC;EAEnBT,SAAS,CAAC,MAAM;IACdG,YAAY,CAACsB,cAAc,CAACf,WAAW,CAAC;EAC1C,CAAC,EAAE,CAACA,WAAW,CAAC,CAAC;EAEjBV,SAAS,CAAC,MAAM;IACdG,YAAY,CAACuB,oBAAoB,CAACf,iBAAiB,CAAC;EACtD,CAAC,EAAE,CAACA,iBAAiB,CAAC,CAAC;EAEvBX,SAAS,CAAC,MAAM;IACd,IAAI,CAACmB,UAAU,EAAE;IACjB,OAAOf,sBAAsB,CAACY,UAAU,CAAC;EAC3C,CAAC,EAAE,CAACG,UAAU,CAAC,CAAC;EAEhBnB,SAAS,CAAC,MAAM;IACd,IAAI,CAACmB,UAAU,EAAE;IACjB,OAAOb,uBAAuB,CAACY,cAAc,CAAC;EAChD,CAAC,EAAE,CAACC,UAAU,CAAC,CAAC;EAEhBnB,SAAS,CAAC,MAAM;IACd,IAAI,CAACmB,UAAU,IAAI,CAACP,OAAO,EAAE;IAC7B,MAAMe,GAAG,GAAGtB,kBAAkB,CAACS,UAAU,CAAC;IAC1C;IACA;IACAX,YAAY,CAACqB,SAAS,CAACF,SAAS,CAACC,OAAO,CAAC;IACzC,OAAOI,GAAG;IACV;EACF,CAAC,EAAE,CAACR,UAAU,EAAEP,OAAO,CAAC,CAAC;EAEzB,OAAO;IAAEC,OAAO;IAAEE,OAAO;IAAEE,WAAW;IAAEE,UAAU;IAAEC;EAAY,CAAC;AACnE","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export { NitroCompass } from './native';
+export { addCalibrationListener, addHeadingListener, addInterferenceListener } from './multiplex';
+export { useCompass } from './hook';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroCompass","addCalibrationListener","addHeadingListener","addInterferenceListener","useCompass"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AASA,SAASA,YAAY,QAAQ,UAAU;AAWvC,SACEC,sBAAsB,EACtBC,kBAAkB,EAClBC,uBAAuB,QAClB,aAAa;AAEpB,SAASC,UAAU,QAAQ,QAAQ","ignoreList":[]}

package/lib/module/multiplex.js

@@ -0,0 +1,103 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+import { NitroCompass } from './native';
+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.
+ */
+export function addHeadingListener(cb) {
+  const wasEmpty = headingListeners.size === 0;
+  headingListeners.add(cb);
+  if (wasEmpty) {
+    NitroCompass.start(DEFAULT_FILTER_DEG, dispatchHeading);
+  }
+  return () => {
+    if (!headingListeners.delete(cb)) return;
+    if (headingListeners.size === 0) {
+      NitroCompass.stop();
+    }
+  };
+}
+
+/**
+ * Subscribe to calibration-bucket transitions. Only fires while a
+ * heading subscription is active. Returns the unsubscribe function.
+ */
+export function addCalibrationListener(cb) {
+  if (!calibrationRegistered) {
+    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.
+ */
+export function addInterferenceListener(cb) {
+  if (!interferenceRegistered) {
+    NitroCompass.setOnInterferenceDetected(dispatchInterference);
+    interferenceRegistered = true;
+  }
+  interferenceListeners.add(cb);
+  return () => {
+    interferenceListeners.delete(cb);
+  };
+}
+//# sourceMappingURL=multiplex.js.map

package/lib/module/multiplex.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroCompass","headingListeners","Set","calibrationListeners","interferenceListeners","calibrationRegistered","interferenceRegistered","DEFAULT_FILTER_DEG","dispatchHeading","sample","cb","Array","from","e","console","error","dispatchCalibration","quality","dispatchInterference","detected","addHeadingListener","wasEmpty","size","add","start","delete","stop","addCalibrationListener","setOnCalibrationNeeded","addInterferenceListener","setOnInterferenceDetected"],"sourceRoot":"../../src","sources":["multiplex.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/native.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+export const NitroCompass = NitroModules.createHybridObject('NitroCompass');
+//# sourceMappingURL=native.js.map

package/lib/module/native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","NitroCompass","createHybridObject"],"sourceRoot":"../../src","sources":["native.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,OAAO,MAAMC,YAAY,GACvBD,YAAY,CAACE,kBAAkB,CAAmB,cAAc,CAAC","ignoreList":[]}

package/lib/module/specs/NitroCompass.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NitroCompass.nitro.js.map

package/lib/module/specs/NitroCompass.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/NitroCompass.nitro.ts"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,49 @@
+import type { AccuracyQuality, CompassSample, SensorDiagnostics } from './specs/NitroCompass.nitro';
+export interface UseCompassOptions {
+    /**
+     * Minimum change between samples in degrees. Pass `0` for "every
+     * event". Default `1`. Updated live via `NitroCompass.setFilter()`.
+     * Note: this is global state shared with any other consumer of
+     * the library — last-write-wins.
+     */
+    filterDegrees?: number;
+    /**
+     * Magnetic-to-true offset in signed degrees. Default `0` (magnetic).
+     * Pull from a model like `geomagnetism` keyed on the user's lat/lon.
+     * Like `filterDegrees`, this is shared global state.
+     */
+    declination?: number;
+    /**
+     * Pause the underlying sensor when the app is backgrounded. Default
+     * `true`. Shared global state.
+     */
+    pauseOnBackground?: boolean;
+    /**
+     * Toggle the heading subscription without unmounting the hook.
+     * Default `true`. When `false`, the hook still observes calibration
+     * and interference (so you can show warnings) but won't tear down
+     * its own state — `reading` simply stops updating.
+     */
+    enabled?: boolean;
+}
+export interface UseCompassResult {
+    /** Latest emitted sample, or `null` until the first arrives. */
+    reading: CompassSample | null;
+    /** Coarse accuracy bucket, or `null` until the first transition. */
+    quality: AccuracyQuality | null;
+    /** Whether external magnetic interference is currently detected. */
+    interfering: boolean;
+    /** Hardware availability — read once on first render. */
+    hasCompass: boolean;
+    /** Which sensor backs the readings on this device. */
+    diagnostics: SensorDiagnostics | undefined;
+}
+/**
+ * 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`.
+ */
+export declare function useCompass(options?: UseCompassOptions): UseCompassResult;
+//# sourceMappingURL=hook.d.ts.map

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

@@ -0,0 +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;;;;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,CAsDlB"}

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

@@ -0,0 +1,8 @@
+import type { AccuracyQuality, CompassSample, NitroCompass as NitroCompassSpec, PermissionStatus, SensorDiagnostics, SensorKind } from './specs/NitroCompass.nitro';
+export { NitroCompass } from './native';
+export type { AccuracyQuality, CompassSample, PermissionStatus, SensorDiagnostics, SensorKind, };
+export type { NitroCompassSpec as NitroCompassHybridObject };
+export { addCalibrationListener, addHeadingListener, addInterferenceListener, } from './multiplex';
+export { useCompass } from './hook';
+export type { UseCompassOptions, UseCompassResult } from './hook';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+import type { AccuracyQuality, CompassSample } from './specs/NitroCompass.nitro';
+type HeadingListener = (sample: CompassSample) => void;
+type CalibrationListener = (quality: AccuracyQuality) => void;
+type InterferenceListener = (interferenceDetected: boolean) => void;
+/**
+ * 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.
+ */
+export declare function addHeadingListener(cb: HeadingListener): () => void;
+/**
+ * Subscribe to calibration-bucket transitions. Only fires while a
+ * heading subscription is active. Returns the unsubscribe function.
+ */
+export declare function addCalibrationListener(cb: CalibrationListener): () => void;
+/**
+ * Subscribe to magnetic-interference transitions. Only fires while a
+ * heading subscription is active. Returns the unsubscribe function.
+ */
+export declare function addInterferenceListener(cb: InterferenceListener): () => void;
+export {};
+//# sourceMappingURL=multiplex.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,3 @@
+import type { NitroCompass as NitroCompassSpec } from './specs/NitroCompass.nitro';
+export declare const NitroCompass: NitroCompassSpec;
+//# sourceMappingURL=native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../src/native.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElF,eAAO,MAAM,YAAY,kBAC0C,CAAA"}

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

@@ -0,0 +1,176 @@
+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.
+ *
+ * - `heading`: heading clockwise from north, in `[0, 360)`. Magnetic by
+ *   default; if you call `setDeclination(deg)` the offset is applied
+ *   natively before this sample is delivered (and reflected in
+ *   `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`.
+ */
+export interface CompassSample {
+    heading: number;
+    accuracy: 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:
+ *
+ *   `<5°` → `high`, `<15°` → `medium`, `<30°` → `low`, otherwise `unreliable`.
+ *
+ * On iOS `unreliable` is also reported when the system asks to display
+ * its built-in calibration UI (we suppress it).
+ */
+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.
+ * - `coreLocation` — iOS `CLLocationManager` heading. Apple's stack
+ *   handles fusion natively.
+ */
+export type SensorKind = 'rotationVector' | 'geomagneticRotationVector' | 'coreLocation';
+export interface SensorDiagnostics {
+    sensor: SensorKind;
+}
+/**
+ * Platform permission state required to deliver headings.
+ *
+ * - `granted` — headings will deliver. iOS: `authorizedAlways` /
+ *   `authorizedWhenInUse`. Android: always (sensors require no permission).
+ * - `denied` — user has refused or the OS has restricted access (e.g.
+ *   parental controls). On iOS, `start()` will throw with this status.
+ * - `unknown` — iOS `notDetermined`: nothing has been asked yet. Calling
+ *   `requestPermission()` is the way to resolve from `unknown` to
+ *   `granted`/`denied`.
+ */
+export type PermissionStatus = 'granted' | 'denied' | 'unknown';
+/**
+ * Native compass module. Pull this from `NitroModules.createHybridObject`
+ * via the bundled `NitroCompass` export, e.g.:
+ *
+ * ```ts
+ * import { NitroCompass } from 'react-native-nitro-compass'
+ *
+ * NitroCompass.start(1, ({ heading, accuracy }) => {
+ *   console.log(heading, accuracy)
+ * })
+ * NitroCompass.stop()
+ * ```
+ */
+export interface NitroCompass extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Begin emitting heading samples to `onHeading`. If `start()` has already
+     * been called without a matching `stop()`, the previous subscription is
+     * silently torn down and replaced — the old `onHeading` is detached.
+     *
+     * @param filterDegrees Minimum change (in degrees) between samples before
+     *   the next one is emitted. Pass `0` for "every event"; typical UI values
+     *   are 1–3. Use `setFilter()` to update without restarting.
+     * @param onHeading JS callback invoked on each accepted sample. Called on
+     *   the JS thread; calling `stop()` from inside this callback is safe.
+     */
+    start(filterDegrees: number, onHeading: (sample: CompassSample) => void): void;
+    /** Stop the underlying sensor / location-manager subscription. Idempotent — safe to call when not started. */
+    stop(): void;
+    /** Whether `start()` has been called without a matching `stop()`. */
+    isStarted(): boolean;
+    /**
+     * Update the deadband filter live without tearing down the subscription.
+     * Same semantics as the `filterDegrees` argument to `start()`. Has no
+     * effect until `start()` is called.
+     */
+    setFilter(degrees: number): void;
+    /**
+     * Describe which underlying sensor / framework would produce headings on
+     * this device. Returns `undefined` if the device has no compass hardware
+     * (equivalent to `hasCompass() === false`). Safe to call before `start()`.
+     */
+    getDiagnostics(): SensorDiagnostics | undefined;
+    /**
+     * Whether the device has the hardware required for a compass reading.
+     * Android: a rotation-vector sensor (fused or geomagnetic) is present.
+     * iOS: `CLLocationManager.headingAvailable()`.
+     */
+    hasCompass(): boolean;
+    /**
+     * Last sample emitted by the active subscription, with declination
+     * already applied. Returns `undefined` when not started, or when started
+     * but no sample has arrived yet.
+     */
+    getCurrentHeading(): CompassSample | undefined;
+    /**
+     * Magnetic-to-true offset (degrees, signed) added to every heading
+     * before it leaves the native side. Pass `0` to revert to magnetic.
+     * Survives across `start`/`stop`. Apply your own declination from a
+     * model like `geomagnetism` keyed on the user's lat/lon.
+     */
+    setDeclination(degrees: number): void;
+    /**
+     * Register a callback fired when the calibration bucket transitions.
+     * Replaces any previously registered callback. Pass a no-op to mute.
+     * The callback is invoked on the JS thread.
+     */
+    setOnCalibrationNeeded(onChange: (quality: AccuracyQuality) => void): void;
+    /**
+     * Register a callback fired when external magnetic interference is
+     * detected — typical sources are laptops, monitors, car engines, and
+     * large steel structures, all of which can skew heading by tens of
+     * degrees while the calibration bucket still reads `'medium'` or
+     * better. Fires `true` when the raw magnetic field magnitude leaves
+     * the normal Earth band (~20–70 µT) and `false` when it returns.
+     * Only transitions are reported; the callback is debounce-free, so
+     * brief excursions still fire.
+     *
+     * Replaces any previously registered callback. Pass a no-op to mute.
+     * The callback is invoked on the JS thread. Only meaningful while
+     * `start()` is active.
+     *
+     * iOS uses `CMDeviceMotion.magneticField` — the calibrated field
+     * with the device's own hard-iron bias subtracted in real time.
+     * No transitions are reported until CoreMotion's bias estimate
+     * converges (a second or two of normal device movement); that's
+     * required, otherwise raw readings dominated by internal bias
+     * would fire false alarms continuously.
+     */
+    setOnInterferenceDetected(onChange: (interferenceDetected: boolean) => void): void;
+    /**
+     * Toggle automatic pause/resume on app background/foreground. Default
+     * `true`. When enabled, the underlying sensor / location-manager
+     * subscription is silently paused while the app is backgrounded and
+     * resumed when it returns to the foreground; the JS callback and
+     * declination are preserved across the pause. Call before or after
+     * `start()`; takes effect immediately.
+     */
+    setPauseOnBackground(enabled: boolean): void;
+    /**
+     * Read the current platform permission state synchronously.
+     * On Android this is always `'granted'` (sensors require no permission);
+     * on iOS it maps `CLLocationManager.authorizationStatus`.
+     */
+    getPermissionStatus(): PermissionStatus;
+    /**
+     * Request the platform permission required to deliver headings. On iOS
+     * this prompts the system "Allow location" dialog if the status is
+     * `'unknown'` and resolves once the user makes a choice. If already
+     * `'granted'` or `'denied'` it resolves immediately with that value
+     * (iOS does not re-prompt). On Android it resolves immediately with
+     * `'granted'`.
+     */
+    requestPermission(): Promise<PermissionStatus>;
+}
+//# sourceMappingURL=NitroCompass.nitro.d.ts.map

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

@@ -0,0 +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;;;;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"}

package/nitro.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": [
+    "nitrocompass"
+  ],
+  "ios": {
+    "iosModuleName": "NitroCompass"
+  },
+  "android": {
+    "androidNamespace": [
+      "nitrocompass"
+    ],
+    "androidCxxLibName": "NitroCompass"
+  },
+  "autolinking": {
+    "NitroCompass": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridNitroCompass"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridNitroCompass"
+      }
+    }
+  },
+  "ignorePaths": [
+    "**/node_modules"
+  ]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true