@umituz/react-native-location 1.0.26 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-location",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Device location services for React Native with GPS, permissions, caching, and reverse geocoding",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/application/ports/ICachePort.ts

@@ -0,0 +1,35 @@
+/**
+ * Application Layer - Cache Port
+ *
+ * Cache abstraction for dependency inversion.
+ * Decouples from specific storage implementation.
+ */
+
+import { LocationData } from "../../types/location.types";
+
+export interface CachedLocationData {
+    location: LocationData;
+    timestamp: number;
+}
+
+export interface ICachePort {
+    /**
+     * Cache'den location al
+     */
+    get(key: string): Promise<CachedLocationData | null>;
+
+    /**
+     * Location'ı cache'le
+     */
+    set(key: string, data: CachedLocationData): Promise<void>;
+
+    /**
+     * Cache'i temizle
+     */
+    remove(key: string): Promise<void>;
+
+    /**
+     * Tüm cache'i temizle
+     */
+    clear(): Promise<void>;
+}

package/src/application/ports/ILocationPort.ts

@@ -0,0 +1,58 @@
+/**
+ * Application Layer - Location Service Port
+ *
+ * Core location operations interface.
+ * Defines what location services can do, not how.
+ */
+
+import { LocationData, LocationAddress, LocationConfig } from "../../types/location.types";
+
+export interface ILocationPort {
+    /**
+     * Mevcut konumu al
+     */
+    getCurrentPosition(): Promise<LocationData>;
+
+    /**
+     * Son bilinen konumu al
+     */
+    getLastKnownPosition(): Promise<LocationData | null>;
+
+    /**
+     * Reverse geocoding
+     */
+    reverseGeocode(latitude: number, longitude: number): Promise<LocationAddress | undefined>;
+
+    /**
+     * Location servisleri açık mı?
+     */
+    isLocationEnabled(): Promise<boolean>;
+
+    /**
+     * Permission durumu
+     */
+    getPermissionStatus(): Promise<string>;
+}
+
+/**
+ * Location watcher için callback interface
+ */
+export interface ILocationWatcherPort {
+    /**
+     * Konum değişikliklerini dinle
+     */
+    watchPosition(
+        onSuccess: (location: LocationData) => void,
+        onError?: (error: Error) => void
+    ): Promise<void>;
+
+    /**
+     * Dinlemeyi durdur
+     */
+    clearWatch(): void;
+
+    /**
+     * Dinliyor mu?
+     */
+    isWatching(): boolean;
+}

package/src/application/ports/ILoggerPort.ts

@@ -0,0 +1,30 @@
+/**
+ * Application Layer - Logger Port
+ *
+ * Logging abstraction for dependency inversion.
+ * Implementation can be easily swapped.
+ */
+
+export enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR",
+}
+
+export interface ILoggerPort {
+    debug(message: string, context?: string): void;
+    info(message: string, context?: string): void;
+    warn(message: string, context?: string): void;
+    error(message: string, error?: unknown, context?: string): void;
+}
+
+/**
+ * No-op logger (production default)
+ */
+export class NoOpLogger implements ILoggerPort {
+    debug(): void {}
+    info(): void {}
+    warn(): void {}
+    error(): void {}
+}

package/src/domain/errors/LocationErrors.ts

