@ajuarezso/capacitor-native-location-auth 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anthony Juarez Solis
+
+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/Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "NativeLocationAuth",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "NativeLocationAuth",
+            targets: ["NativeLocationAuthPlugin"])
+    ],
+    dependencies: [
+        // Rango amplio para coexistir con plugins que aún están en
+        // capacitor-swift-pm 7.x (caso de @capacitor-community/background-geolocation
+        // que sigue pinneado a 7.0.0..<8.0.0). El plugin custom funciona con
+        // las APIs base de Capacitor que existen en ambas versiones.
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", "7.0.0"..<"9.0.0")
+    ],
+    targets: [
+        .target(
+            name: "NativeLocationAuthPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm"),
+            ],
+            path: "ios/Sources/NativeLocationAuthPlugin"
+        )
+    ]
+)

package/README.md

@@ -0,0 +1,155 @@
+# @ajuarezso/capacitor-native-location-auth
+
+Capacitor plugin to distinguish the **4 real levels of location authorization** (`notDetermined` / `whenInUse` / `always` / `denied`) on iOS and Android.
+
+Fills the gap left by [`@capacitor/geolocation`](https://capacitorjs.com/docs/apis/geolocation), which only reports generic `granted` / `denied` / `prompt` without distinguishing foreground vs background.
+
+Designed for apps that need to build a **2-step educational permission flow**:
+1. Ask user for `whenInUse` first (foreground only) — iOS shows a simple dialog with no "Always" option mixed in.
+2. After foreground granted, ask for `always` (background) — iOS shows a dedicated upgrade dialog ("Allow always" vs "Keep while using").
+
+This is the UX flow Apple recommends and that apps like Uber, Rappi, and DoorDash use.
+
+## Install
+
+```bash
+npm install @ajuarezso/capacitor-native-location-auth
+npx cap sync
+```
+
+## iOS Setup
+
+In `ios/App/App/Info.plist`, ensure you have both keys:
+
+```xml
+<key>NSLocationWhenInUseUsageDescription</key>
+<string>Your app needs location to ...</string>
+<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
+<string>Your app needs background location to ...</string>
+```
+
+If you need background tracking, also add `location` to `UIBackgroundModes`.
+
+## Android Setup
+
+In `android/app/src/main/AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+```
+
+`ACCESS_BACKGROUND_LOCATION` is only needed for Android 10+ (API 29+).
+
+## API
+
+### Types
+
+```ts
+type LocationAuthStatus = 'notDetermined' | 'whenInUse' | 'always' | 'denied';
+
+interface LocationAuthStatusResult {
+  status: LocationAuthStatus;
+}
+```
+
+### `getStatus(): Promise<LocationAuthStatusResult>`
+
+Returns the current authorization level without prompting.
+
+```ts
+import { NativeLocationAuth } from '@ajuarezso/capacitor-native-location-auth';
+
+const { status } = await NativeLocationAuth.getStatus();
+// 'notDetermined' | 'whenInUse' | 'always' | 'denied'
+```
+
+### `requestWhenInUse(): Promise<LocationAuthStatusResult>`
+
+Requests **foreground-only** authorization ("While using the app").
+
+- **iOS**: calls `CLLocationManager.requestWhenInUseAuthorization()`. Shows a system dialog with only `whenInUse` / `oneTime` / `deny` — **not** the combined 4-option dialog that `Geolocation.requestPermissions()` would show.
+- **Android**: requests `ACCESS_FINE_LOCATION`.
+
+If status is already `whenInUse` or `always`, resolves immediately without showing a dialog. If permanently denied, returns `'denied'` and you should direct user to Settings.
+
+```ts
+const { status } = await NativeLocationAuth.requestWhenInUse();
+if (status === 'whenInUse') {
+  // Now you can ask for 'always' separately
+}
+```
+
+### `requestAlways(): Promise<LocationAuthStatusResult>`
+
+Requests **background** authorization ("Always allow"). Call this **after** `requestWhenInUse()` succeeded.
+
+- **iOS**: calls `CLLocationManager.requestAlwaysAuthorization()`. If status is `whenInUse`, iOS shows the upgrade dialog ("Allow always" vs "Keep while using"). If user already denied, no dialog is shown — only Settings can change it.
+- **Android 10+**: requests `ACCESS_BACKGROUND_LOCATION` with its own runtime dialog ("Allow all the time" vs "Allow only while using").
+- **Android <10**: resolves immediately with `'always'` because background isn't a separate permission below API 29.
+
+```ts
+const { status } = await NativeLocationAuth.requestAlways();
+if (status === 'always') {
+  // Start background tracking
+}
+```
+
+## Complete 2-step Flow Example
+
+```ts
+import { NativeLocationAuth } from '@ajuarezso/capacitor-native-location-auth';
+
+async function enableBackgroundLocation() {
+  const initial = await NativeLocationAuth.getStatus();
+
+  if (initial.status === 'always') {
+    // Already authorized for background; start tracking
+    return startTracking();
+  }
+
+  if (initial.status === 'denied') {
+    // Permanently denied; direct user to Settings
+    return openSettings();
+  }
+
+  // Step 1: ask for foreground
+  await showEducationalModal({ title: 'Enable location', cta: 'Continue' });
+  const fg = await NativeLocationAuth.requestWhenInUse();
+  if (fg.status === 'denied') return openSettings();
+
+  // Step 2: ask for background
+  await showEducationalModal({ title: 'One more permission', cta: 'Continue' });
+  const bg = await NativeLocationAuth.requestAlways();
+  if (bg.status === 'always') {
+    startTracking();
+  } else {
+    // User kept only whenInUse — start tracking anyway,
+    // they'll just need to keep the app open
+    startTracking({ foregroundOnly: true });
+  }
+}
+```
+
+## Why This Plugin?
+
+The official `@capacitor/geolocation` plugin reports permission as a generic `granted` / `denied` — you cannot tell whether the user has `whenInUse` or `always`. This is fine for apps that only need foreground location, but breaks for apps that need background tracking (delivery drivers, fitness apps, geofencing, etc.).
+
+Other plugins:
+
+| Plugin | Distinguishes whenInUse vs always? | Cost |
+|---|---|---|
+| `@capacitor/geolocation` | ❌ | Free |
+| `@capacitor-community/background-geolocation` | ❌ | Free |
+| `@capgo/background-geolocation` | ❌ | Free |
+| `@transistorsoft/capacitor-background-geolocation` | ✅ | $300/year for Android production |
+| **`@ajuarezso/capacitor-native-location-auth`** | ✅ | **Free** |
+
+## Platforms
+
+- iOS 14+
+- Android API 24+ (Android 7+)
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/android/build.gradle

@@ -0,0 +1,52 @@
+ext {
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.25"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.masterpedidos.nativelocationauth"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation project(':capacitor-android')
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/masterpedidos/nativelocationauth/NativeLocationAuthPlugin.kt

@@ -0,0 +1,133 @@
+package com.masterpedidos.nativelocationauth
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import com.getcapacitor.JSObject
+import com.getcapacitor.PermissionState
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+
+@CapacitorPlugin(
+    name = "NativeLocationAuth",
+    permissions = [
+        Permission(
+            alias = "whenInUse",
+            strings = [Manifest.permission.ACCESS_FINE_LOCATION]
+        ),
+        Permission(
+            alias = "background",
+            strings = [Manifest.permission.ACCESS_BACKGROUND_LOCATION]
+        )
+    ]
+)
+class NativeLocationAuthPlugin : Plugin() {
+
+    /**
+     * Distingue los 4 niveles reales de autorización combinando los 2 permisos
+     * Android. Mapping a las strings que el TS espera (consistente con iOS):
+     *   - ACCESS_FINE_LOCATION granted + ACCESS_BACKGROUND_LOCATION granted  → "always"
+     *   - ACCESS_FINE_LOCATION granted + ACCESS_BACKGROUND_LOCATION denied   → "whenInUse"
+     *   - ACCESS_FINE_LOCATION denied (rechazo permanente)                   → "denied"
+     *   - ACCESS_FINE_LOCATION nunca preguntado (primera vez)                → "notDetermined"
+     *
+     * Android < 10 (API 29) NO tiene ACCESS_BACKGROUND_LOCATION como permiso
+     * separado — si tiene FINE granted, automáticamente puede tracker en
+     * background, mapeado a "always" para compat con el flow.
+     */
+    @PluginMethod
+    fun getStatus(call: PluginCall) {
+        call.resolve(JSObject().put("status", currentStatusString()))
+    }
+
+    /**
+     * Pide ACCESS_FINE_LOCATION (foreground). Equivalente Android del
+     * requestWhenInUseAuthorization() de iOS. Si ya está granted, resuelve
+     * inmediatamente; si fue rechazado permanente ("no preguntar más"),
+     * retorna "denied" para que el frontend dirija al user a Settings.
+     */
+    @PluginMethod
+    fun requestWhenInUse(call: PluginCall) {
+        val fineGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        if (fineGranted) {
+            call.resolve(JSObject().put("status", currentStatusString()))
+            return
+        }
+        requestPermissionForAlias("whenInUse", call, "whenInUsePermsCallback")
+    }
+
+    /**
+     * Pide ACCESS_BACKGROUND_LOCATION (Android 10+ / API 29+). Apple's
+     * requestAlwaysAuthorization() equivalente. Requiere que FINE ya esté
+     * granted antes (Android lo enforcea). En Android < 10 retorna "always"
+     * inmediato porque background no es permiso separado.
+     */
+    @PluginMethod
+    fun requestAlways(call: PluginCall) {
+        // Android < 10: FINE granted implica background tracking — no hay
+        // permiso de background separado.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            call.resolve(JSObject().put("status", currentStatusString()))
+            return
+        }
+        val fineGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        if (!fineGranted) {
+            // Android rechazaría el request de background si FINE no está granted
+            call.reject("Necesitas conceder primero el permiso de ubicación en uso")
+            return
+        }
+        val bgGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_BACKGROUND_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        if (bgGranted) {
+            call.resolve(JSObject().put("status", "always"))
+            return
+        }
+        requestPermissionForAlias("background", call, "backgroundPermsCallback")
+    }
+
+    @PermissionCallback
+    private fun whenInUsePermsCallback(call: PluginCall) {
+        call.resolve(JSObject().put("status", currentStatusString()))
+    }
+
+    @PermissionCallback
+    private fun backgroundPermsCallback(call: PluginCall) {
+        call.resolve(JSObject().put("status", currentStatusString()))
+    }
+
+    private fun currentStatusString(): String {
+        val fineStatus = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        )
+        if (fineStatus != PackageManager.PERMISSION_GRANTED) {
+            // No podemos distinguir 100% entre "nunca preguntado" y "rechazado
+            // permanente" sin estado persistido. El frontend pedirá permiso y
+            // si falla mostrará toast "ve a Settings".
+            return "notDetermined"
+        }
+        // FINE granted. Background solo aplica en Android 10+.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            val backgroundStatus = ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.ACCESS_BACKGROUND_LOCATION
+            )
+            return if (backgroundStatus == PackageManager.PERMISSION_GRANTED) "always" else "whenInUse"
+        }
+        // Pre-Android 10: FINE granted implica background tracking permitido
+        return "always"
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+export type LocationAuthStatus = 'notDetermined' | 'whenInUse' | 'always' | 'denied';
+export interface LocationAuthStatusResult {
+    status: LocationAuthStatus;
+}
+export interface NativeLocationAuthPlugin {
+    /**
+     * Retorna el nivel exacto de autorización de location.
+     *  - `notDetermined`: nunca preguntado al user.
+     *  - `whenInUse`: foreground autorizado, background NO.
+     *  - `always`: foreground + background autorizados (Android: `ACCESS_BACKGROUND_LOCATION`; iOS: `authorizedAlways`).
+     *  - `denied`: rechazado o restricted.
+     */
+    getStatus(): Promise<LocationAuthStatusResult>;
+    /**
+     * Solicita autorización solo de foreground ("Mientras la app esté en uso").
+     *
+     * - iOS: llama a `CLLocationManager.requestWhenInUseAuthorization()`. Muestra
+     *   un dialog con SOLO opciones whenInUse/oneTime/deny, sin la opción "Always"
+     *   mezclada (a diferencia de `Geolocation.requestPermissions()` de Capacitor
+     *   que pide el nivel declarado en Info.plist con dialog combinado de 4 opciones).
+     * - Android: pide `ACCESS_FINE_LOCATION` con UI estándar.
+     *
+     * Si el estado ya es `whenInUse` o `always`, resuelve inmediato sin mostrar
+     * dialog. Si fue rechazado permanente, retorna `'denied'` y el frontend
+     * debe dirigir al user a Settings.
+     */
+    requestWhenInUse(): Promise<LocationAuthStatusResult>;
+    /**
+     * Solicita autorización de background ("Permitir siempre"). Llamar SOLO
+     * después de tener `whenInUse` autorizado.
+     *
+     * - iOS: llama a `CLLocationManager.requestAlwaysAuthorization()`. Si el
+     *   estado es `whenInUse`, iOS muestra el dialog de upgrade (Always vs
+     *   Keep WhenInUse). Si el user ya rechazó antes, NO se muestra dialog y
+     *   retorna el estado actual — solo Settings puede cambiarlo.
+     * - Android 10+ (API 29+): pide `ACCESS_BACKGROUND_LOCATION` con dialog
+     *   propio. El user puede elegir "Permitir todo el tiempo" o "Permitir
+     *   solo mientras se usa la app".
+     * - Android < 10: resuelve inmediato con `always` porque background no es
+     *   un permiso separado en API < 29.
+     */
+    requestAlways(): Promise<LocationAuthStatusResult>;
+}
+export declare const NativeLocationAuth: NativeLocationAuthPlugin;

