@umituz/react-native-location 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Ümit UZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,127 @@
+# @umituz/react-native-location
+
+Device location services for React Native with GPS, permissions, caching, and reverse geocoding.
+
+## Installation
+
+```bash
+npm install @umituz/react-native-location
+```
+
+## Peer Dependencies
+
+- `react` >= 18.2.0
+- `react-native` >= 0.74.0
+- `expo-location` *
+- `@react-native-async-storage/async-storage` *
+
+## Features
+
+- ✅ Current location retrieval with GPS
+- ✅ Location permission management (iOS/Android)
+- ✅ 15-minute location caching for performance
+- ✅ Reverse geocoding (coordinates → address)
+- ✅ Multi-tier accuracy fallback (High → Balanced → Cached)
+- ✅ Platform-aware (iOS/Android only, no web support)
+
+## Usage
+
+### Using Hook (Recommended)
+
+```typescript
+import { useLocation } from '@umituz/react-native-location';
+
+const MyComponent = () => {
+  const {
+    location,
+    loading,
+    hasPermission,
+    requestPermission,
+    getCurrentLocation,
+    formatLocation,
+  } = useLocation();
+
+  useEffect(() => {
+    // Auto-fetch on mount
+    getCurrentLocation();
+  }, []);
+
+  if (loading) return <LoadingIndicator />;
+
+  return (
+    <View>
+      {location && (
+        <>
+          <Text>Location: {formatLocation(location)}</Text>
+          <Text>Lat: {location.latitude}</Text>
+          <Text>Lng: {location.longitude}</Text>
+          {location.accuracy && (
+            <Text>Accuracy: {location.accuracy.toFixed(0)}m</Text>
+          )}
+        </>
+      )}
+      <Button onPress={getCurrentLocation}>
+        Refresh Location
+      </Button>
+    </View>
+  );
+};
+```
+
+### Using Service Directly
+
+```typescript
+import { locationService } from '@umituz/react-native-location';
+
+// Check permission
+const hasPermission = await locationService.hasPermissions();
+
+// Request permission if needed
+if (!hasPermission) {
+  const granted = await locationService.requestPermissions();
+}
+
+// Get current location
+const location = await locationService.getCurrentLocation();
+if (location) {
+  console.log(locationService.formatLocation(location));
+}
+```
+
+## Platform Support
+
+- ✅ iOS: Full support (GPS, permissions, geocoding)
+- ✅ Android: Full support (GPS, permissions, geocoding)
+- ❌ Web: Not supported (returns null)
+
+## Permission Flow
+
+1. Check: `hasPermissions()` → true/false
+2. Request: `requestPermissions()` → true/false
+3. Retrieve: `getCurrentLocation()` → LocationData | null
+
+## Fallback Strategy
+
+1. High accuracy GPS (15s timeout)
+2. Balanced accuracy GPS (8s timeout)
+3. Cached location (15min cache)
+4. null (no location available)
+
+## Caching
+
+- Duration: 15 minutes
+- Storage: AsyncStorage
+- Auto-refresh: On `getCurrentLocation()` if expired
+
+## Hooks
+
+- `useLocation()` - Main hook for location operations
+
+## Services
+
+- `locationService` - Direct service access for location operations
+
+## License
+
+MIT
+

