@apex-inc/capacitor-plugin 0.1.0

package/ios/Tests/ApexCapacitorPluginTests/AdvertisingIdProviderTests.swift

@@ -0,0 +1,74 @@
+//
+//  AdvertisingIdProviderTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class AdvertisingIdProviderTests: XCTestCase {
+
+    private func makeProvider(
+        attStatus: AttStatus,
+        idfa: String?,
+        idfv: String?
+    ) -> AdvertisingIdProvider {
+        let tracker = FakeAttTracker(nextStatus: attStatus)
+        let attManager = AttManager(tracker: tracker)
+        return AdvertisingIdProvider(
+            attManager: attManager,
+            idfaProvider: { idfa },
+            idfvProvider: { idfv }
+        )
+    }
+
+    func testReturnsIdfaWhenAuthorizedAndNotZero() {
+        let provider = makeProvider(
+            attStatus: .authorized,
+            idfa: "12345678-1234-4567-8901-123456789012",
+            idfv: "vendor-id-unused"
+        )
+        let result = provider.current()
+        XCTAssertEqual(result.id, "12345678-1234-4567-8901-123456789012")
+        XCTAssertNil(result.fallback)
+    }
+
+    func testFallsBackToIdfvWhenDenied() {
+        let provider = makeProvider(
+            attStatus: .denied,
+            idfa: "should-not-be-used",
+            idfv: "vendor-abc-def"
+        )
+        let result = provider.current()
+        XCTAssertEqual(result.id, "vendor-abc-def")
+        XCTAssertEqual(result.fallback, "idfv")
+    }
+
+    func testFallsBackToIdfvWhenIdfaIsZero() {
+        let provider = makeProvider(
+            attStatus: .authorized,
+            idfa: "00000000-0000-0000-0000-000000000000",
+            idfv: "vendor-xyz"
+        )
+        let result = provider.current()
+        XCTAssertEqual(result.id, "vendor-xyz")
+        XCTAssertEqual(result.fallback, "idfv")
+    }
+
+    func testFallsBackToIdfvWhenNotDetermined() {
+        let provider = makeProvider(
+            attStatus: .notDetermined,
+            idfa: "12345678-1234-4567-8901-123456789012",
+            idfv: "vendor-not-yet"
+        )
+        let result = provider.current()
+        XCTAssertEqual(result.id, "vendor-not-yet")
+        XCTAssertEqual(result.fallback, "idfv")
+    }
+
+    func testReturnsNilWhenBothUnavailable() {
+        let provider = makeProvider(attStatus: .denied, idfa: nil, idfv: nil)
+        let result = provider.current()
+        XCTAssertNil(result.id)
+        XCTAssertNil(result.fallback)
+    }
+}

package/ios/Tests/ApexCapacitorPluginTests/AttManagerTests.swift