package/dist/index.js

@@ -0,0 +1,2 @@
+import { registerPlugin } from '@capacitor/core';
+export const NativeLocationAuth = registerPlugin('NativeLocationAuth');

package/ios/Sources/NativeLocationAuthPlugin/NativeLocationAuthPlugin.swift

@@ -0,0 +1,113 @@
+import Foundation
+import Capacitor
+import CoreLocation
+
+@objc(NativeLocationAuthPlugin)
+public class NativeLocationAuthPlugin: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelegate {
+    public let identifier = "NativeLocationAuthPlugin"
+    public let jsName = "NativeLocationAuth"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestWhenInUse", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestAlways", returnType: CAPPluginReturnPromise),
+    ]
+
+    private let locationManager = CLLocationManager()
+    private var pendingCall: CAPPluginCall?
+
+    override public func load() {
+        locationManager.delegate = self
+    }
+
+    /// Distingue los 4 niveles reales de `CLAuthorizationStatus` y los expone
+    /// al JS como strings consistentes con Android. Apple deprecó la API estática
+    /// `CLLocationManager.authorizationStatus()` en iOS 14 — usar la propiedad
+    /// de instancia.
+    @objc func getStatus(_ call: CAPPluginCall) {
+        call.resolve(["status": currentStatusString()])
+    }
+
+    /// Pide `WhenInUseAuthorization` específicamente. iOS muestra el dialog
+    /// SOLO con opciones "Mientras la app esté en uso" / "Solo esta vez" /
+    /// "No permitir" — sin la opción "Permitir siempre" mezclada (a diferencia
+    /// de `Geolocation.requestPermissions()` de Capacitor que pide el nivel
+    /// declarado en Info.plist y muestra el dialog combinado).
+    /// Si el estado actual ya es `whenInUse` o `always`, no muestra dialog y
+    /// resuelve inmediatamente con el estado actual.
+    @objc func requestWhenInUse(_ call: CAPPluginCall) {
+        if pendingCall != nil {
+            call.reject("Otra solicitud de autorización ya está en curso")
+            return
+        }
+        let currentStatus = currentAuthorizationStatus()
+        if currentStatus != .notDetermined {
+            // Ya tiene una decisión — no se muestra dialog, resolvemos directo
+            call.resolve(["status": currentStatusString()])
+            return
+        }
+        pendingCall = call
+        call.keepAlive = true
+        DispatchQueue.main.async { [weak self] in
+            self?.locationManager.requestWhenInUseAuthorization()
+        }
+    }
+
+    /// Pide `AlwaysAuthorization`. Si el estado actual es `whenInUse`, iOS
+    /// muestra el dialog para upgrade a "Permitir siempre" vs "Mantener
+    /// mientras esté en uso". Si está en `notDetermined`, iOS pide always
+    /// desde cero (sin pasar por whenInUse). Si ya es `always`, resuelve
+    /// inmediato.
+    @objc func requestAlways(_ call: CAPPluginCall) {
+        if pendingCall != nil {
+            call.reject("Otra solicitud de autorización ya está en curso")
+            return
+        }
+        let currentStatus = currentAuthorizationStatus()
+        if currentStatus == .authorizedAlways {
+            call.resolve(["status": "always"])
+            return
+        }
+        if currentStatus == .denied || currentStatus == .restricted {
+            // Apple no permite re-pedir si el user rechazó — solo Settings
+            call.resolve(["status": "denied"])
+            return
+        }
+        pendingCall = call
+        call.keepAlive = true
+        DispatchQueue.main.async { [weak self] in
+            self?.locationManager.requestAlwaysAuthorization()
+        }
+    }
+
+    /// Delegate callback — iOS lo dispara cuando el usuario responde un
+    /// dialog de autorización (o cuando cambia el permiso desde Settings).
+    /// Resolvemos el pendingCall con el nuevo estado.
+    public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        guard let call = pendingCall else { return }
+        // Si todavía es notDetermined, iOS aún no terminó de procesar — esperamos
+        // al próximo callback. Eso pasa la primera vez que se llama con el
+        // dialog visible (el initial event antes del user input).
+        let status = currentAuthorizationStatus()
+        if status == .notDetermined { return }
+        pendingCall = nil
+        call.resolve(["status": currentStatusString()])
+    }
+
+    private func currentAuthorizationStatus() -> CLAuthorizationStatus {
+        if #available(iOS 14.0, *) {
+            return locationManager.authorizationStatus
+        } else {
+            return CLLocationManager.authorizationStatus()
+        }
+    }
+
+    private func currentStatusString() -> String {
+        switch currentAuthorizationStatus() {
+        case .notDetermined:    return "notDetermined"
+        case .authorizedWhenInUse: return "whenInUse"
+        case .authorizedAlways: return "always"
+        case .denied, .restricted: return "denied"
+        @unknown default:       return "denied"
+        }
+    }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@ajuarezso/capacitor-native-location-auth",
+  "version": "1.0.0",
+  "description": "Capacitor plugin to distinguish the 4 real levels of location authorization (notDetermined / whenInUse / always / denied) on iOS and Android. Fills the gap of @capacitor/geolocation which only reports generic granted/denied without distinguishing foreground vs background.",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "ios/Sources/",
+    "android/src/",
+    "android/build.gradle",
+    "Package.swift",
+    "README.md",
+    "LICENSE"
+  ],
+  "author": "Anthony Juarez Solis <anthonyjuarezsolis@icloud.com>",
+  "license": "MIT",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "ios",
+    "android",
+    "location",
+    "geolocation",
+    "permissions",
+    "authorization",
+    "background-location",
+    "whenInUse",
+    "always",
+    "CLLocationManager"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthonyjuarezsolis/capacitor-native-location-auth.git"
+  },
+  "bugs": {
+    "url": "https://github.com/anthonyjuarezsolis/capacitor-native-location-auth/issues"
+  },
+  "homepage": "https://github.com/anthonyjuarezsolis/capacitor-native-location-auth#readme",
+  "scripts": {
+    "build": "rm -rf dist && tsc"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "devDependencies": {
+    "@capacitor/core": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^7.0.0 || ^8.0.0"
+  }
+}