@kafitra/react-native-live-tracking 0.1.0

package/ios/TrackingNotificationManager.swift

@@ -0,0 +1,187 @@
+import Foundation
+import UserNotifications
+
+/**
+ * Manages persistent local notifications for iOS live tracking.
+ *
+ * iOS does not have a "foreground service" concept like Android. Instead,
+ * this manager posts a local notification when tracking starts and removes it
+ * when tracking stops. If the user dismisses the notification, it is re-posted
+ * to maintain visibility (similar to Android's foreground service notification).
+ *
+ * Requirements:
+ * - Show persistent notification while tracking is active
+ * - Re-post notification if dismissed by user
+ * - Remove notification when tracking stops
+ * - Gracefully degrade if notification permission is denied
+ */
+@objc
+class TrackingNotificationManager: NSObject, UNUserNotificationCenterDelegate {
+
+    // MARK: - Constants
+
+    private static let notificationIdentifier = "com.livetracking.persistent"
+    private static let categoryIdentifier = "LIVE_TRACKING_CATEGORY"
+    private static let recheckInterval: TimeInterval = 5.0
+
+    // MARK: - Properties
+
+    private var title: String = "Live Tracking"
+    private var body: String = "Tracking your location"
+    private var isTrackingActive: Bool = false
+    private var recheckTimer: Timer?
+    private var hasNotificationPermission: Bool = false
+
+    // MARK: - Singleton
+
+    @objc static let shared = TrackingNotificationManager()
+
+    private override init() {
+        super.init()
+        setupNotificationCategory()
+    }
+
+    // MARK: - Configuration
+
+    /**
+     * Configure the notification title and body text.
+     *
+     * - Parameter title: The notification title
+     * - Parameter body: The notification body text
+     */
+    @objc
+    func configure(title: String, body: String) {
+        self.title = title
+        self.body = body
+    }
+
+    // MARK: - Public Methods
+
+    /**
+     * Show the persistent tracking notification.
+     * Requests notification permission if not already granted.
+     * Starts a re-check timer to re-post if the user dismisses it.
+     */
+    @objc
+    func showTrackingNotification() {
+        isTrackingActive = true
+
+        let center = UNUserNotificationCenter.current()
+        center.delegate = self
+
+        center.requestAuthorization(options: [.alert, .sound]) { [weak self] granted, _ in
+            guard let self = self else { return }
+            self.hasNotificationPermission = granted
+            if granted {
+                DispatchQueue.main.async {
+                    self.postNotification()
+                    self.startRecheckTimer()
+                }
+            }
+        }
+    }
+
+    /**
+     * Remove the tracking notification and stop the re-check timer.
+     */
+    @objc
+    func removeTrackingNotification() {
+        isTrackingActive = false
+        stopRecheckTimer()
+
+        let center = UNUserNotificationCenter.current()
+        center.removeDeliveredNotifications(withIdentifiers: [TrackingNotificationManager.notificationIdentifier])
+        center.removePendingNotificationRequests(withIdentifiers: [TrackingNotificationManager.notificationIdentifier])
+    }
+
+    // MARK: - UNUserNotificationCenterDelegate
+
+    /**
+     * Handle notification presentation while app is in foreground.
+     * Show the notification banner even when app is active.
+     */
+    func userNotificationCenter(
+        _ center: UNUserNotificationCenter,
+        willPresent notification: UNNotification,
+        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+    ) {
+        if notification.request.identifier == TrackingNotificationManager.notificationIdentifier {
+            completionHandler([.banner])
+        } else {
+            completionHandler([.banner, .sound])
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private func setupNotificationCategory() {
+        let category = UNNotificationCategory(
+            identifier: TrackingNotificationManager.categoryIdentifier,
+            actions: [],
+            intentIdentifiers: [],
+            options: []
+        )
+        UNUserNotificationCenter.current().setNotificationCategories([category])
+    }
+
+    private func postNotification() {
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.body = body
+        content.categoryIdentifier = TrackingNotificationManager.categoryIdentifier
+        // No sound for persistent notification to avoid annoyance
+        content.sound = nil
+
+        let request = UNNotificationRequest(
+            identifier: TrackingNotificationManager.notificationIdentifier,
+            content: content,
+            trigger: nil // Deliver immediately
+        )
+
+        UNUserNotificationCenter.current().add(request) { error in
+            if let error = error {
+                print("[TrackingNotificationManager] Failed to post notification: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    /**
+     * Start a timer that periodically checks if the notification is still delivered.
+     * If not (user dismissed it), re-post it while tracking is active.
+     */
+    private func startRecheckTimer() {
+        stopRecheckTimer()
+        recheckTimer = Timer.scheduledTimer(
+            withTimeInterval: TrackingNotificationManager.recheckInterval,
+            repeats: true
+        ) { [weak self] _ in
+            self?.recheckNotification()
+        }
+    }
+
+    private func stopRecheckTimer() {
+        recheckTimer?.invalidate()
+        recheckTimer = nil
+    }
+
+    private func recheckNotification() {
+        guard isTrackingActive, hasNotificationPermission else {
+            stopRecheckTimer()
+            return
+        }
+
+        UNUserNotificationCenter.current().getDeliveredNotifications { [weak self] notifications in
+            guard let self = self, self.isTrackingActive else { return }
+
+            let hasTrackingNotification = notifications.contains {
+                $0.request.identifier == TrackingNotificationManager.notificationIdentifier
+            }
+
+            if !hasTrackingNotification {
+                DispatchQueue.main.async {
+                    self.postNotification()
+                }
+            }
+        }
+    }
+}

package/lib/commonjs/EventEmitter.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onError = onError;
+exports.onLocationUpdate = onLocationUpdate;
+exports.removeAllListeners = removeAllListeners;
+var _reactNative = require("react-native");
+/**
+ * Event listener system for react-native-live-tracking.
+ *
+ * Wraps NativeEventEmitter to provide typed event subscriptions
+ * for location updates and tracking errors.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Directly use the global device event emitter.
+ *
+ * NativeEventEmitter's constructor accesses Platform.OS, which requires the
+ * PlatformConstants native module. In a broken or partially-initialised binary
+ * that module can be missing and crash the app before we can even report that
+ * LiveTracking is unavailable. DeviceEventEmitter avoids that dependency
+ * entirely while still delivering native events emitted by the LiveTracking
+ * RCTEventEmitter.
+ */
+
+/**
+ * Register a callback for location updates.
+ *
+ * The callback is invoked each time a valid location update is emitted
+ * from the native layer after passing the Distance/Time Matrix filter.
+ *
+ * @param callback - Function called with LocationData on each update
+ * @returns Subscription with `remove()` method to unsubscribe
+ *
+ * @example
+ * ```ts
+ * const subscription = onLocationUpdate((location) => {
+ *   console.log(location.latitude, location.longitude);
+ * });
+ * // Later: unsubscribe
+ * subscription.remove();
+ * ```
+ */
+function onLocationUpdate(callback) {
+  const nativeSubscription = _reactNative.DeviceEventEmitter.addListener('onLocationUpdate', event => {
+    const location = {
+      latitude: event.latitude,
+      longitude: event.longitude,
+      timestamp: event.timestamp,
+      accuracy: event.accuracy,
+      speed: event.speed ?? null,
+      altitude: event.altitude ?? null,
+      bearing: event.bearing ?? null
+    };
+    callback(location);
+  });
+  return {
+    remove: () => {
+      nativeSubscription.remove();
+    }
+  };
+}
+
+/**
+ * Register a callback for tracking errors.
+ *
+ * The callback is invoked when an error occurs during tracking
+ * (e.g., permission denied, GPS disabled, Firebase write failure).
+ *
+ * @param callback - Function called with TrackingError on each error event
+ * @returns Subscription with `remove()` method to unsubscribe
+ *
+ * @example
+ * ```ts
+ * const subscription = onError((error) => {
+ *   console.error(`[${error.code}] ${error.message}`);
+ * });
+ * // Later: unsubscribe
+ * subscription.remove();
+ * ```
+ */
+function onError(callback) {
+  const nativeSubscription = _reactNative.DeviceEventEmitter.addListener('onTrackingError', event => {
+    const error = {
+      code: event.code,
+      message: event.message,
+      recoverable: event.recoverable ?? true,
+      details: event.details ?? undefined
+    };
+    callback(error);
+  });
+  return {
+    remove: () => {
+      nativeSubscription.remove();
+    }
+  };
+}
+
+/**
+ * Remove all event listeners registered through this module.
+ *
+ * Useful for cleanup when the tracking module is being torn down
+ * or when all subscriptions need to be cleared at once.
+ */
+function removeAllListeners() {
+  _reactNative.DeviceEventEmitter.removeAllListeners('onLocationUpdate');
+  _reactNative.DeviceEventEmitter.removeAllListeners('onTrackingError');
+}
+//# sourceMappingURL=EventEmitter.js.map

package/lib/commonjs/EventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","onLocationUpdate","callback","nativeSubscription","DeviceEventEmitter","addListener","event","location","latitude","longitude","timestamp","accuracy","speed","altitude","bearing","remove","onError","error","code","message","recoverable","details","undefined","removeAllListeners"],"sourceRoot":"../../src","sources":["EventEmitter.ts"],"mappings":";;;;;;;;AASA,IAAAA,YAAA,GAAAC,OAAA;AATA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,gBAAgBA,CAC9BC,QAA0C,EAC5B;EACd,MAAMC,kBAAkB,GAAGC,+BAAkB,CAACC,WAAW,CACvD,kBAAkB,EACjBC,KAA8B,IAAK;IAClC,MAAMC,QAAsB,GAAG;MAC7BC,QAAQ,EAAEF,KAAK,CAACE,QAAkB;MAClCC,SAAS,EAAEH,KAAK,CAACG,SAAmB;MACpCC,SAAS,EAAEJ,KAAK,CAACI,SAAmB;MACpCC,QAAQ,EAAEL,KAAK,CAACK,QAAkB;MAClCC,KAAK,EAAGN,KAAK,CAACM,KAAK,IAAsB,IAAI;MAC7CC,QAAQ,EAAGP,KAAK,CAACO,QAAQ,IAAsB,IAAI;MACnDC,OAAO,EAAGR,KAAK,CAACQ,OAAO,IAAsB;IAC/C,CAAC;IACDZ,QAAQ,CAACK,QAAQ,CAAC;EACpB,CACF,CAAC;EAED,OAAO;IACLQ,MAAM,EAAEA,CAAA,KAAM;MACZZ,kBAAkB,CAACY,MAAM,CAAC,CAAC;IAC7B;EACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,OAAOA,CACrBd,QAAwC,EAC1B;EACd,MAAMC,kBAAkB,GAAGC,+BAAkB,CAACC,WAAW,CACvD,iBAAiB,EAChBC,KAA8B,IAAK;IAClC,MAAMW,KAAoB,GAAG;MAC3BC,IAAI,EAAEZ,KAAK,CAACY,IAAc;MAC1BC,OAAO,EAAEb,KAAK,CAACa,OAAiB;MAChCC,WAAW,EAAGd,KAAK,CAACc,WAAW,IAAgB,IAAI;MACnDC,OAAO,EAAGf,KAAK,CAACe,OAAO,IAAgCC;IACzD,CAAC;IACDpB,QAAQ,CAACe,KAAK,CAAC;EACjB,CACF,CAAC;EAED,OAAO;IACLF,MAAM,EAAEA,CAAA,KAAM;MACZZ,kBAAkB,CAACY,MAAM,CAAC,CAAC;IAC7B;EACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASQ,kBAAkBA,CAAA,EAAS;EACzCnB,+BAAkB,CAACmB,kBAAkB,CAAC,kBAAkB,CAAC;EACzDnB,+BAAkB,CAACmB,kBAAkB,CAAC,iBAAiB,CAAC;AAC1D","ignoreList":[]}

package/lib/commonjs/LiveTracking.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._resetConfiguredStateForTesting = _resetConfiguredStateForTesting;
+exports.default = void 0;
+var _NativeLiveTracking = _interopRequireDefault(require("./NativeLiveTracking"));
+var _EventEmitter = require("./EventEmitter");
+var _validation = require("./validation");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * JavaScript LiveTracking module that wraps NativeModule calls.
+ *
+ * Provides the public API for configuring, starting, and stopping
+ * location tracking, with validation and state management.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Returns the native module or throws a descriptive error if not linked.
+ * Using a function accessor (rather than assertNative) keeps TypeScript
+ * happy since it can't narrow an imported binding via assertion functions.
+ */
+function native() {
+  if (!_NativeLiveTracking.default) {
+    throw new Error("[@kafitra/react-native-live-tracking] Native module 'LiveTracking' is not registered. " + 'Make sure you ran `pod install` and rebuilt the app from Xcode.');
+  }
+  return _NativeLiveTracking.default;
+}
+
+/**
+ * Tracks whether configure() has been successfully called.
+ * Used to guard queue methods that require configuration.
+ */
+let isConfigured = false;
+
+/**
+ * Resets the configured state. Only for use in tests.
+ * @internal
+ */
+function _resetConfiguredStateForTesting() {
+  isConfigured = false;
+}
+
+/**
+ * LiveTracking module implementation.
+ *
+ * Wraps native module calls with validation, serialization,
+ * and state management on the JavaScript side.
+ */
+const LiveTracking = {
+  /**
+   * Configure the tracking library with the given parameters.
+   * Validates the config, applies defaults, and passes to native layer.
+   */
+  async configure(config) {
+    const validationResult = (0, _validation.validateConfig)(config);
+    if (!validationResult.valid) {
+      const errorMessages = validationResult.errors.map(e => `[${e.field}]: ${e.message}`).join('; ');
+      throw new Error(`Invalid configuration: ${errorMessages}`);
+    }
+    const finalConfig = (0, _validation.applyDefaults)(config);
+    const jsonString = JSON.stringify(finalConfig);
+    const MAX_PAYLOAD_BYTES = 1024 * 1024; // 1 MB
+    if (jsonString.length > MAX_PAYLOAD_BYTES) {
+      throw new Error('Configuration payload is too large: serialized JSON exceeds 1 MB');
+    }
+    await native().configure(jsonString);
+    isConfigured = true;
+  },
+  /**
+   * Start location tracking.
+   * Requires `configure()` to have been called first.
+   */
+  async start() {
+    await native().start();
+  },
+  /**
+   * Stop location tracking and clean up resources.
+   */
+  async stop() {
+    await native().stop();
+  },
+  /**
+   * Register a callback for location updates.
+   */
+  onLocationUpdate(callback) {
+    return (0, _EventEmitter.onLocationUpdate)(callback);
+  },
+  /**
+   * Register a callback for tracking errors.
+   */
+  onError(callback) {
+    return (0, _EventEmitter.onError)(callback);
+  },
+  /**
+   * Get the current tracking status.
+   */
+  async getStatus() {
+    const jsonString = await native().getStatus();
+    return JSON.parse(jsonString);
+  },
+  /**
+   * Get the total number of locations currently queued for sync.
+   *
+   * @throws Error with code NOT_CONFIGURED if called before configure()
+   */
+  async getQueuedLocations() {
+    if (!isConfigured) {
+      const error = new Error('LiveTracking is not configured. Call configure() before getQueuedLocations().');
+      error.code = 'NOT_CONFIGURED';
+      throw error;
+    }
+    return native().getQueuedLocations();
+  },
+  /**
+   * Get the number of queued locations per target path.
+   *
+   * @throws Error with code NOT_CONFIGURED if called before configure()
+   */
+  async getQueuedLocationsByTarget() {
+    if (!isConfigured) {
+      const error = new Error('LiveTracking is not configured. Call configure() before getQueuedLocationsByTarget().');
+      error.code = 'NOT_CONFIGURED';
+      throw error;
+    }
+    const jsonString = await native().getQueuedLocationsByTarget();
+    return JSON.parse(jsonString);
+  }
+};
+var _default = exports.default = LiveTracking;
+//# sourceMappingURL=LiveTracking.js.map

package/lib/commonjs/LiveTracking.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeLiveTracking","_interopRequireDefault","require","_EventEmitter","_validation","e","__esModule","default","native","NativeLiveTracking","Error","isConfigured","_resetConfiguredStateForTesting","LiveTracking","configure","config","validationResult","validateConfig","valid","errorMessages","errors","map","field","message","join","finalConfig","applyDefaults","jsonString","JSON","stringify","MAX_PAYLOAD_BYTES","length","start","stop","onLocationUpdate","callback","emitterOnLocationUpdate","onError","emitterOnError","getStatus","parse","getQueuedLocations","error","code","getQueuedLocationsByTarget","_default","exports"],"sourceRoot":"../../src","sources":["LiveTracking.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/NativeLiveTracking.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+/**
+ * Codegen spec for react-native-live-tracking.
+ *
+ * Uses TurboModuleRegistry.get (not getEnforcing) so that a missing or
+ * not-yet-registered module returns null instead of throwing synchronously.
+ * A top-level throw would corrupt the module graph and leave upstream
+ * importers (TrackingProvider, AppNavigator) with undefined module records.
+ *
+ * File must be named Native*.ts and live in the codegenConfig.jsSrcsDir
+ * for RN's codegen to pick it up.
+ */
+// Try TurboModule first (new arch with codegen), fall back to Bridge (old arch / interop)
+var _default = exports.default = _reactNative.TurboModuleRegistry.get('LiveTracking') ?? _reactNative.NativeModules.LiveTracking;
+//# sourceMappingURL=NativeLiveTracking.js.map

package/lib/commonjs/NativeLiveTracking.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","get","NativeModules","LiveTracking"],"sourceRoot":"../../src","sources":["NativeLiveTracking.ts"],"mappings":";;;;;;AAaA,IAAAA,YAAA,GAAAC,OAAA;AAbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAgBA;AAAA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GACgBC,gCAAmB,CAACC,GAAG,CAAO,cAAc,CAAC,IAC3DC,0BAAa,CAACC,YAAY","ignoreList":[]}

package/lib/commonjs/filters/distanceTimeFilter.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldAcceptLocation = shouldAcceptLocation;
+var _distance = require("../utils/distance");
+/**
+ * Distance/Time Matrix filter for location updates.
+ *
+ * This filter implements the battery optimization strategy that accepts a new
+ * location update based on the selected mode:
+ * - 'both' (default): BOTH time and distance conditions must be met
+ * - 'interval': only the time condition must be met
+ * - 'distance': only the distance condition must be met
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Configuration subset required by the distance/time filter.
+ */
+
+/**
+ * Determines whether a new location should be accepted based on the
+ * Distance/Time Matrix filter criteria.
+ *
+ * The filtering strategy depends on `config.mode`:
+ * - 'both': accepted only if both time and distance conditions are met
+ * - 'interval': accepted only if enough time has elapsed
+ * - 'distance': accepted only if enough distance has been covered
+ *
+ * @param lastLocation - The most recently accepted location
+ * @param newLocation - The candidate location to evaluate
+ * @param config - Filter configuration with intervalMs, distanceFilterMeters, and mode
+ * @returns `true` if the new location should be accepted, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * const accepted = shouldAcceptLocation(
+ *   { latitude: -6.2088, longitude: 106.8456, timestamp: 1700000000000, accuracy: 5, speed: null, altitude: null, bearing: null },
+ *   { latitude: -6.2090, longitude: 106.8460, timestamp: 1700000015000, accuracy: 5, speed: 1.2, altitude: null, bearing: null },
+ *   { intervalMs: 10000, distanceFilterMeters: 10, mode: 'both' }
+ * );
+ * ```
+ */
+function shouldAcceptLocation(lastLocation, newLocation, config) {
+  const mode = config.mode ?? 'both';
+  const timeDiff = newLocation.timestamp - lastLocation.timestamp;
+  const distance = (0, _distance.calculateDistance)(lastLocation.latitude, lastLocation.longitude, newLocation.latitude, newLocation.longitude);
+  const timeMet = timeDiff >= config.intervalMs;
+  const distanceMet = distance >= config.distanceFilterMeters;
+  switch (mode) {
+    case 'interval':
+      return timeMet;
+    case 'distance':
+      return distanceMet;
+    case 'both':
+    default:
+      return timeMet && distanceMet;
+  }
+}
+//# sourceMappingURL=distanceTimeFilter.js.map

package/lib/commonjs/filters/distanceTimeFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_distance","require","shouldAcceptLocation","lastLocation","newLocation","config","mode","timeDiff","timestamp","distance","calculateDistance","latitude","longitude","timeMet","intervalMs","distanceMet","distanceFilterMeters"],"sourceRoot":"../../../src","sources":["filters/distanceTimeFilter.ts"],"mappings":";;;;;;AAYA,IAAAA,SAAA,GAAAC,OAAA;AAZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,oBAAoBA,CAClCC,YAA0B,EAC1BC,WAAyB,EACzBC,MAAgC,EACvB;EACT,MAAMC,IAAI,GAAGD,MAAM,CAACC,IAAI,IAAI,MAAM;EAClC,MAAMC,QAAQ,GAAGH,WAAW,CAACI,SAAS,GAAGL,YAAY,CAACK,SAAS;EAC/D,MAAMC,QAAQ,GAAG,IAAAC,2BAAiB,EAChCP,YAAY,CAACQ,QAAQ,EACrBR,YAAY,CAACS,SAAS,EACtBR,WAAW,CAACO,QAAQ,EACpBP,WAAW,CAACQ,SACd,CAAC;EAED,MAAMC,OAAO,GAAGN,QAAQ,IAAIF,MAAM,CAACS,UAAU;EAC7C,MAAMC,WAAW,GAAGN,QAAQ,IAAIJ,MAAM,CAACW,oBAAoB;EAE3D,QAAQV,IAAI;IACV,KAAK,UAAU;MACb,OAAOO,OAAO;IAChB,KAAK,UAAU;MACb,OAAOE,WAAW;IACpB,KAAK,MAAM;IACX;MACE,OAAOF,OAAO,IAAIE,WAAW;EACjC;AACF","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "LiveTracking", {
+  enumerable: true,
+  get: function () {
+    return _LiveTracking.default;
+  }
+});
+Object.defineProperty(exports, "TrackingState", {
+  enumerable: true,
+  get: function () {
+    return _types.TrackingState;
+  }
+});
+Object.defineProperty(exports, "applyDefaults", {
+  enumerable: true,
+  get: function () {
+    return _validation.applyDefaults;
+  }
+});
+Object.defineProperty(exports, "calculateBackoffDelay", {
+  enumerable: true,
+  get: function () {
+    return _retry.calculateBackoffDelay;
+  }
+});
+Object.defineProperty(exports, "calculateDistance", {
+  enumerable: true,
+  get: function () {
+    return _distance.calculateDistance;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "onError", {
+  enumerable: true,
+  get: function () {
+    return _EventEmitter.onError;
+  }
+});
+Object.defineProperty(exports, "onLocationUpdate", {
+  enumerable: true,
+  get: function () {
+    return _EventEmitter.onLocationUpdate;
+  }
+});
+Object.defineProperty(exports, "removeAllListeners", {
+  enumerable: true,
+  get: function () {
+    return _EventEmitter.removeAllListeners;
+  }
+});
+Object.defineProperty(exports, "serializeLocationForTarget", {
+  enumerable: true,
+  get: function () {
+    return _locationSerializer.serializeLocationForTarget;
+  }
+});
+Object.defineProperty(exports, "shouldAcceptLocation", {
+  enumerable: true,
+  get: function () {
+    return _distanceTimeFilter.shouldAcceptLocation;
+  }
+});
+Object.defineProperty(exports, "shouldRetry", {
+  enumerable: true,
+  get: function () {
+    return _retry.shouldRetry;
+  }
+});
+Object.defineProperty(exports, "validateConfig", {
+  enumerable: true,
+  get: function () {
+    return _validation.validateConfig;
+  }
+});
+var _LiveTracking = _interopRequireDefault(require("./LiveTracking"));
+var _types = require("./types");
+var _EventEmitter = require("./EventEmitter");
+var _validation = require("./validation");
+var _distance = require("./utils/distance");
+var _distanceTimeFilter = require("./filters/distanceTimeFilter");
+var _locationSerializer = require("./serialization/locationSerializer");
+var _retry = require("./utils/retry");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * react-native-live-tracking
+ *
+ * Real-time location tracking library for React Native with Firebase synchronization.
+ * Supports both TurboModules (new architecture) and Bridge (old architecture).
+ *
+ * @packageDocumentation
+ */
+var _default = exports.default = _LiveTracking.default; // Re-export all types
+// Event listener functions
+// Configuration validation utilities
+// Distance calculation utility
+// Distance/Time Matrix filter
+// Location serialization for Firebase
+// Retry/backoff utilities
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_LiveTracking","_interopRequireDefault","require","_types","_EventEmitter","_validation","_distance","_distanceTimeFilter","_locationSerializer","_retry","e","__esModule","default","_default","exports","LiveTracking"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,IAAAA,aAAA,GAAAC,sBAAA,CAAAC,OAAA;AAMA,IAAAC,MAAA,GAAAD,OAAA;AAmBA,IAAAE,aAAA,GAAAF,OAAA;AAGA,IAAAG,WAAA,GAAAH,OAAA;AAGA,IAAAI,SAAA,GAAAJ,OAAA;AAGA,IAAAK,mBAAA,GAAAL,OAAA;AAGA,IAAAM,mBAAA,GAAAN,OAAA;AAIA,IAAAO,MAAA,GAAAP,OAAA;AAAmE,SAAAD,uBAAAS,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAlDnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAPA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAWeG,qBAAY,EAG3B;AAmBA;AAGA;AAGA;AAGA;AAGA;AAIA","ignoreList":[]}