@@ -0,0 +1,82 @@
+//
+//  AttManagerTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class FakeAttTracker: AttTrackerProtocol {
+    var nextStatus: AttStatus
+    var requestedCount = 0
+
+    init(nextStatus: AttStatus) {
+        self.nextStatus = nextStatus
+    }
+
+    func currentStatus() -> AttStatus {
+        return nextStatus
+    }
+
+    func requestAuthorization(completion: @escaping (UInt) -> Void) {
+        requestedCount += 1
+        let raw: UInt = {
+            switch nextStatus {
+            case .notDetermined: return 0
+            case .restricted: return 1
+            case .denied: return 2
+            case .authorized: return 3
+            }
+        }()
+        completion(raw)
+    }
+}
+
+final class AttManagerTests: XCTestCase {
+
+    func testMapsAllAuthorizationStatuses() {
+        XCTAssertEqual(AttStatus.from(authorizationRawValue: 0), .notDetermined)
+        XCTAssertEqual(AttStatus.from(authorizationRawValue: 1), .restricted)
+        XCTAssertEqual(AttStatus.from(authorizationRawValue: 2), .denied)
+        XCTAssertEqual(AttStatus.from(authorizationRawValue: 3), .authorized)
+    }
+
+    func testMapsUnknownStatusToNotDetermined() {
+        XCTAssertEqual(AttStatus.from(authorizationRawValue: 99), .notDetermined)
+    }
+
+    func testCurrentStatusReturnsTrackerValue() {
+        let tracker = FakeAttTracker(nextStatus: .denied)
+        let manager = AttManager(tracker: tracker)
+        XCTAssertEqual(manager.currentStatus(), .denied)
+    }
+
+    func testRequestReturnsAuthorized() {
+        let tracker = FakeAttTracker(nextStatus: .authorized)
+        let manager = AttManager(tracker: tracker)
+        let expectation = XCTestExpectation(description: "request completes")
+        manager.request { status in
+            XCTAssertEqual(status, .authorized)
+            expectation.fulfill()
+        }
+        wait(for: [expectation], timeout: 0.5)
+        XCTAssertEqual(tracker.requestedCount, 1)
+    }
+
+    func testRequestReturnsDenied() {
+        let tracker = FakeAttTracker(nextStatus: .denied)
+        let manager = AttManager(tracker: tracker)
+        let expectation = XCTestExpectation(description: "request completes")
+        manager.request { status in
+            XCTAssertEqual(status, .denied)
+            expectation.fulfill()
+        }
+        wait(for: [expectation], timeout: 0.5)
+    }
+
+    func testAttStatusRawValueStrings() {
+        XCTAssertEqual(AttStatus.authorized.rawValue, "authorized")
+        XCTAssertEqual(AttStatus.denied.rawValue, "denied")
+        XCTAssertEqual(AttStatus.restricted.rawValue, "restricted")
+        XCTAssertEqual(AttStatus.notDetermined.rawValue, "not-determined")
+    }
+}

package/ios/Tests/ApexCapacitorPluginTests/DeepLinkManagerTests.swift

@@ -0,0 +1,69 @@
+//
+//  DeepLinkManagerTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class DeepLinkManagerTests: XCTestCase {
+
+    func testConsumeInitialUrlReturnsNilWhenNotSet() {
+        let manager = DeepLinkManager()
+        XCTAssertNil(manager.consumeInitialUrl())
+    }
+
+    func testConsumeInitialUrlReturnsStoredUrl() {
+        let manager = DeepLinkManager()
+        let url = URL(string: "https://links.apex.inc/abc123")!
+        manager.setInitialUrl(url)
+        XCTAssertEqual(manager.consumeInitialUrl(), url)
+    }
+
+    func testConsumeInitialUrlIsOneShot() {
+        let manager = DeepLinkManager()
+        manager.setInitialUrl(URL(string: "apexapp://home")!)
+        _ = manager.consumeInitialUrl()
+        XCTAssertNil(manager.consumeInitialUrl())
+    }
+
+    func testSetInitialUrlDoesNotOverwriteExisting() {
+        let manager = DeepLinkManager()
+        manager.setInitialUrl(URL(string: "apexapp://first")!)
+        manager.setInitialUrl(URL(string: "apexapp://second")!)
+        XCTAssertEqual(manager.consumeInitialUrl()?.absoluteString, "apexapp://first")
+    }
+
+    func testWarmLinkDispatchesToHandler() {
+        var received: URL?
+        let manager = DeepLinkManager()
+        manager.setWarmLinkHandler { url in
+            received = url
+        }
+        let url = URL(string: "https://links.apex.inc/xyz")!
+        manager.deliverWarmLink(url)
+        XCTAssertEqual(received, url)
+    }
+
+    func testWarmLinkReplacesHandler() {
+        var first = 0
+        var second = 0
+        let manager = DeepLinkManager()
+        manager.setWarmLinkHandler { _ in first += 1 }
+        manager.setWarmLinkHandler { _ in second += 1 }
+        manager.deliverWarmLink(URL(string: "apexapp://home")!)
+        XCTAssertEqual(first, 0)
+        XCTAssertEqual(second, 1)
+    }
+
+    func testIsValidDeepLinkAcceptsHttps() {
+        XCTAssertTrue(DeepLinkManager.isValidDeepLink(URL(string: "https://links.apex.inc/abc")!))
+    }
+
+    func testIsValidDeepLinkAcceptsCustomScheme() {
+        XCTAssertTrue(DeepLinkManager.isValidDeepLink(URL(string: "apexapp://home")!))
+    }
+
+    func testIsValidDeepLinkRejectsFileUrl() {
+        XCTAssertFalse(DeepLinkManager.isValidDeepLink(URL(string: "file:///tmp/test")!))
+    }
+}