package/lib/domain/entities/Location.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Location Domain Entities
+ *
+ * Core location types and interfaces for device location services
+ * and geolocation features
+ *
+ * Features:
+ * - Current location retrieval with GPS
+ * - Location permission management
+ * - Location caching (15-minute cache)
+ * - Reverse geocoding (address lookup)
+ * - Fallback strategies (High → Balanced → Cached)
+ * - Platform-aware (iOS/Android only, no web)
+ *
+ * Dependencies:
+ * - expo-location (GPS and permissions)
+ * - AsyncStorage (location cache)
+ */
+/**
+ * Location data with coordinates and optional address
+ */
+export interface LocationData {
+    /** Latitude coordinate */
+    latitude: number;
+    /** Longitude coordinate */
+    longitude: number;
+    /** Human-readable address (reverse geocoded) */
+    address?: string;
+    /** Timestamp when location was captured (milliseconds since epoch) */
+    timestamp: number;
+    /** GPS accuracy in meters (lower is better) */
+    accuracy?: number;
+    /** Whether this location is from cache (not fresh GPS) */
+    isCached?: boolean;
+}
+/**
+ * Location permission status
+ */
+export type LocationPermissionStatus = 'granted' | 'denied' | 'unknown';
+/**
+ * Location accuracy levels for GPS
+ */
+export declare enum LocationAccuracy {
+    /** Lowest accuracy, fastest response, battery-friendly */
+    Lowest = 1,
+    /** Low accuracy */
+    Low = 2,
+    /** Balanced accuracy (recommended for most use cases) */
+    Balanced = 3,
+    /** High accuracy (GPS-based) */
+    High = 4,
+    /** Highest accuracy (most battery-intensive) */
+    Highest = 5,
+    /** Best for navigation (continuous high accuracy) */
+    BestForNavigation = 6
+}
+/**
+ * Location cache configuration
+ */
+export interface LocationCacheConfig {
+    /** Cache duration in milliseconds (default: 15 minutes) */
+    duration: number;
+    /** Storage key for cached location */
+    storageKey: string;
+}
+/**
+ * Location retrieval configuration
+ */
+export interface LocationRetrievalConfig {
+    /** Timeout for high accuracy request (milliseconds) */
+    highAccuracyTimeout: number;
+    /** Timeout for balanced accuracy request (milliseconds) */
+    balancedAccuracyTimeout: number;
+    /** Whether to enable reverse geocoding (address lookup) */
+    enableGeocoding: boolean;
+}
+/**
+ * Cached location storage format
+ */
+export interface CachedLocation {
+    /** Location data */
+    data: LocationData;
+    /** Timestamp when location was cached (milliseconds since epoch) */
+    cachedAt: number;
+}
+/**
+ * Location Service Interface
+ * Defines all location-related operations
+ */
+export interface ILocationService {
+    /**
+     * Request location permissions from user
+     * @returns Promise resolving to true if granted, false otherwise
+     */
+    requestPermissions(): Promise<boolean>;
+    /**
+     * Check if location permissions are granted
+     * @returns Promise resolving to true if granted, false otherwise
+     */
+    hasPermissions(): Promise<boolean>;
+    /**
+     * Get current permission status without requesting
+     * @returns Current permission status ('granted' | 'denied' | 'unknown')
+     */
+    getPermissionStatus(): LocationPermissionStatus;
+    /**
+     * Get current device location with fallback strategies
+     * Priority: High accuracy → Balanced accuracy → Cached location → null
+     * @returns Promise resolving to LocationData or null if unavailable
+     */
+    getCurrentLocation(): Promise<LocationData | null>;
+    /**
+     * Get cached location if available and not expired
+     * @returns Cached location or null
+     */
+    getCachedLocation(): LocationData | null;
+    /**
+     * Format location for display (address or coordinates)
+     * @param location - LocationData to format
+     * @returns Formatted string (address or "lat, lng")
+     */
+    formatLocation(location: LocationData): string;
+    /**
+     * Check if location services are available on this platform
+     * @returns True if available (iOS/Android), false otherwise (web)
+     */
+    isLocationAvailable(): boolean;
+}
+/**
+ * Location service constants
+ */
+export declare const LOCATION_CONSTANTS: {
+    /** Cache duration: 15 minutes */
+    readonly CACHE_DURATION: number;
+    /** High accuracy timeout: 15 seconds */
+    readonly HIGH_ACCURACY_TIMEOUT: 15000;
+    /** Balanced accuracy timeout: 8 seconds */
+    readonly BALANCED_ACCURACY_TIMEOUT: 8000;
+    /** AsyncStorage key for cached location */
+    readonly CACHE_KEY: "@location_cache";
+    /** Coordinate decimal precision for display */
+    readonly COORDINATE_PRECISION: 4;
+};
+//# sourceMappingURL=Location.d.ts.map

