therms-device-tracker 1.0.0-rc.1

package/ios/ThermsGeofenceTests.swift

@@ -0,0 +1,474 @@
+import XCTest
+import CoreLocation
+@testable import ThermsDeviceTracker
+
+/**
+ * Native XCTest cases exercising seams in GeofenceManager / LocationStore / ScheduleManager / MotionActivityProvider.
+ *
+ * Uses:
+ *  - MockRegionMonitor implementing GeofenceRegionMonitoring to record start/stop (no real CLLocationManager).
+ *  - LocationStore injected with isolated UserDefaults(suiteName:) (no .standard side effects).
+ *  - lastLocationProvider closure, on* callbacks, handle* entry points.
+ *  - Direct MotionActivityProvider() entrypoint + onActivityUpdate/onPedometerUpdate/onError callback capture for seam tests (no internal manager injection).
+ *
+ * Tests cover:
+ *  - addGeofence/remove/getGeofences + monitor calls + persist via store.
+ *  - addGeofences (bulk) / removeGeofences (list or all) + persistence + onGeofencesChange + monitor calls.
+ *  - Bad inputs: invalid geofence dicts (missing id/lat/lon/radius, nulls, wrong types), bad remove ids (non-existing + nil for all); graceful no-op no crash no persist (note: empty string identifier is accepted as valid degenerate key by current seam guards).
+ *  - handleDidEnterRegion / handleDidExitRegion (action, identifier, location from provider, extras).
+ *  - LocationStore: id gen on insert, remove(byId), geofence save/load roundtrip (core + extras), clear.
+ *  - ScheduleManager start with config interval (exercises seam).
+ *  - Direct restorePersistedGeofences() (iOS pure; Android via startMonitoring entrypoint) exercising "populates memory only (no side effects / do not notify or start)" + getGeofences() roundtrip + no-callback asserts.
+ *  - MotionActivityProvider: configure (enable flags), start/stop, callback assignment/capture for onActivityUpdate, onPedometerUpdate, onError; disabled paths and multi start/stop (direct entrypoints, no crash).
+ *
+ * Isolation: no real monitoring, correct event payloads, durability roundtrips.
+ * Running (Xcode): Add/include ThermsGeofenceTests.swift in an XCTest target (for @testable import ThermsDeviceTracker access to the module). Use `npm run open:ios` (after prebuild), then Product > Test (Cmd+U) in Xcode. On macOS host some MotionActivityProvider paths may be no-op due to hardware availability (tests focus on seam wiring/no-crash). `swift test` requires additional SPM configuration (not provided here).
+ */
+final class ThermsGeofenceTests: XCTestCase {
+
+  // Simple mock implementing the protocol seam (records calls only).
+  class MockRegionMonitor: GeofenceRegionMonitoring {
+    var started: [CLRegion] = []
+    var stopped: [CLRegion] = []
+    func startMonitoring(for region: CLRegion) { started.append(region) }
+    func stopMonitoring(for region: CLRegion) { stopped.append(region) }
+  }
+
+  func testAddGeofence_populatesGetAndPersistsToStore() {
+    let suite = "test.add.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+
+    var changes: [[String: Any]] = []
+    mgr.onGeofencesChange = { p in
+      if let on = p["on"] as? [[String: Any]] { changes = on }
+    }
+
+    let dict: [String: Any] = [
+      "identifier": "f1",
+      "latitude": 37.7749,
+      "longitude": -122.4194,
+      "radius": 150.0,
+      "notifyOnEntry": true,
+      "notifyOnExit": false
+    ]
+    mgr.addGeofence(from: dict)
+
+    // Memory population (getGeofences) and persist/notify always happen (deterministic).
+    // startMonitoring on monitor is conditional on canMonitorRegions() (true in iOS test targets; may be false on macOS host XCTest).
+    // This uses public seam; no env-branching in assertions.
+    XCTAssertEqual(mgr.getGeofences().count, 1)
+    XCTAssertEqual(mgr.getGeofences()[0]["identifier"] as? String, "f1")
+    let saved = store.loadGeofences()
+    XCTAssertEqual(saved.count, 1)
+    XCTAssertEqual(saved[0]["identifier"] as? String, "f1")
+    XCTAssertEqual(saved[0]["radius"] as? Double, 150.0)
+    XCTAssertEqual(changes.count, 1)
+  }
+
+  func testRemoveGeofence_stopsMonitorAndClearsStore() {
+    let suite = "test.remove.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+
+    let dict: [String: Any] = ["identifier": "r1", "latitude": 1.0, "longitude": 2.0, "radius": 10.0]
+    mgr.addGeofence(from: dict)
+    mgr.removeGeofence(identifier: "r1")
+
+    XCTAssertEqual(mock.stopped.count, 1)
+    XCTAssertEqual(mock.stopped.first?.identifier, "r1")
+    XCTAssertEqual(store.loadGeofences().count, 0)
+    XCTAssertEqual(mgr.getGeofences().count, 0)
+  }
+
+  func testGetGeofences_returnsCoreFieldsAndExtras() {
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: nil)
+    let dict: [String: Any] = [
+      "identifier": "g1",
+      "latitude": 10.0,
+      "longitude": 20.0,
+      "radius": 30.0,
+      "extras": ["foo": "bar"]
+    ]
+    mgr.addGeofence(from: dict)
+    let list = mgr.getGeofences()
+    XCTAssertEqual(list.count, 1)
+    XCTAssertEqual(list[0]["identifier"] as? String, "g1")
+    XCTAssertEqual(list[0]["radius"] as? Double, 30.0)
+    XCTAssertEqual((list[0]["extras"] as? [String: Any])?["foo"] as? String, "bar")
+  }
+
+  func testHandleEnterExit_invokesOnGeofenceWithActionAndLocationProvider() {
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: nil)
+
+    var entered: [String: Any]?
+    var exited: [String: Any]?
+    mgr.onGeofence = { evt in
+      if (evt["action"] as? String) == "ENTER" { entered = evt }
+      if (evt["action"] as? String) == "EXIT" { exited = evt }
+    }
+    mgr.lastLocationProvider = { ["latitude": 99.0, "longitude": 88.0] }
+
+    let region = CLCircularRegion(
+      center: CLLocationCoordinate2D(latitude: 0, longitude: 0),
+      radius: 5,
+      identifier: "h1"
+    )
+    mgr.handleDidEnterRegion(region)
+    mgr.handleDidExitRegion(region)
+
+    XCTAssertEqual(entered?["identifier"] as? String, "h1")
+    XCTAssertEqual(entered?["action"] as? String, "ENTER")
+    XCTAssertEqual((entered?["location"] as? [String: Any])?["latitude"] as? Double, 99.0)
+
+    XCTAssertEqual(exited?["identifier"] as? String, "h1")
+    XCTAssertEqual(exited?["action"] as? String, "EXIT")
+    XCTAssertNotNil(exited?["location"])
+  }
+
+  func testLocationStore_generatesIdOnInsert_removesById() {
+    let suite = "test.storeloc.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+
+    store.insert(["latitude": 12.3, "longitude": 45.6, "timestamp": 123456.0])
+    let all = store.getAll()
+    XCTAssertEqual(all.count, 1)
+    let id = all[0]["id"] as? String
+    XCTAssertNotNil(id)
+    XCTAssertFalse(id!.isEmpty)
+
+    store.remove(byId: id)
+    XCTAssertEqual(store.getAll().count, 0)
+    XCTAssertEqual(store.count(), 0)
+  }
+
+  func testLocationStore_geofenceSaveLoadRoundtrip_clear() {
+    let suite = "test.storegeo.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+
+    let gfs: [[String: Any]] = [
+      [
+        "identifier": "rt1",
+        "latitude": 1.1,
+        "longitude": 2.2,
+        "radius": 50.5,
+        "notifyOnEntry": true,
+        "notifyOnExit": false,
+        "extras": ["key": "val"]
+      ]
+    ]
+    store.saveGeofences(gfs)
+    let loaded = store.loadGeofences()
+    XCTAssertEqual(loaded.count, 1)
+    XCTAssertEqual(loaded[0]["identifier"] as? String, "rt1")
+    XCTAssertEqual(loaded[0]["radius"] as? Double, 50.5)
+    XCTAssertEqual(loaded[0]["notifyOnEntry"] as? Bool, true)
+    XCTAssertEqual(loaded[0]["notifyOnExit"] as? Bool, false)
+    XCTAssertEqual((loaded[0]["extras"] as? [String: Any])?["key"] as? String, "val")
+
+    store.clearGeofences()
+    XCTAssertEqual(store.loadGeofences().count, 0)
+  }
+
+  func testScheduleManager_startWithConfigInterval_emitsStartedAndHeartbeat() {
+    let mgr = ScheduleManager()
+    var states: [String] = []
+    let exp = expectation(description: "heartbeat")
+    mgr.onSchedule = { payload in
+      if let s = payload["state"] as? String {
+        states.append(s)
+        if s == "heartbeat" { exp.fulfill() }
+      }
+    }
+
+    mgr.start(config: ["interval": 0.05])
+    XCTAssertEqual(states.first, "started")
+
+    wait(for: [exp], timeout: 1.0)
+    XCTAssertTrue(states.contains("heartbeat"))
+
+    mgr.stop()
+    // last may be heartbeat or stopped; just ensure no crash and stopped was sent at least once before
+  }
+
+  func testRestorePersistedGeofences_populatesFromStore_noSideEffectsOrCallbacks() {
+    let suite = "test.restore.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let gfs: [[String: Any]] = [[
+      "identifier": "rest1",
+      "latitude": 10.0,
+      "longitude": 20.0,
+      "radius": 30.0,
+      "notifyOnEntry": false,
+      "notifyOnExit": true,
+      "extras": ["x": 42]
+    ]]
+    store.saveGeofences(gfs)
+
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+    var changeCalled = false
+    mgr.onGeofencesChange = { _ in changeCalled = true }
+    // no onGeofence assignment needed; restore path does not emit it (see buildEvent)
+
+    XCTAssertEqual(mgr.getGeofences().count, 0)
+    mgr.restorePersistedGeofences()
+    let restored = mgr.getGeofences()
+    XCTAssertEqual(restored.count, 1)
+    XCTAssertEqual(restored[0]["identifier"] as? String, "rest1")
+    XCTAssertEqual(restored[0]["notifyOnEntry"] as? Bool, false)
+    XCTAssertEqual(restored[0]["notifyOnExit"] as? Bool, true)
+    XCTAssertEqual((restored[0]["extras"] as? [String: Any])?["x"] as? Int, 42)
+
+    // restore-only: no monitor calls, no callbacks (per "populates memory only"; "do not notify or start here")
+    XCTAssertEqual(mock.started.count, 0)
+    XCTAssertEqual(mock.stopped.count, 0)
+    XCTAssertFalse(changeCalled)
+    // Note: iOS provides public pure restorePersistedGeofences() (unlike Android startMonitoring entrypoint)
+  }
+
+  // Bulk operations tests
+  func testAddGeofences_bulk_populatesPersistsAndMonitorAndEvents() {
+    let suite = "test.bulkadd.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+
+    var changes: [[String: Any]] = []
+    mgr.onGeofencesChange = { p in
+      if let on = p["on"] as? [[String: Any]] { changes = on }
+    }
+
+    let gfs: [[String: Any]] = [
+      ["identifier": "b1", "latitude": 1.0, "longitude": 2.0, "radius": 10.0],
+      ["identifier": "b2", "latitude": 3.0, "longitude": 4.0, "radius": 20.0, "extras": ["k": "v"]]
+    ]
+    mgr.addGeofences(gfs)
+
+    XCTAssertEqual(mgr.getGeofences().count, 2)
+    XCTAssertEqual(store.loadGeofences().count, 2)
+    // monitor starts recorded (may be 0/2 depending on canMonitor in host; use public get for count)
+    XCTAssertEqual(changes.count, 2) // last change after second add
+    XCTAssertEqual(mgr.getGeofences()[1]["identifier"] as? String, "b2")
+    XCTAssertEqual((mgr.getGeofences()[1]["extras"] as? [String: Any])?["k"] as? String, "v")
+  }
+
+  func testRemoveGeofences_list_and_all_stopsMonitorsClearsStoreAndEvents() {
+    let suite = "test.bulkrem.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+
+    var changes: [[String: Any]] = []
+    mgr.onGeofencesChange = { p in
+      if let on = p["on"] as? [[String: Any]] { changes = on }
+    }
+
+    mgr.addGeofences([
+      ["identifier": "ra", "latitude": 10.0, "longitude": 20.0, "radius": 5.0],
+      ["identifier": "rb", "latitude": 30.0, "longitude": 40.0, "radius": 5.0]
+    ])
+    XCTAssertEqual(mgr.getGeofences().count, 2)
+
+    // remove list
+    mgr.removeGeofences(identifiers: ["ra"])
+    XCTAssertEqual(mgr.getGeofences().count, 1)
+    XCTAssertEqual(store.loadGeofences().count, 1)
+    XCTAssertEqual(mock.stopped.count, 1)
+    XCTAssertEqual(changes.count, 1) // onGeofencesChange fired with remaining
+
+    // remove all (nil)
+    mgr.removeGeofences(identifiers: nil)
+    XCTAssertEqual(mgr.getGeofences().count, 0)
+    XCTAssertEqual(store.loadGeofences().count, 0)
+    XCTAssertEqual(changes.count, 0)
+  }
+
+  // Bad inputs tests (graceful handling: no crash, no invalid persist/monitor)
+  func testAddGeofence_badDicts_gracefulNoPersistNoMonitor() {
+    let suite = "test.badadd.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+
+    // missing id, missing lat/lon/rad, wrong types, nulls via Any.
+    // (empty id string "" is accepted as valid degenerate identifier by seam; not treated as reject here)
+    let bads: [[String: Any]] = [
+      [:],
+      ["latitude": 1.0, "longitude": 2.0, "radius": 3.0], // no id
+      ["identifier": "bad1", "latitude": "notnum", "longitude": 2.0, "radius": 3.0],
+      ["identifier": "bad2", "latitude": 1.0], // missing lon/rad
+      ["identifier": "bad3", "latitude": nil, "longitude": 2.0, "radius": 3.0]
+    ]
+    for b in bads { mgr.addGeofence(from: b) }
+
+    XCTAssertEqual(mgr.getGeofences().count, 0)
+    XCTAssertEqual(store.loadGeofences().count, 0)
+    XCTAssertEqual(mock.started.count, 0)
+  }
+
+  func testRemoveGeofence_badIds_noCrashNoOp() {
+    let suite = "test.badrem.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mock = MockRegionMonitor()
+    let mgr = GeofenceManager(monitor: mock, store: store)
+
+    mgr.addGeofence(from: ["identifier": "good", "latitude": 1.0, "longitude": 2.0, "radius": 3.0])
+
+    // non-existing ids + remove-all via nil
+    mgr.removeGeofence(identifier: "nope")
+    XCTAssertEqual(mgr.getGeofences().count, 1)
+
+    // removeGeofences with bad list (includes nonexist)
+    mgr.removeGeofences(identifiers: ["nope2"])
+    XCTAssertEqual(mgr.getGeofences().count, 1)
+
+    // all via nil should work on existing
+    mgr.removeGeofences(identifiers: nil)
+    XCTAssertEqual(mgr.getGeofences().count, 0)
+  }
+
+  // Tests for SyncManager emissions (onSync callback paths for batch/immediate/background sync feature)
+  func testSyncManager_startStopAndSyncEmits_onSyncStates_forBatchAndImmediate() {
+    let suite = "test.sync.\(UUID().uuidString)"
+    let defaults = UserDefaults(suiteName: suite)!
+    let store = LocationStore(defaults: defaults)
+    let mgr = SyncManager(store: store)
+
+    var emitted: [[String: Any]] = []
+    mgr.onSync = { payload in
+      emitted.append(payload)
+    }
+
+    // disabled path (no url or disabled)
+    mgr.start(config: ["enabled": false])
+    XCTAssertEqual(emitted.last?["state"] as? String, "disabled")
+
+    // started path
+    mgr.start(config: ["enabled": true, "url": "https://example.com/api", "batch": true, "interval": 30])
+    XCTAssertEqual(emitted.last?["state"] as? String, "started")
+    XCTAssertEqual(emitted.last?["url"] as? String, "https://example.com/api")
+
+    // noop on syncNow (batch mode, empty store) - covers batch sync trigger path w/o http
+    mgr.syncNow()
+    XCTAssertEqual(emitted.last?["state"] as? String, "noop")
+    XCTAssertEqual(emitted.last?["count"] as? Int, 0)
+
+    // stop
+    mgr.stop()
+    XCTAssertEqual(emitted.last?["state"] as? String, "stopped")
+
+    // immediate (non-batch) mode also covers syncNow path (called from location updates when !batch)
+    mgr.start(config: ["enabled": true, "url": "https://ex.com", "batch": false])
+    XCTAssertEqual(emitted.last?["state"] as? String, "started")
+    mgr.syncNow() // triggers immediate path emission
+    XCTAssertEqual(emitted.last?["state"] as? String, "noop")
+
+    mgr.stop()
+    XCTAssertEqual(emitted.last?["state"] as? String, "stopped")
+
+    // ensure variety of states exercised
+    let states = emitted.compactMap { $0["state"] as? String }
+    XCTAssertTrue(states.contains("started"))
+    XCTAssertTrue(states.contains("stopped"))
+    XCTAssertTrue(states.contains("noop"))
+    XCTAssertTrue(states.contains("disabled"))
+  }
+
+  // Tests for MotionActivityProvider (seam tests for configure/start/stop + callbacks).
+  // Direct mocking of CMMotionActivityManager/CMPedometer internals is not injected (unlike Android fusedClient);
+  // use seam tests exercising public API + callbacks (consistent with other providers tested here).
+  // On macOS host, availability checks typically prevent actual updates firing (similar notes for geofence monitor);
+  // test focuses on call paths, wiring, no-crash, and config.
+  func testMotionActivityProvider_configureStartStopCallbacks_noCrash() {
+    let provider = MotionActivityProvider()
+
+    var activityUpdates: [[String: Any]] = []
+    var pedometerUpdates: [[String: Any]] = []
+    var errors: [String] = []
+
+    provider.onActivityUpdate = { activityUpdates.append($0) }
+    provider.onPedometerUpdate = { pedometerUpdates.append($0) }
+    provider.onError = { _, msg in errors.append(msg) }
+
+    provider.configure(enableActivity: true, enablePedometer: true)
+    provider.start()
+    provider.stop()
+
+    // Seams: callbacks assigned, configure/start/stop called without throwing.
+    XCTAssertNotNil(provider.onActivityUpdate)
+    XCTAssertNotNil(provider.onPedometerUpdate)
+    XCTAssertNotNil(provider.onError)
+  }
+
+  func testMotionActivityProvider_configureDisableSkips() {
+    let provider = MotionActivityProvider()
+    var called = false
+    provider.onActivityUpdate = { _ in called = true }
+    provider.configure(enableActivity: false, enablePedometer: false)
+    provider.start()
+    provider.stop()
+    XCTAssertFalse(called)
+  }
+
+  // Expanded seam tests per task: more coverage of configure variants, callback capture, direct entrypoints.
+  func testMotionActivityProvider_configureActivityOnly_usesDirectEntrypoint_capturesCallbacks() {
+    let provider = MotionActivityProvider()
+    var activity: [String: Any]?
+    var pedo: [String: Any]?
+    provider.onActivityUpdate = { activity = $0 }
+    provider.onPedometerUpdate = { pedo = $0 }
+    provider.onError = { _, _ in }
+
+    // direct entrypoint call
+    provider.configure(enableActivity: true, enablePedometer: false)
+    provider.start()
+    provider.stop()
+
+    // callback capture seams wired
+    XCTAssertNotNil(provider.onActivityUpdate)
+    XCTAssertNotNil(provider.onPedometerUpdate)
+    // no actual fire expected on test host but wiring verified
+  }
+
+  func testMotionActivityProvider_configurePedometerOnly_andErrorCallback() {
+    let provider = MotionActivityProvider()
+    var pedometerUpdates: [[String: Any]] = []
+    var errors: [String] = []
+    provider.onPedometerUpdate = { pedometerUpdates.append($0) }
+    provider.onError = { code, msg in errors.append("\(code):\(msg)") }
+
+    provider.configure(enableActivity: false, enablePedometer: true)
+    provider.start()
+    provider.stop()
+
+    XCTAssertNotNil(provider.onPedometerUpdate)
+    XCTAssertNotNil(provider.onError)
+  }
+
+  func testMotionActivityProvider_multipleStartStop_noCrash_direct() {
+    let provider = MotionActivityProvider()
+    var updates: [[String: Any]] = []
+    provider.onActivityUpdate = { updates.append($0) }
+    provider.configure(enableActivity: true, enablePedometer: true)
+    provider.start()
+    provider.stop()
+    provider.start()
+    provider.stop()
+    // callback capture pattern (assign before start)
+    XCTAssertNotNil(provider.onActivityUpdate)
+  }
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "therms-device-tracker",
+  "version": "1.0.0-rc.1",
+  "description": "THERMS software expo app device physical activity and geo location tracking",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build",
+    "ios",
+    "android/src/main",
+    "android/build.gradle",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "README.md",
+    "CHANGELOG.md",
+    "ARCHITECTURE.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node internal/module_scripts/build.js",
+    "build:expo": "npm run build",
+    "clean": "node internal/module_scripts/clean.js",
+    "lint": "eslint src/",
+    "test": "node internal/module_scripts/test.js",
+    "prepare": "node internal/module_scripts/prepare.js",
+    "open:ios": "node internal/module_scripts/open-ios.js",
+    "open:android": "node internal/module_scripts/open-android.js",
+    "test:native:ios": "echo 'Native iOS provider tests: (1) npm run build (2) (cd example && npx expo prebuild) (3) npm run open:ios (4) include ios/ThermsGeofenceTests.swift in XCTest target if needed (5) Cmd+U'",
+    "test:native:android": "echo 'Native Android provider tests: (1) npm run build (2) (cd example && npx expo prebuild) (3) cd example/android && ./gradlew test  (GeofenceTest.kt + seams)'"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "background-geolocation",
+    "geolocation",
+    "location-tracking",
+    "activity-recognition",
+    "motion-detection",
+    "therms-device-tracker",
+    "ThermsDeviceTracker"
+  ],
+  "repository": "https://www.therms.io",
+  "bugs": {
+    "url": "https://www.therms.io/issues"
+  },
+  "author": "Cory Robinson <cory@therms.io>",
+  "license": "MIT",
+  "homepage": "https://www.therms.io#readme",
+  "expo": {
+    "plugins": [
+      "./app.plugin.js"
+    ]
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@types/jest": "^29.2.1",
+    "@types/react": "~19.1.1",
+    "babel-preset-expo": "~56.0.8",
+    "eslint": "~9.39.4",
+    "eslint-config-universe": "^15.0.3",
+    "expo": "^56.0.11",
+    "jest": "^29.7.0",
+    "jest-expo": "~56.0.5",
+    "prettier": "^3.0.0",
+    "react-native": "0.82.1",
+    "typescript": "^5.9.2"
+  },
+  "jest": {
+    "preset": "jest-expo",
+    "roots": [
+      "<rootDir>/src",
+      "<rootDir>/tests"
+    ],
+    "moduleNameMapper": {
+      "^therms-device-tracker$": "<rootDir>/src"
+    }
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "codegenConfig": {
+    "name": "ThermsDeviceTracker",
+    "type": "modules",
+    "jsSrcsDir": "./src/specs",
+    "android": {
+      "javaPackageName": "expo.modules.thermsdevicetracker"
+    },
+    "ios": {
+      "swiftModuleName": "ThermsDeviceTracker"
+    }
+  }
+}