package/ios/Tests/ApexCapacitorPluginTests/DeviceInfoTests.swift

@@ -0,0 +1,52 @@
+//
+//  DeviceInfoTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class DeviceInfoTests: XCTestCase {
+
+    func testCollectReportsPlatformIos() {
+        let info = DeviceInfo()
+        let meta = info.collect()
+        XCTAssertEqual(meta.platform, "ios")
+    }
+
+    func testCollectUsesInjectedTimezoneAndLocale() {
+        let info = DeviceInfo(
+            bundle: .main,
+            tzProvider: { "America/New_York" },
+            localeProvider: { "en-US" },
+            modelProvider: { "iPhone15,2" },
+            osVersionProvider: { "17.4" }
+        )
+        let meta = info.collect()
+        XCTAssertEqual(meta.timezone, "America/New_York")
+        XCTAssertEqual(meta.locale, "en-US")
+        XCTAssertEqual(meta.model, "iPhone15,2")
+        XCTAssertEqual(meta.osVersion, "17.4")
+    }
+
+    func testDeviceMetadataEquatable() {
+        let a = DeviceMetadata(
+            platform: "ios",
+            osVersion: "17.4",
+            model: "iPhone15,2",
+            appVersion: "1.0.0",
+            bundleId: "com.example.app",
+            timezone: "UTC",
+            locale: "en-US"
+        )
+        let b = DeviceMetadata(
+            platform: "ios",
+            osVersion: "17.4",
+            model: "iPhone15,2",
+            appVersion: "1.0.0",
+            bundleId: "com.example.app",
+            timezone: "UTC",
+            locale: "en-US"
+        )
+        XCTAssertEqual(a, b)
+    }
+}

package/ios/Tests/ApexCapacitorPluginTests/OfflineQueueTests.swift