package/lib/domain/entities/Location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Location.d.ts","sourceRoot":"","sources":["../../../src/domain/entities/Location.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAC;IAElB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAElB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExE;;GAEG;AACH,oBAAY,gBAAgB;IAC1B,0DAA0D;IAC1D,MAAM,IAAI;IAEV,mBAAmB;IACnB,GAAG,IAAI;IAEP,yDAAyD;IACzD,QAAQ,IAAI;IAEZ,gCAAgC;IAChC,IAAI,IAAI;IAER,gDAAgD;IAChD,OAAO,IAAI;IAEX,qDAAqD;IACrD,iBAAiB,IAAI;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IAEjB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,uDAAuD;IACvD,mBAAmB,EAAE,MAAM,CAAC;IAE5B,2DAA2D;IAC3D,uBAAuB,EAAE,MAAM,CAAC;IAEhC,2DAA2D;IAC3D,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oBAAoB;IACpB,IAAI,EAAE,YAAY,CAAC;IAEnB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEvC;;;OAGG;IACH,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC;;;OAGG;IACH,mBAAmB,IAAI,wBAAwB,CAAC;IAEhD;;;;OAIG;IACH,kBAAkB,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAEnD;;;OAGG;IACH,iBAAiB,IAAI,YAAY,GAAG,IAAI,CAAC;IAEzC;;;;OAIG;IACH,cAAc,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAC;IAE/C;;;OAGG;IACH,mBAAmB,IAAI,OAAO,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,iCAAiC;;IAGjC,wCAAwC;;IAGxC,2CAA2C;;IAG3C,2CAA2C;;IAG3C,+CAA+C;;CAEvC,CAAC"}

package/lib/domain/entities/Location.js

@@ -0,0 +1,52 @@
+/**
+ * Location Domain Entities
+ *
+ * Core location types and interfaces for device location services
+ * and geolocation features
+ *
+ * Features:
+ * - Current location retrieval with GPS
+ * - Location permission management
+ * - Location caching (15-minute cache)
+ * - Reverse geocoding (address lookup)
+ * - Fallback strategies (High → Balanced → Cached)
+ * - Platform-aware (iOS/Android only, no web)
+ *
+ * Dependencies:
+ * - expo-location (GPS and permissions)
+ * - AsyncStorage (location cache)
+ */
+/**
+ * Location accuracy levels for GPS
+ */
+export var LocationAccuracy;
+(function (LocationAccuracy) {
+    /** Lowest accuracy, fastest response, battery-friendly */
+    LocationAccuracy[LocationAccuracy["Lowest"] = 1] = "Lowest";
+    /** Low accuracy */
+    LocationAccuracy[LocationAccuracy["Low"] = 2] = "Low";
+    /** Balanced accuracy (recommended for most use cases) */
+    LocationAccuracy[LocationAccuracy["Balanced"] = 3] = "Balanced";
+    /** High accuracy (GPS-based) */
+    LocationAccuracy[LocationAccuracy["High"] = 4] = "High";
+    /** Highest accuracy (most battery-intensive) */
+    LocationAccuracy[LocationAccuracy["Highest"] = 5] = "Highest";
+    /** Best for navigation (continuous high accuracy) */
+    LocationAccuracy[LocationAccuracy["BestForNavigation"] = 6] = "BestForNavigation";
+})(LocationAccuracy || (LocationAccuracy = {}));
+/**
+ * Location service constants
+ */
+export const LOCATION_CONSTANTS = {
+    /** Cache duration: 15 minutes */
+    CACHE_DURATION: 15 * 60 * 1000,
+    /** High accuracy timeout: 15 seconds */
+    HIGH_ACCURACY_TIMEOUT: 15000,
+    /** Balanced accuracy timeout: 8 seconds */
+    BALANCED_ACCURACY_TIMEOUT: 8000,
+    /** AsyncStorage key for cached location */
+    CACHE_KEY: '@location_cache',
+    /** Coordinate decimal precision for display */
+    COORDINATE_PRECISION: 4,
+};
+//# sourceMappingURL=Location.js.map