@@ -0,0 +1,76 @@
+/**
+ * Domain Layer - Error Handling
+ *
+ * Merkezi error oluşturma ve validasyon.
+ * Tüm location error'ları buradan üretilir (Single Responsibility).
+ */
+
+import { LocationErrorCode, LocationError } from "../../types/location.types";
+
+export class LocationErrors {
+    private static readonly VALID_ERROR_CODES: readonly LocationErrorCode[] = [
+        "PERMISSION_DENIED",
+        "TIMEOUT",
+        "UNKNOWN_ERROR",
+    ] as const;
+
+    /**
+     * Error code validation
+     */
+    static isValidErrorCode(code: string): code is LocationErrorCode {
+        return this.VALID_ERROR_CODES.includes(code as LocationErrorCode);
+    }
+
+    /**
+     * Error object'ten code çıkarma
+     */
+    static extractErrorCode(error: unknown): LocationErrorCode {
+        if (error instanceof Error && "code" in error && typeof error.code === "string") {
+            if (this.isValidErrorCode(error.code)) {
+                return error.code;
+            }
+        }
+        return "UNKNOWN_ERROR";
+    }
+
+    /**
+     * Error mesajı çıkarma
+     */
+    static extractMessage(error: unknown): string {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return "An unknown error occurred";
+    }
+
+    /**
+     * Permission denied error
+     */
+    static permissionDenied(message = "Location permission not granted"): LocationError & Error {
+        return this.createError("PERMISSION_DENIED", message);
+    }
+
+    /**
+     * Timeout error
+     */
+    static timeout(message: string): LocationError & Error {
+        return this.createError("TIMEOUT", message);
+    }
+
+    /**
+     * Unknown error
+     */
+    static unknown(message: string): LocationError & Error {
+        return this.createError("UNKNOWN_ERROR", message);
+    }
+
+    /**
+     * Generic error factory
+     */
+    private static createError(code: LocationErrorCode, message: string): LocationError & Error {
+        const error = new Error(message) as Error & LocationError;
+        error.name = "LocationError";
+        error.code = code;
+        return error;
+    }
+}

package/src/domain/services/PermissionService.ts