@@ -0,0 +1,134 @@
+//
+//  OfflineQueueTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class OfflineQueueTests: XCTestCase {
+
+    private func makeQueue(maxSize: Int = 100) -> (NativeOfflineQueue, URL) {
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("apex-queue-tests")
+            .appendingPathComponent(UUID().uuidString)
+        try? FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let fileURL = tempDir.appendingPathComponent("events.json")
+        let queue = NativeOfflineQueue(fileURL: fileURL, maxSize: maxSize)
+        return (queue, fileURL)
+    }
+
+    private func makeEvent(id: String, type: String = "app_open") -> NativeQueuedEvent {
+        return NativeQueuedEvent(
+            id: id,
+            payload: ["type": AnyCodable(type)],
+            attempts: 0,
+            enqueuedAt: Date()
+        )
+    }
+
+    override func tearDownWithError() throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent("apex-queue-tests")
+        try? FileManager.default.removeItem(at: root)
+    }
+
+    func testEnqueueAndSize() throws {
+        let (queue, _) = makeQueue()
+        try queue.enqueue(makeEvent(id: "1"))
+        XCTAssertEqual(try queue.size(), 1)
+
+        try queue.enqueue(makeEvent(id: "2"))
+        XCTAssertEqual(try queue.size(), 2)
+    }
+
+    func testPeekReturnsInOrder() throws {
+        let (queue, _) = makeQueue()
+        try queue.enqueue(makeEvent(id: "a"))
+        try queue.enqueue(makeEvent(id: "b"))
+        try queue.enqueue(makeEvent(id: "c"))
+
+        let peeked = try queue.peek(batchSize: 10)
+        XCTAssertEqual(peeked.map { $0.id }, ["a", "b", "c"])
+    }
+
+    func testMarkSentRemovesById() throws {
+        let (queue, _) = makeQueue()
+        try queue.enqueue(makeEvent(id: "a"))
+        try queue.enqueue(makeEvent(id: "b"))
+        try queue.enqueue(makeEvent(id: "c"))
+
+        try queue.markSent(ids: ["b"])
+        let remaining = try queue.peek(batchSize: 10)
+        XCTAssertEqual(remaining.map { $0.id }, ["a", "c"])
+    }
+
+    func testMarkFailedIncrementsAttempts() throws {
+        let (queue, _) = makeQueue()
+        try queue.enqueue(makeEvent(id: "a"))
+        try queue.enqueue(makeEvent(id: "b"))
+
+        try queue.markFailed(ids: ["a"])
+        let peeked = try queue.peek(batchSize: 10)
+        let a = peeked.first { $0.id == "a" }!
+        let b = peeked.first { $0.id == "b" }!
+        XCTAssertEqual(a.attempts, 1)
+        XCTAssertEqual(b.attempts, 0)
+    }
+
+    func testMaxSizeEvictsOldest() throws {
+        let (queue, _) = makeQueue(maxSize: 3)
+        for id in ["a", "b", "c", "d", "e"] {
+            try queue.enqueue(makeEvent(id: id))
+        }
+        let peeked = try queue.peek(batchSize: 10)
+        XCTAssertEqual(peeked.map { $0.id }, ["c", "d", "e"])
+    }
+
+    func testOldestEventAtNilWhenEmpty() throws {
+        let (queue, _) = makeQueue()
+        XCTAssertNil(try queue.oldestEventAt())
+    }
+
+    func testOldestEventAtReturnsFirstEnqueued() throws {
+        let (queue, _) = makeQueue()
+        let event = makeEvent(id: "a")
+        try queue.enqueue(event)
+        let oldest = try queue.oldestEventAt()
+        XCTAssertNotNil(oldest)
+        XCTAssertEqual(oldest!.timeIntervalSince1970,
+                       event.enqueuedAt.timeIntervalSince1970,
+                       accuracy: 1.0)
+    }
+
+    func testClearEmpties() throws {
+        let (queue, _) = makeQueue()
+        try queue.enqueue(makeEvent(id: "a"))
+        try queue.enqueue(makeEvent(id: "b"))
+        XCTAssertEqual(try queue.size(), 2)
+        try queue.clear()
+        XCTAssertEqual(try queue.size(), 0)
+    }
+
+    func testPersistsAcrossReopens() throws {
+        let (queue1, fileURL) = makeQueue()
+        try queue1.enqueue(makeEvent(id: "a"))
+        try queue1.enqueue(makeEvent(id: "b"))
+        XCTAssertEqual(try queue1.size(), 2)
+
+        // Reopen the same file with a fresh queue instance.
+        let queue2 = NativeOfflineQueue(fileURL: fileURL)
+        XCTAssertEqual(try queue2.size(), 2)
+        let peeked = try queue2.peek(batchSize: 10)
+        XCTAssertEqual(peeked.map { $0.id }, ["a", "b"])
+    }
+
+    func testEnqueueWithEmptyIdThrows() {
+        let (queue, _) = makeQueue()
+        let event = NativeQueuedEvent(
+            id: "",
+            payload: [:],
+            attempts: 0,
+            enqueuedAt: Date()
+        )
+        XCTAssertThrowsError(try queue.enqueue(event))
+    }
+}

package/ios/Tests/ApexCapacitorPluginTests/SessionManagerTests.swift