package/lib/domain/entities/Location.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Location.js","sourceRoot":"","sources":["../../../src/domain/entities/Location.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA8BH;;GAEG;AACH,MAAM,CAAN,IAAY,gBAkBX;AAlBD,WAAY,gBAAgB;IAC1B,0DAA0D;IAC1D,2DAAU,CAAA;IAEV,mBAAmB;IACnB,qDAAO,CAAA;IAEP,yDAAyD;IACzD,+DAAY,CAAA;IAEZ,gCAAgC;IAChC,uDAAQ,CAAA;IAER,gDAAgD;IAChD,6DAAW,CAAA;IAEX,qDAAqD;IACrD,iFAAqB,CAAA;AACvB,CAAC,EAlBW,gBAAgB,KAAhB,gBAAgB,QAkB3B;AAwFD;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,iCAAiC;IACjC,cAAc,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI;IAE9B,wCAAwC;IACxC,qBAAqB,EAAE,KAAK;IAE5B,2CAA2C;IAC3C,yBAAyB,EAAE,IAAI;IAE/B,2CAA2C;IAC3C,SAAS,EAAE,iBAAiB;IAE5B,+CAA+C;IAC/C,oBAAoB,EAAE,CAAC;CACf,CAAC"}

package/lib/index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Location Domain - Barrel Export
+ *
+ * Global infrastructure domain for device location services and geolocation
+ *
+ * Features:
+ * - Current location retrieval with GPS
+ * - Location permission management (iOS/Android)
+ * - 15-minute location caching for performance
+ * - Reverse geocoding (coordinates → address)
+ * - Multi-tier accuracy fallback (High → Balanced → Cached)
+ * - Platform-aware (iOS/Android only, no web support)
+ * - Silent failures (no console logging)
+ *
+ * Dependencies:
+ * - expo-location (GPS and permissions API)
+ * - AsyncStorage (cache persistence)
+ *
+ * USAGE:
+ * ```typescript
+ * // Recommended: Use hook in components
+ * import { useLocation } from '@umituz/react-native-location';
+ *
+ * const MyComponent = () => {
+ *   const {
+ *     location,
+ *     loading,
+ *     hasPermission,
+ *     requestPermission,
+ *     getCurrentLocation,
+ *     formatLocation,
+ *   } = useLocation();
+ *
+ *   useEffect(() => {
+ *     // Auto-fetch on mount
+ *     getCurrentLocation();
+ *   }, []);
+ *
+ *   if (loading) return <LoadingIndicator />;
+ *
+ *   return (
+ *     <View>
+ *       {location && (
+ *         <>
+ *           <Text>Location: {formatLocation(location)}</Text>
+ *           <Text>Lat: {location.latitude}</Text>
+ *           <Text>Lng: {location.longitude}</Text>
+ *           {location.accuracy && (
+ *             <Text>Accuracy: {location.accuracy.toFixed(0)}m</Text>
+ *           )}
+ *         </>
+ *       )}
+ *       <AtomicButton onPress={getCurrentLocation}>
+ *         Refresh Location
+ *       </AtomicButton>
+ *     </View>
+ *   );
+ * };
+ *
+ * // Alternative: Use service directly (for non-component code)
+ * import { locationService } from '@umituz/react-native-location';
+ *
+ * const location = await locationService.getCurrentLocation();
+ * if (location) {
+ *   console.log(locationService.formatLocation(location));
+ * }
+ * ```
+ *
+ * PLATFORM SUPPORT:
+ * - ✅ iOS: Full support (GPS, permissions, geocoding)
+ * - ✅ Android: Full support (GPS, permissions, geocoding)
+ * - ❌ Web: Not supported (returns null)
+ *
+ * PERMISSION FLOW:
+ * 1. Check: hasPermissions() → true/false
+ * 2. Request: requestPermissions() → true/false
+ * 3. Retrieve: getCurrentLocation() → LocationData | null
+ *
+ * FALLBACK STRATEGY:
+ * 1. High accuracy GPS (15s timeout)
+ * 2. Balanced accuracy GPS (8s timeout)
+ * 3. Cached location (15min cache)
+ * 4. null (no location available)
+ *
+ * CACHING:
+ * - Duration: 15 minutes
+ * - Storage: AsyncStorage (@location_cache)
+ * - Auto-refresh: On getCurrentLocation() if expired
+ */
+export type { LocationData, LocationPermissionStatus, CachedLocation, LocationCacheConfig, LocationRetrievalConfig, ILocationService, } from './domain/entities/Location';
+export { LocationAccuracy, LOCATION_CONSTANTS } from './domain/entities/Location';
+export { locationService } from './infrastructure/services/LocationService';
+export { useLocation } from './presentation/hooks/useLocation';
+export type { UseLocationReturn } from './presentation/hooks/useLocation';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AAGH,YAAY,EACV,YAAY,EACZ,wBAAwB,EACxB,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGlF,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAG5E,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,YAAY,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC"}