@@ -0,0 +1,59 @@
+/**
+ * Domain Layer - Permission Service
+ *
+ * Location permission yönetimi için merkezi servis.
+ * Hem LocationService hem LocationWatcher tarafından kullanılır (DRY prensibi).
+ */
+
+import * as Location from "expo-location";
+
+export class PermissionService {
+    /**
+     * Mevcut permission durumunu kontrol et
+     */
+    static async getStatus(): Promise<Location.PermissionStatus> {
+        try {
+            const { status } = await Location.getForegroundPermissionsAsync();
+            return status;
+        } catch {
+            return Location.PermissionStatus.UNDETERMINED;
+        }
+    }
+
+    /**
+     * Permission zaten verilmiş mi?
+     */
+    static async isGranted(): Promise<boolean> {
+        const status = await this.getStatus();
+        return status === "granted";
+    }
+
+    /**
+     * Permission iste (eğer gerekirse)
+     */
+    static async request(): Promise<boolean> {
+        try {
+            // Önce mevcut durumu kontrol et
+            if (await this.isGranted()) {
+                return true;
+            }
+
+            // Permission iste
+            const { status } = await Location.requestForegroundPermissionsAsync();
+            return status === "granted";
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Location servislerinin açık olup olmadığını kontrol et
+     */
+    static async areServicesEnabled(): Promise<boolean> {
+        try {
+            return await Location.hasServicesEnabledAsync();
+        } catch {
+            return false;
+        }
+    }
+}

package/src/domain/value-objects/CoordinatesVO.ts

@@ -0,0 +1,66 @@
+/**
+ * Domain Layer - Coordinates Value Object
+ *
+ * Koordinat validasyonu ve karşılaştırma işlemleri.
+ * Immutable value object pattern.
+ */
+
+import { Coordinates } from "../../types/location.types";
+
+export class CoordinatesVO {
+    private static readonly LATITUDE_MIN = -90;
+    private static readonly LATITUDE_MAX = 90;
+    private static readonly LONGITUDE_MIN = -180;
+    private static readonly LONGITUDE_MAX = 180;
+    private static readonly DEFAULT_PRECISION = 6;
+
+    /**
+     * Koordinat validasyonu
+     */
+    static isValid(latitude: number, longitude: number): boolean {
+        if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+            return false;
+        }
+
+        return (
+            latitude >= this.LATITUDE_MIN &&
+            latitude <= this.LATITUDE_MAX &&
+            longitude >= this.LONGITUDE_MIN &&
+            longitude <= this.LONGITUDE_MAX
+        );
+    }
+
+    /**
+     * İki koordinat eşit mi (belirtilen hassasiyette)
+     */
+    static areEqual(
+        coord1: Coordinates,
+        coord2: Coordinates,
+        precision = this.DEFAULT_PRECISION
+    ): boolean {
+        const valid = [
+            coord1.latitude,
+            coord1.longitude,
+            coord2.latitude,
+            coord2.longitude,
+        ].every(Number.isFinite);
+
+        if (!valid) return false;
+
+        const epsilon = Math.pow(10, -precision);
+        return (
+            Math.abs(coord1.latitude - coord2.latitude) < epsilon &&
+            Math.abs(coord1.longitude - coord2.longitude) < epsilon
+        );
+    }
+
+    /**
+     * Koordinat object oluşturma (validasyon ile)
+     */
+    static create(latitude: number, longitude: number): Coordinates | null {
+        if (!this.isValid(latitude, longitude)) {
+            return null;
+        }
+        return { latitude, longitude };
+    }
+}

package/src/domain/value-objects/DistanceVO.ts

@@ -0,0 +1,64 @@
+/**
+ * Domain Layer - Distance Value Object
+ *
+ * Mesafe hesaplama işlemleri.
+ * Haversine formula implementation.
+ */
+
+import { Coordinates, DistanceUnit } from "../../types/location.types";
+
+export class DistanceVO {
+    private static readonly EARTH_RADIUS_KM = 6371;
+    private static readonly EARTH_RADIUS_MILES = 3959;
+    private static readonly EARTH_RADIUS_METERS = 6371000;
+
+    /**
+     * İki koordinat arasındaki mesafeyi hesapla (Haversine)
+     */
+    static calculate(
+        from: Coordinates,
+        to: Coordinates,
+        unit: DistanceUnit = "km"
+    ): number {
+        const lat1Rad = this.toRadians(from.latitude);
+        const lat2Rad = this.toRadians(to.latitude);
+        const deltaLatRad = this.toRadians(to.latitude - from.latitude);
+        const deltaLonRad = this.toRadians(to.longitude - from.longitude);
+
+        const a = this.calculateHaversineA(lat1Rad, lat2Rad, deltaLatRad, deltaLonRad);
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        return this.multiplyByRadius(c, unit);
+    }
+
+    private static toRadians(degrees: number): number {
+        return (degrees * Math.PI) / 180;
+    }
+
+    private static calculateHaversineA(
+        lat1Rad: number,
+        lat2Rad: number,
+        deltaLatRad: number,
+        deltaLonRad: number
+    ): number {
+        return (
+            Math.sin(deltaLatRad / 2) * Math.sin(deltaLatRad / 2) +
+            Math.cos(lat1Rad) *
+            Math.cos(lat2Rad) *
+            Math.sin(deltaLonRad / 2) *
+            Math.sin(deltaLonRad / 2)
+        );
+    }
+
+    private static multiplyByRadius(c: number, unit: DistanceUnit): number {
+        switch (unit) {
+            case "miles":
+                return this.EARTH_RADIUS_MILES * c;
+            case "meters":
+                return this.EARTH_RADIUS_METERS * c;
+            case "km":
+            default:
+                return this.EARTH_RADIUS_KM * c;
+        }
+    }
+}

package/src/index.ts

@@ -1,6 +1,35 @@
+// ============================================================
+// Types
+// ============================================================
 export * from "./types/location.types";
+
+// ============================================================
+// Domain Layer - Core business logic
+// ============================================================
+export * from "./domain/errors/LocationErrors";
+export * from "./domain/value-objects/CoordinatesVO";
+export * from "./domain/value-objects/DistanceVO";
+export * from "./domain/services/PermissionService";
+
+// ============================================================
+// Application Layer - Ports (Interfaces)
+// ============================================================
+export * from "./application/ports/ILoggerPort";
+export * from "./application/ports/ICachePort";
+export * from "./application/ports/ILocationPort";
+
+// ============================================================
+// Infrastructure Layer - Implementations
+// ============================================================
 export * from "./infrastructure/services/LocationService";
-export * from "./infrastructure/services/LocationWatcher";
-export * from "./infrastructure/utils/LocationUtils";
-export * from "./presentation/hooks/useLocation";
-export * from "./presentation/hooks/useLocationWatch";
+export * from "./infrastructure/services/LocationWatcherService";
+export * from "./infrastructure/services/LocationLoggerService";
+export * from "./infrastructure/repositories/LocationCache.repository";
+export * from "./infrastructure/utils/Accuracy.utils";
+export * from "./infrastructure/utils/ObjectComparison.utils";
+
+// ============================================================
+// Presentation Layer - Hooks
+// ============================================================
+export * from "./presentation/hooks/useLocationHook";
+export * from "./presentation/hooks/useLocationWatchHook";

package/src/infrastructure/repositories/LocationCache.repository.ts

@@ -0,0 +1,68 @@
+/**
+ * Infrastructure Layer - Location Cache Repository
+ *
+ * Storage repository wrapper implementing cache port.
+ * Handles cache expiration logic.
+ */
+
+import { storageRepository, unwrap } from "@umituz/react-native-design-system/storage";
+import { ICachePort, CachedLocationData } from "../../application/ports/ICachePort";
+
+export class LocationCacheRepository implements ICachePort {
+    async get(key: string): Promise<CachedLocationData | null> {
+        try {
+            const result = await storageRepository.getItem<CachedLocationData | null>(key, null);
+            return unwrap(result, null);
+        } catch {
+            return null;
+        }
+    }
+
+    async set(key: string, data: CachedLocationData): Promise<void> {
+        try {
+            await storageRepository.setItem(key, data);
+        } catch {
+            // Silent fail - cache write errors shouldn't block location fetching
+        }
+    }
+
+    async remove(key: string): Promise<void> {
+        try {
+            await storageRepository.removeItem(key);
+        } catch {
+            // Silent fail
+        }
+    }
+
+    async clear(): Promise<void> {
+        // Not implemented - cache clearing not needed for location
+        // Individual cache entries are removed when expired
+    }
+}
+
+/**
+ * Cache utilities
+ */
+export class CacheUtils {
+    /**
+     * Cache anahtarı oluştur
+     */
+    static generateKey(baseKey: string, withAddress: boolean): string {
+        const suffix = withAddress ? "_addr" : "";
+        return `location_cache_${baseKey}${suffix}`;
+    }
+
+    /**
+     * Cache yaşını hesapla (ms)
+     */
+    static getAge(cachedTimestamp: number): number {
+        return Date.now() - cachedTimestamp;
+    }
+
+    /**
+     * Cache expired mi?
+     */
+    static isExpired(cachedTimestamp: number, maxDuration: number): boolean {
+        return this.getAge(cachedTimestamp) > maxDuration;
+    }
+}

package/src/infrastructure/services/LocationLoggerService.ts

@@ -0,0 +1,58 @@
+/**
+ * Infrastructure Layer - Location Logger Service
+ *
+ * Console-based logger implementation.
+ * Uses __DEV__ checks for production optimization.
+ */
+
+import { ILoggerPort, LogLevel } from "../../application/ports/ILoggerPort";
+
+export class LocationLogger implements ILoggerPort {
+    private readonly context: string;
+    private readonly enabled: boolean;
+
+    constructor(context: string, enabled = __DEV__) {
+        this.context = context;
+        this.enabled = enabled;
+    }
+
+    private log(level: LogLevel, message: string, ...args: unknown[]): void {
+        if (!this.enabled) return;
+
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [${level}] [${this.context}]`;
+
+        switch (level) {
+            case LogLevel.DEBUG:
+            case LogLevel.INFO:
+                console.log(prefix, message, ...args);
+                break;
+            case LogLevel.WARN:
+                console.warn(prefix, message, ...args);
+                break;
+            case LogLevel.ERROR:
+                console.error(prefix, message, ...args);
+                break;
+        }
+    }
+
+    debug(message: string, context?: string): void {
+        const ctx = context || this.context;
+        this.log(LogLevel.DEBUG, message, `[${ctx}]`);
+    }
+
+    info(message: string, context?: string): void {
+        const ctx = context || this.context;
+        this.log(LogLevel.INFO, message, `[${ctx}]`);
+    }
+
+    warn(message: string, context?: string): void {
+        const ctx = context || this.context;
+        this.log(LogLevel.WARN, message, `[${ctx}]`);
+    }
+
+    error(message: string, error?: unknown, context?: string): void {
+        const ctx = context || this.context;
+        this.log(LogLevel.ERROR, message, `[${ctx}]`, error);
+    }
+}