@@ -0,0 +1,98 @@
+//
+//  SessionManagerTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class SessionManagerTests: XCTestCase {
+
+    func testEmitsSessionStartOnFirstActivity() {
+        var starts: [String] = []
+        let manager = NativeSessionManager(
+            timeoutMinutes: 30,
+            onStart: { snapshot in starts.append(snapshot.sessionId) }
+        )
+        _ = manager.recordActivity()
+        XCTAssertEqual(starts.count, 1)
+    }
+
+    func testDoesNotEmitOnSubsequentActivity() {
+        var starts = 0
+        let manager = NativeSessionManager(
+            timeoutMinutes: 30,
+            onStart: { _ in starts += 1 }
+        )
+        _ = manager.recordActivity()
+        _ = manager.recordActivity()
+        _ = manager.recordActivity()
+        XCTAssertEqual(starts, 1)
+    }
+
+    func testPreservesSessionId() {
+        let manager = NativeSessionManager(timeoutMinutes: 30)
+        let s1 = manager.recordActivity()
+        let s2 = manager.recordActivity()
+        XCTAssertEqual(s1.sessionId, s2.sessionId)
+    }
+
+    func testIncrementsEventCount() {
+        let manager = NativeSessionManager(timeoutMinutes: 30)
+        _ = manager.recordActivity()
+        _ = manager.recordActivity()
+        _ = manager.recordActivity()
+        XCTAssertEqual(manager.getCurrent()?.eventCount, 3)
+    }
+
+    func testEndSessionClearsCurrent() {
+        let manager = NativeSessionManager(timeoutMinutes: 30)
+        _ = manager.recordActivity()
+        XCTAssertNotNil(manager.getCurrent())
+        manager.endSession()
+        XCTAssertNil(manager.getCurrent())
+    }
+
+    func testEndSessionComputesDuration() {
+        var ended: NativeSessionSnapshot?
+        var mockClock: Date = Date()
+        let manager = NativeSessionManager(
+            timeoutMinutes: 30,
+            clock: { mockClock },
+            onEnd: { snapshot in ended = snapshot }
+        )
+        _ = manager.recordActivity()
+        mockClock = mockClock.addingTimeInterval(15 * 60)
+        manager.endSession()
+
+        XCTAssertNotNil(ended)
+        XCTAssertEqual(ended?.durationSeconds, 15 * 60)
+    }
+
+    func testForceStartEndsPrevious() {
+        var startIds: [String] = []
+        var endIds: [String] = []
+        let manager = NativeSessionManager(
+            timeoutMinutes: 30,
+            onStart: { s in startIds.append(s.sessionId) },
+            onEnd: { s in endIds.append(s.sessionId) }
+        )
+
+        _ = manager.recordActivity()
+        let firstId = startIds.first!
+        _ = manager.forceStart()
+
+        XCTAssertEqual(endIds, [firstId])
+        XCTAssertEqual(startIds.count, 2)
+        XCTAssertNotEqual(startIds[0], startIds[1])
+    }
+
+    func testEndSessionNoOpWhenIdle() {
+        var endCount = 0
+        let manager = NativeSessionManager(
+            timeoutMinutes: 30,
+            onEnd: { _ in endCount += 1 }
+        )
+        manager.endSession()
+        XCTAssertEqual(endCount, 0)
+    }
+}

package/ios/Tests/ApexCapacitorPluginTests/SkanManagerTests.swift