package/lib/index.js

@@ -0,0 +1,95 @@
+/**
+ * Location Domain - Barrel Export
+ *
+ * Global infrastructure domain for device location services and geolocation
+ *
+ * Features:
+ * - Current location retrieval with GPS
+ * - Location permission management (iOS/Android)
+ * - 15-minute location caching for performance
+ * - Reverse geocoding (coordinates → address)
+ * - Multi-tier accuracy fallback (High → Balanced → Cached)
+ * - Platform-aware (iOS/Android only, no web support)
+ * - Silent failures (no console logging)
+ *
+ * Dependencies:
+ * - expo-location (GPS and permissions API)
+ * - AsyncStorage (cache persistence)
+ *
+ * USAGE:
+ * ```typescript
+ * // Recommended: Use hook in components
+ * import { useLocation } from '@umituz/react-native-location';
+ *
+ * const MyComponent = () => {
+ *   const {
+ *     location,
+ *     loading,
+ *     hasPermission,
+ *     requestPermission,
+ *     getCurrentLocation,
+ *     formatLocation,
+ *   } = useLocation();
+ *
+ *   useEffect(() => {
+ *     // Auto-fetch on mount
+ *     getCurrentLocation();
+ *   }, []);
+ *
+ *   if (loading) return <LoadingIndicator />;
+ *
+ *   return (
+ *     <View>
+ *       {location && (
+ *         <>
+ *           <Text>Location: {formatLocation(location)}</Text>
+ *           <Text>Lat: {location.latitude}</Text>
+ *           <Text>Lng: {location.longitude}</Text>
+ *           {location.accuracy && (
+ *             <Text>Accuracy: {location.accuracy.toFixed(0)}m</Text>
+ *           )}
+ *         </>
+ *       )}
+ *       <AtomicButton onPress={getCurrentLocation}>
+ *         Refresh Location
+ *       </AtomicButton>
+ *     </View>
+ *   );
+ * };
+ *
+ * // Alternative: Use service directly (for non-component code)
+ * import { locationService } from '@umituz/react-native-location';
+ *
+ * const location = await locationService.getCurrentLocation();
+ * if (location) {
+ *   console.log(locationService.formatLocation(location));
+ * }
+ * ```
+ *
+ * PLATFORM SUPPORT:
+ * - ✅ iOS: Full support (GPS, permissions, geocoding)
+ * - ✅ Android: Full support (GPS, permissions, geocoding)
+ * - ❌ Web: Not supported (returns null)
+ *
+ * PERMISSION FLOW:
+ * 1. Check: hasPermissions() → true/false
+ * 2. Request: requestPermissions() → true/false
+ * 3. Retrieve: getCurrentLocation() → LocationData | null
+ *
+ * FALLBACK STRATEGY:
+ * 1. High accuracy GPS (15s timeout)
+ * 2. Balanced accuracy GPS (8s timeout)
+ * 3. Cached location (15min cache)
+ * 4. null (no location available)
+ *
+ * CACHING:
+ * - Duration: 15 minutes
+ * - Storage: AsyncStorage (@location_cache)
+ * - Auto-refresh: On getCurrentLocation() if expired
+ */
+export { LocationAccuracy, LOCATION_CONSTANTS } from './domain/entities/Location';
+// Infrastructure Services
+export { locationService } from './infrastructure/services/LocationService';
+// Presentation Hooks
+export { useLocation } from './presentation/hooks/useLocation';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AAWH,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAElF,0BAA0B;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAE5E,qBAAqB;AACrB,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC"}