@@ -0,0 +1,91 @@
+//
+//  SkanManagerTests.swift
+//
+
+import XCTest
+@testable import ApexCapacitorPlugin
+
+final class RecordingSkanUpdater: SkanUpdaterProtocol {
+    struct Call: Equatable {
+        let fineValue: Int
+        let coarseValue: SkanCoarseValue?
+    }
+    var calls: [Call] = []
+    var nextError: Error?
+
+    func updateConversionValue(
+        fineValue: Int,
+        coarseValue: SkanCoarseValue?,
+        completion: @escaping (Error?) -> Void
+    ) {
+        calls.append(Call(fineValue: fineValue, coarseValue: coarseValue))
+        completion(nextError)
+    }
+}
+
+final class SkanManagerTests: XCTestCase {
+    func testValidateAcceptsZeroToSixtyThree() throws {
+        XCTAssertNoThrow(try SkanManager.validateFineValue(0))
+        XCTAssertNoThrow(try SkanManager.validateFineValue(1))
+        XCTAssertNoThrow(try SkanManager.validateFineValue(32))
+        XCTAssertNoThrow(try SkanManager.validateFineValue(63))
+    }
+
+    func testValidateRejectsOutOfRange() {
+        XCTAssertThrowsError(try SkanManager.validateFineValue(-1))
+        XCTAssertThrowsError(try SkanManager.validateFineValue(64))
+        XCTAssertThrowsError(try SkanManager.validateFineValue(100))
+    }
+
+    func testUpdatePassesFineValueThrough() {
+        let updater = RecordingSkanUpdater()
+        let manager = SkanManager(updater: updater)
+
+        let exp = expectation(description: "update completes")
+        manager.update(fineValue: 42, coarseValue: nil) { error in
+            XCTAssertNil(error)
+            exp.fulfill()
+        }
+        wait(for: [exp], timeout: 0.5)
+
+        XCTAssertEqual(updater.calls.count, 1)
+        XCTAssertEqual(updater.calls[0].fineValue, 42)
+        XCTAssertNil(updater.calls[0].coarseValue)
+    }
+
+    func testUpdateSupportsCoarseValue() {
+        let updater = RecordingSkanUpdater()
+        let manager = SkanManager(updater: updater)
+
+        let exp = expectation(description: "update completes")
+        manager.update(fineValue: 10, coarseValue: .medium) { _ in exp.fulfill() }
+        wait(for: [exp], timeout: 0.5)
+
+        XCTAssertEqual(updater.calls[0].coarseValue, .medium)
+    }
+
+    func testUpdateRejectsOutOfRangeFineValue() {
+        let updater = RecordingSkanUpdater()
+        let manager = SkanManager(updater: updater)
+
+        let exp = expectation(description: "update rejected")
+        manager.update(fineValue: 200) { error in
+            XCTAssertNotNil(error)
+            if let skanError = error as? SkanError {
+                XCTAssertEqual(skanError, .fineValueOutOfRange(200))
+            } else {
+                XCTFail("Expected SkanError")
+            }
+            exp.fulfill()
+        }
+        wait(for: [exp], timeout: 0.5)
+
+        XCTAssertTrue(updater.calls.isEmpty, "Updater should not be called when validation fails")
+    }
+
+    func testCoarseValueRawStrings() {
+        XCTAssertEqual(SkanCoarseValue.low.rawValue, "low")
+        XCTAssertEqual(SkanCoarseValue.medium.rawValue, "medium")
+        XCTAssertEqual(SkanCoarseValue.high.rawValue, "high")
+    }
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@apex-inc/capacitor-plugin",
+  "version": "0.1.0",
+  "description": "Apex Capacitor plugin — iOS/Android attribution, events, deep linking, SKAN, and offline-tolerant tracking for Capacitor apps.",
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources/",
+    "ios/Tests/",
+    "Package.swift",
+    "ApexCapacitorPlugin.podspec"
+  ],
+  "author": "Apex Inc.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apex-incorporated/capacitor-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/apex-incorporated/capacitor-plugin/issues"
+  },
+  "homepage": "https://apex.inc/products/mobile-measurement",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "ios",
+    "android",
+    "apex",
+    "attribution",
+    "analytics",
+    "mmp",
+    "mobile-measurement",
+    "skadnetwork",
+    "deep-linking"
+  ],
+  "scripts": {
+    "verify": "npm run verify:typecheck && npm run test && npm run build",
+    "verify:typecheck": "tsc --noEmit",
+    "build": "npm run clean && tsc && tsc -p tsconfig.esm.json",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@capacitor/core": "^7.0.0",
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^3.2.0",
+    "fake-indexeddb": "^6.0.0",
+    "rimraf": "^6.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=6.0.0"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}