package/lib/infrastructure/services/LocationService.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Location Service Implementation
+ *
+ * Handles device location retrieval, permissions, caching, and reverse geocoding
+ * with intelligent fallback strategies
+ *
+ * Features:
+ * - Multi-tier accuracy fallback (High → Balanced → Cached)
+ * - 15-minute location caching for performance
+ * - Reverse geocoding with coordinate fallback
+ * - Platform detection (iOS/Android only, no web)
+ * - Silent failures (no console logging)
+ * - AsyncStorage persistence
+ *
+ * Dependencies:
+ * - expo-location (GPS and permissions API)
+ * - AsyncStorage (cache persistence)
+ *
+ * USAGE:
+ * ```typescript
+ * import { locationService } from '@umituz/react-native-location';
+ *
+ * // Check permission
+ * const hasPermission = await locationService.hasPermissions();
+ *
+ * // Request permission if needed
+ * if (!hasPermission) {
+ *   const granted = await locationService.requestPermissions();
+ * }
+ *
+ * // Get current location
+ * const location = await locationService.getCurrentLocation();
+ * if (location) {
+ *   console.log(location.latitude, location.longitude);
+ *   console.log(locationService.formatLocation(location));
+ * }
+ * ```
+ */
+import type { LocationData, LocationPermissionStatus, ILocationService } from '../../domain/entities/Location';
+declare class LocationService implements ILocationService {
+    private cachedLocation;
+    private cachedAt;
+    private permissionStatus;
+    constructor();
+    /**
+     * Check if location services are available on this platform
+     */
+    isLocationAvailable(): boolean;
+    /**
+     * Load cached location from AsyncStorage
+     */
+    private loadCachedLocation;
+    /**
+     * Save location to cache (AsyncStorage + memory)
+     */
+    private saveCachedLocation;
+    /**
+     * Get cached location if available and not expired
+     */
+    getCachedLocation(): LocationData | null;
+    /**
+     * Request location permissions from user
+     */
+    requestPermissions(): Promise<boolean>;
+    /**
+     * Check if location permissions are granted
+     */
+    hasPermissions(): Promise<boolean>;
+    /**
+     * Get permission status without requesting
+     */
+    getPermissionStatus(): LocationPermissionStatus;
+    /**
+     * Get current location with fallback strategies
+     * Priority: High accuracy → Balanced accuracy → Cached location → null
+     */
+    getCurrentLocation(): Promise<LocationData | null>;
+    /**
+     * Get location with specific accuracy and timeout
+     */
+    private getLocationWithAccuracy;
+    /**
+     * Format location for display (address or coordinates)
+     */
+    formatLocation(location: LocationData): string;
+}
+/**
+ * Singleton instance
+ * Use this for all location operations
+ */
+export declare const locationService: LocationService;
+export {};
+//# sourceMappingURL=LocationService.d.ts.map

package/lib/infrastructure/services/LocationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocationService.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/LocationService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAMH,OAAO,KAAK,EACV,YAAY,EACZ,wBAAwB,EAExB,gBAAgB,EACjB,MAAM,gCAAgC,CAAC;AAGxC,cAAM,eAAgB,YAAW,gBAAgB;IAC/C,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,gBAAgB,CAAuC;;IAM/D;;OAEG;IACH,mBAAmB,IAAI,OAAO;IAQ9B;;OAEG;YACW,kBAAkB;IAkBhC;;OAEG;YACW,kBAAkB;IAiBhC;;OAEG;IACH,iBAAiB,IAAI,YAAY,GAAG,IAAI;IAWxC;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC;IAgB5C;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAoBxC;;OAEG;IACH,mBAAmB,IAAI,wBAAwB;IAI/C;;;OAGG;IACG,kBAAkB,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IA6CxD;;OAEG;YACW,uBAAuB;IAqDrC;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM;CAQ/C;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAC"}