@nitra/geolocation 7.1.1

package/CapacitorGeolocation.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorGeolocation'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.dependency 'IONGeolocationLib', spec='~> 1.0'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,34 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "GeolocationCapacitor",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(
+            name: "GeolocationCapacitor",
+            targets: ["GeolocationPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", branch: "main")
+    ],
+    targets: [
+        .binaryTarget(
+            name: "IONGeolocationLib",
+            url: "https://github.com/ionic-team/ion-ios-geolocation/releases/download/1.0.0/IONGeolocationLib.zip",
+            checksum: "b117d3681a947f5d367e79abdb3bfc9abf7ab070ea5279d7da634ddd2d54ffdb" // sha-256
+        ),
+        .target(
+            name: "GeolocationPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm"),
+                "IONGeolocationLib"
+            ],
+            path: "ios/Sources/GeolocationPlugin"),
+        .testTarget(
+            name: "GeolocationPluginTests",
+            dependencies: ["GeolocationPlugin"],
+            path: "ios/Tests/GeolocationTests")
+    ]
+)

package/README.md

@@ -0,0 +1,238 @@
+# @nitra/geolocation
+
+The Geolocation API provides simple methods for getting and tracking the current position of the device using GPS, along with altitude, heading, and speed information if available.
+
+## Install
+
+```bash
+npm install @nitra/geolocation
+npx cap sync
+```
+
+## iOS
+
+Apple requires privacy descriptions to be specified in `Info.plist` for location information:
+
+- `NSLocationAlwaysAndWhenInUseUsageDescription` (`Privacy - Location Always and When In Use Usage Description`)
+- `NSLocationWhenInUseUsageDescription` (`Privacy - Location When In Use Usage Description`)
+
+Read about [Configuring `Info.plist`](https://capacitorjs.com/docs/ios/configuration#configuring-infoplist) in the [iOS Guide](https://capacitorjs.com/docs/ios) for more information on setting iOS permissions in Xcode
+
+## Android
+
+This plugin requires the following permissions be added to your `AndroidManifest.xml`:
+
+```xml
+<!-- Geolocation Plugin -->
+<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+<uses-feature android:name="android.hardware.location.gps" />
+```
+
+The first two permissions ask for location data, both fine and coarse, and the last line is optional but necessary if your app _requires_ GPS to function. You may leave it out, though keep in mind that this may mean your app is installed on devices lacking GPS hardware.
+
+Read about [Setting Permissions](https://capacitorjs.com/docs/android/configuration#setting-permissions) in the [Android Guide](https://capacitorjs.com/docs/android) for more information on setting Android permissions.
+
+
+## API
+
+<docgen-index>
+
+* [`getCurrentPosition(...)`](#getcurrentposition)
+* [`watchPosition(...)`](#watchposition)
+* [`clearWatch(...)`](#clearwatch)
+* [`checkPermissions()`](#checkpermissions)
+* [`requestPermissions(...)`](#requestpermissions)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+For list of error codes, see [Errors](#errors)
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### getCurrentPosition(...)
+
+```typescript
+getCurrentPosition(options?: PositionOptions | undefined) => Promise<Position>
+```
+
+Get the current GPS location of the device
+
+| Param         | Type                                                        |
+| ------------- | ----------------------------------------------------------- |
+| **`options`** | <code><a href="#positionoptions">PositionOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#position">Position</a>&gt;</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### watchPosition(...)
+
+```typescript
+watchPosition(options: PositionOptions, callback: WatchPositionCallback) => Promise<CallbackID>
+```
+
+Set up a watch for location changes. Note that watching for location changes
+can consume a large amount of energy. Be smart about listening only when you need to.
+
+| Param          | Type                                                                    |
+| -------------- | ----------------------------------------------------------------------- |
+| **`options`**  | <code><a href="#positionoptions">PositionOptions</a></code>             |
+| **`callback`** | <code><a href="#watchpositioncallback">WatchPositionCallback</a></code> |
+
+**Returns:** <code>Promise&lt;string&gt;</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### clearWatch(...)
+
+```typescript
+clearWatch(options: ClearWatchOptions) => Promise<void>
+```
+
+Clear a given watch
+
+| Param         | Type                                                            |
+| ------------- | --------------------------------------------------------------- |
+| **`options`** | <code><a href="#clearwatchoptions">ClearWatchOptions</a></code> |
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### checkPermissions()
+
+```typescript
+checkPermissions() => Promise<PermissionStatus>
+```
+
+Check location permissions.  Will throw if system location services are disabled.
+
+**Returns:** <code>Promise&lt;<a href="#permissionstatus">PermissionStatus</a>&gt;</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### requestPermissions(...)
+
+```typescript
+requestPermissions(permissions?: GeolocationPluginPermissions | undefined) => Promise<PermissionStatus>
+```
+
+Request location permissions.  Will throw if system location services are disabled.
+
+Not available on web.
+
+| Param             | Type                                                                                  |
+| ----------------- | ------------------------------------------------------------------------------------- |
+| **`permissions`** | <code><a href="#geolocationpluginpermissions">GeolocationPluginPermissions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#permissionstatus">PermissionStatus</a>&gt;</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### Position
+
+| Prop            | Type                                                                                                                                                                                | Description                                             | Since |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ----- |
+| **`timestamp`** | <code>number</code>                                                                                                                                                                 | Creation timestamp for coords                           | 1.0.0 |
+| **`coords`**    | <code>{ latitude: number; longitude: number; accuracy: number; altitudeAccuracy: number \| null; altitude: number \| null; speed: number \| null; heading: number \| null; }</code> | The GPS coordinates along with the accuracy of the data | 1.0.0 |
+
+
+#### PositionOptions
+
+| Prop                        | Type                 | Description                                                                                                                                                                                                                                                                                                     | Default            | Since |
+| --------------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- |
+| **`enableHighAccuracy`**    | <code>boolean</code> | High accuracy mode (such as GPS, if available) On Android 12+ devices it will be ignored if users didn't grant ACCESS_FINE_LOCATION permissions (can be checked with location alias).                                                                                                                           | <code>false</code> | 1.0.0 |
+| **`timeout`**               | <code>number</code>  | The maximum wait time in milliseconds for location updates. In Android, since version 7.1.0 of the plugin, it is also used to determine the interval of location updates for `watchPosition`.                                                                                                                   | <code>10000</code> | 1.0.0 |
+| **`maximumAge`**            | <code>number</code>  | The maximum age in milliseconds of a possible cached position that is acceptable to return                                                                                                                                                                                                                      | <code>0</code>     | 1.0.0 |
+| **`minimumUpdateInterval`** | <code>number</code>  | The minumum update interval for location updates. If location updates are available faster than this interval then an update will only occur if the minimum update interval has expired since the last location update. This parameter is only available for Android. It has no effect on iOS or Web platforms. | <code>5000</code>  | 6.1.0 |
+
+
+#### ClearWatchOptions
+
+| Prop     | Type                                              |
+| -------- | ------------------------------------------------- |
+| **`id`** | <code><a href="#callbackid">CallbackID</a></code> |
+
+
+#### PermissionStatus
+
+| Prop                 | Type                                                        | Description                                                                                                                                                                                                                                                                                                                                                        | Since |
+| -------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----- |
+| **`location`**       | <code><a href="#permissionstate">PermissionState</a></code> | Permission state for location alias. On Android it requests/checks both ACCESS_COARSE_LOCATION and ACCESS_FINE_LOCATION permissions. On iOS and web it requests/checks location permission.                                                                                                                                                                        | 1.0.0 |
+| **`coarseLocation`** | <code><a href="#permissionstate">PermissionState</a></code> | Permission state for coarseLocation alias. On Android it requests/checks ACCESS_COARSE_LOCATION. On Android 12+, users can choose between Approximate location (ACCESS_COARSE_LOCATION) or Precise location (ACCESS_FINE_LOCATION), so this alias can be used if the app doesn't need high accuracy. On iOS and web it will have the same value as location alias. | 1.2.0 |
+
+
+#### GeolocationPluginPermissions
+
+| Prop              | Type                                     |
+| ----------------- | ---------------------------------------- |
+| **`permissions`** | <code>GeolocationPermissionType[]</code> |
+
+
+### Type Aliases
+
+
+#### WatchPositionCallback
+
+<code>(position: <a href="#position">Position</a> | null, err?: any): void</code>
+
+
+#### CallbackID
+
+<code>string</code>
+
+
+#### PermissionState
+
+<code>'prompt' | 'prompt-with-rationale' | 'granted' | 'denied'</code>
+
+
+#### GeolocationPermissionType
+
+<code>'location' | 'coarseLocation'</code>
+
+</docgen-api>
+
+### Errors
+
+The plugin returns specific errors with specific codes on native Android and iOS. Web does not follow this standard for errors.
+
+The following table list all the plugin errors:
+
+| Error code           | Platform(s)  | Message                                  |
+| -------------------- | ------------ | ---------------------------------------- |
+| OS-PLUG-GLOC-0002 | Android, iOS | There was en error trying to obtain the location. |
+| OS-PLUG-GLOC-0003 | Android, iOS | Location permission request was denied. |
+| OS-PLUG-GLOC-0004 | iOS          | The 'getCurrentPosition' input parameters aren't valid. |
+| OS-PLUG-GLOC-0005 | iOS          | The 'watchPosition' input parameters aren't valid. |
+| OS-PLUG-GLOC-0006 | iOS          | The 'clearWatch' input parameters aren't valid. |
+| OS-PLUG-GLOC-0007 | Android, iOS | Location services are not enabled. |
+| OS-PLUG-GLOC-0008 | iOS          | Application's use of location services was restricted. |
+| OS-PLUG-GLOC-0009 | Android      | Request to enable location was denied. |
+| OS-PLUG-GLOC-0010 | Android      | Could not obtain location in time. Try with a higher timeout. |
+| OS-PLUG-GLOC-0011 | Android      | Timeout needs to be a positive value. |
+| OS-PLUG-GLOC-0012 | Android      | WatchId not found. |
+| OS-PLUG-GLOC-0013 | Android      | WatchId needs to be provided. |
+| OS-PLUG-GLOC-0014 | Android      | Google Play Services error user resolvable. |
+| OS-PLUG-GLOC-0015 | Android      | Google Play Services error. |
+| OS-PLUG-GLOC-0016 | Android      | Location settings error. |

package/android/build.gradle

@@ -0,0 +1,72 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+    playServicesLocationVersion = project.hasProperty('playServicesLocationVersion') ? rootProject.ext.playServicesLocationVersion : '21.3.0'
+}
+
+buildscript {
+    ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '1.9.24'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.1'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.capacitorjs.plugins.geolocation"
+    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
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation("io.ionic.libs:iongeolocation-android:1.0.0")
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+
+    implementation 'com.google.code.gson:gson:2.10.1'
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.6.4")
+    implementation "com.google.android.gms:play-services-location:$playServicesLocationVersion"
+
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/kotlin/com/capacitorjs/plugins/geolocation/GeolocationErrors.kt

@@ -0,0 +1,71 @@
+package com.capacitorjs.plugins.geolocation
+
+/**
+ * Object with plugin errors
+ */
+object GeolocationErrors {
+
+    private fun formatErrorCode(number: Int): String {
+        return "OS-PLUG-GLOC-" + number.toString().padStart(4, '0')
+    }
+
+    data class ErrorInfo(
+        val code: String,
+        val message: String
+    )
+
+    val POSITION_UNAVAILABLE = ErrorInfo(
+        code = formatErrorCode(2),
+        message = "There was en error trying to obtain the location."
+    )
+
+    val LOCATION_PERMISSIONS_DENIED = ErrorInfo(
+        code = formatErrorCode(3),
+        message = "Location permission request was denied."
+    )
+
+    val LOCATION_DISABLED = ErrorInfo(
+        code = formatErrorCode(7),
+        message = "Location services are not enabled."
+    )
+
+    val LOCATION_ENABLE_REQUEST_DENIED = ErrorInfo(
+        code = formatErrorCode(9),
+        message = "Request to enable location was denied."
+    )
+
+    val GET_LOCATION_TIMEOUT = ErrorInfo(
+        code = formatErrorCode(10),
+        message = "Could not obtain location in time. Try with a higher timeout."
+    )
+
+    val INVALID_TIMEOUT = ErrorInfo(
+        code = formatErrorCode(11),
+        message = "Timeout needs to be a positive value."
+    )
+
+    val WATCH_ID_NOT_FOUND = ErrorInfo(
+        code = formatErrorCode(12),
+        message = "WatchId not found."
+    )
+
+    val WATCH_ID_NOT_PROVIDED = ErrorInfo(
+        code = formatErrorCode(13),
+        message = "WatchId needs to be provided."
+    )
+
+    val GOOGLE_SERVICES_RESOLVABLE = ErrorInfo(
+        code = formatErrorCode(14),
+        message = "Google Play Services error user resolvable."
+    )
+
+    val GOOGLE_SERVICES_ERROR = ErrorInfo(
+        code = formatErrorCode(15),
+        message = "Google Play Services error."
+    )
+
+    val LOCATION_SETTINGS_ERROR = ErrorInfo(
+        code = formatErrorCode(16),
+        message = "Location settings error."
+    )
+}

package/android/src/main/kotlin/com/capacitorjs/plugins/geolocation/GeolocationPlugin.kt

@@ -0,0 +1,338 @@
+package com.capacitorjs.plugins.geolocation
+
+import android.Manifest
+import android.os.Build
+import androidx.activity.result.contract.ActivityResultContracts
+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
+import com.google.android.gms.location.LocationServices
+import io.ionic.libs.iongeolocationlib.controller.IONGLOCController
+import io.ionic.libs.iongeolocationlib.model.IONGLOCException
+import io.ionic.libs.iongeolocationlib.model.IONGLOCLocationOptions
+import io.ionic.libs.iongeolocationlib.model.IONGLOCLocationResult
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+@CapacitorPlugin(
+    name = "Geolocation",
+    permissions = [Permission(
+        strings = [Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION],
+        alias = GeolocationPlugin.LOCATION_ALIAS
+    ), Permission(
+        strings = [Manifest.permission.ACCESS_COARSE_LOCATION],
+        alias = GeolocationPlugin.COARSE_LOCATION_ALIAS
+    )]
+)
+class GeolocationPlugin : Plugin() {
+
+    private lateinit var controller: IONGLOCController
+    private lateinit var coroutineScope: CoroutineScope
+    private val watchingCalls: MutableMap<String, PluginCall> = mutableMapOf()
+
+    companion object {
+        const val LOCATION_ALIAS: String = "location"
+        const val COARSE_LOCATION_ALIAS: String = "coarseLocation"
+    }
+
+    override fun load() {
+        super.load()
+
+        coroutineScope = CoroutineScope(Dispatchers.Main)
+        val activityLauncher = activity.registerForActivityResult(
+            ActivityResultContracts.StartIntentSenderForResult()
+        ) { result ->
+            CoroutineScope(Dispatchers.Main).launch {
+                controller.onResolvableExceptionResult(result.resultCode)
+            }
+        }
+
+        this.controller = IONGLOCController(
+            LocationServices.getFusedLocationProviderClient(context),
+            activityLauncher
+        )
+
+    }
+
+    override fun handleOnDestroy() {
+        super.handleOnDestroy()
+        coroutineScope.cancel()
+    }
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        checkLocationState(call) { super.checkPermissions(call) }
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        checkLocationState(call) { super.requestPermissions(call) }
+    }
+
+    /**
+     * Helper function to determine if location services are enabled or not
+     * @param call the PluginCall to use in case we want to send an error
+     * @param onLocationEnabled lambda function to use in case location services are enabled
+     */
+    private fun checkLocationState(call: PluginCall, onLocationEnabled: () -> Unit) {
+        if (controller.areLocationServicesEnabled(context)) {
+            onLocationEnabled()
+        } else {
+            call.sendError(GeolocationErrors.LOCATION_DISABLED)
+        }
+    }
+
+    /**
+     * Checks location permission state, requesting them if necessary.
+     * If not, calls getPosition to get the device's position
+     * @param call the plugin call
+     */
+    @PluginMethod
+    fun getCurrentPosition(call: PluginCall) {
+        handlePermissionRequest(call, "completeCurrentPosition") { getPosition(call) }
+    }
+
+    /**
+     * Checks location permission state, requesting them if necessary.
+     * If not, calls startWatch to start getting location updates
+     * @param call the plugin call
+     */
+    @PluginMethod(returnType = PluginMethod.RETURN_CALLBACK)
+    fun watchPosition(call: PluginCall) {
+        handlePermissionRequest(call, "completeWatchPosition") { startWatch(call) }
+    }
+
+    /**
+     * Helper function to determine if a permission is granted or not and request it if necessary
+     * @param call the PluginCall to use in case we want to send an error
+     * @param callbackName a string identifying the callback to call once the permission prompt is answered
+     * @param onPermissionGranted lambda function to use in case the permission is enabled
+     */
+    private fun handlePermissionRequest(
+        call: PluginCall,
+        callbackName: String,
+        onPermissionGranted: () -> Unit
+    ) {
+        val alias = getAlias(call)
+        if (getPermissionState(alias) != PermissionState.GRANTED) {
+            requestPermissionForAlias(alias, call, callbackName)
+        } else {
+            onPermissionGranted()
+        }
+    }
+
+    /**
+     * Completes the getCurrentPosition plugin call after a permission request
+     * @see .getCurrentPosition
+     * @param call the plugin call
+     */
+    @PermissionCallback
+    private fun completeCurrentPosition(call: PluginCall) {
+        handlePermissionResult(call) { getPosition(call) }
+    }
+
+    /**
+     * Completes the watchPosition plugin call after a permission request
+     * @see .startWatch
+     * @param call the plugin call
+     */
+    @PermissionCallback
+    private fun completeWatchPosition(call: PluginCall) {
+        handlePermissionResult(call) { startWatch(call) }
+    }
+
+    /**
+     * Helper function to handle the result of a location permission request
+     * @param call the PluginCall to use in case we want to send an error
+     * @param onPermissionGranted lambda function to use in case the permission was granted
+     */
+    private fun handlePermissionResult(call: PluginCall, onPermissionGranted: () -> Unit) {
+        if (getPermissionState(COARSE_LOCATION_ALIAS) == PermissionState.GRANTED) {
+            onPermissionGranted()
+        } else {
+            call.sendError(GeolocationErrors.LOCATION_PERMISSIONS_DENIED)
+        }
+    }
+
+    /**
+     * Clears the watch, removing location updates.
+     * @param call the plugin call
+     */
+    @PluginMethod
+    fun clearWatch(call: PluginCall) {
+        val id = call.getString("id")
+        if (id.isNullOrBlank()) {
+            call.sendError(GeolocationErrors.WATCH_ID_NOT_PROVIDED)
+        } else {
+            watchingCalls.remove(id)?.release(bridge)
+            val watchCleared = controller.clearWatch(id)
+            if (watchCleared) {
+                call.sendSuccess()
+            } else {
+                call.sendError(GeolocationErrors.WATCH_ID_NOT_FOUND)
+            }
+        }
+    }
+
+    /**
+     * Gets the appropriate permission alias
+     * @param call the plugin call
+     * @return String with correct alias
+     */
+    private fun getAlias(call: PluginCall): String {
+        var alias = LOCATION_ALIAS
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val enableHighAccuracy = call.getBoolean("enableHighAccuracy") ?: false
+            if (!enableHighAccuracy) {
+                alias = COARSE_LOCATION_ALIAS
+            }
+        }
+        return alias
+    }
+
+    /**
+     * Gets the current position
+     * @param call the plugin call
+     */
+    private fun getPosition(call: PluginCall) {
+        coroutineScope.launch {
+            val locationOptions = createOptions(call)
+
+            // call getCurrentPosition method from controller
+            val locationResult = controller.getCurrentPosition(activity, locationOptions)
+
+            locationResult
+                .onSuccess { location ->
+                    call.sendSuccess(getJSObjectForLocation(location))
+                }
+                .onFailure { exception ->
+                    onLocationError(exception, call)
+                }
+        }
+    }
+
+    /**
+     * Starts watching the device's location by requesting location updates
+     * @param call the plugin call
+     */
+    private fun startWatch(call: PluginCall) {
+        coroutineScope.launch {
+            val watchId = call.callbackId
+
+            val locationOptions = createOptions(call)
+
+            // call addWatch method from controller
+            controller.addWatch(activity, locationOptions, watchId).collect { result ->
+                result.onSuccess { locationList ->
+                    locationList.forEach { locationResult ->
+                        call.sendSuccess(
+                            result = getJSObjectForLocation(locationResult),
+                            keepCallback = true)
+                    }
+                }
+                result.onFailure { exception ->
+                    onLocationError(exception, call)
+                }
+            }
+        }
+        watchingCalls[call.callbackId] = call
+    }
+
+    /**
+     * Helper function to convert IONGLOCLocationResult object into the format accepted by the Capacitor bridge
+     * @param locationResult IONGLOCLocationResult object with the location to convert
+     * @return JSObject with converted JSON object
+     */
+    private fun getJSObjectForLocation(locationResult: IONGLOCLocationResult): JSObject {
+        val coords = JSObject().apply {
+            put("latitude", locationResult.latitude)
+            put("longitude", locationResult.longitude)
+            put("accuracy", locationResult.accuracy)
+            put("altitude", locationResult.altitude)
+            locationResult.altitudeAccuracy?.let { put("altitudeAccuracy", it) }
+            put("speed", locationResult.speed)
+            put("heading", locationResult.heading)
+        }
+        return JSObject().apply {
+            put("timestamp", locationResult.timestamp)
+            put("coords", coords)
+        }
+    }
+
+    /**
+     * Helper function to handle error cases
+     * @param exception Throwable to handle as an error
+     * @param call the plugin call
+     */
+    private fun onLocationError(exception: Throwable?, call: PluginCall) {
+        when (exception) {
+            is IONGLOCException.IONGLOCRequestDeniedException -> {
+                call.sendError(GeolocationErrors.LOCATION_ENABLE_REQUEST_DENIED)
+            }
+            is IONGLOCException.IONGLOCSettingsException -> {
+                call.sendError(GeolocationErrors.LOCATION_SETTINGS_ERROR)
+            }
+            is IONGLOCException.IONGLOCInvalidTimeoutException -> {
+                call.sendError(GeolocationErrors.INVALID_TIMEOUT)
+            }
+            is IONGLOCException.IONGLOCGoogleServicesException -> {
+                if (exception.resolvable) {
+                    call.sendError(GeolocationErrors.GOOGLE_SERVICES_RESOLVABLE)
+                } else {
+                    call.sendError(GeolocationErrors.GOOGLE_SERVICES_ERROR)
+                }
+            }
+            is IONGLOCException.IONGLOCLocationRetrievalTimeoutException -> {
+                call.sendError(GeolocationErrors.GET_LOCATION_TIMEOUT)
+            }
+            else -> {
+                call.sendError(GeolocationErrors.POSITION_UNAVAILABLE)
+            }
+        }
+    }
+
+    /**
+     * Extension function to return a successful plugin result
+     * @param result JSOObject with the JSON content to return
+     * @param keepCallback boolean to determine if callback should be kept for future calls or not
+     */
+    private fun PluginCall.sendSuccess(result: JSObject? = null, keepCallback: Boolean? = false) {
+        this.setKeepAlive(keepCallback)
+        if (result != null) {
+            this.resolve(result)
+        } else {
+            this.resolve()
+        }
+    }
+
+    /**
+     * Extension function to return a unsuccessful plugin result
+     * @param error error class representing the error to return, containing a code and message
+     */
+    private fun PluginCall.sendError(error: GeolocationErrors.ErrorInfo) {
+        this.reject(error.message, error.code)
+    }
+
+    /**
+     * Creates the location options to pass to the native controller
+     * @param call the plugin call
+     * @return IONGLOCLocationOptions object
+     */
+    private fun createOptions(call: PluginCall): IONGLOCLocationOptions {
+        val timeout = call.getLong("timeout", 10000) ?: 10000
+        val maximumAge = call.getLong("maximumAge", 0) ?: 0
+        val enableHighAccuracy = call.getBoolean("enableHighAccuracy", false) ?: false
+        val minimumUpdateInterval = call.getLong("minimumUpdateInterval", 5000) ?: 5000
+
+        val locationOptions = IONGLOCLocationOptions(timeout, maximumAge, enableHighAccuracy, minimumUpdateInterval)
+
+        return locationOptions
+    }
+}

package/ios/Sources/GeolocationPlugin/GeolocationCallbackManager.swift

@@ -0,0 +1,154 @@
+import Capacitor
+import IONGeolocationLib
+
+private enum GeolocationCallbackType {
+    case requestPermissions
+    case location
+    case watch
+
+    var shouldKeepCallback: Bool {
+        self == .watch
+    }
+
+    var shouldClearAfterSending: Bool {
+        self == .location || self == .requestPermissions
+    }
+}
+
+private struct GeolocationCallbackGroup {
+    let ids: [CAPPluginCall]
+    let type: GeolocationCallbackType
+}
+
+final class GeolocationCallbackManager {
+    private(set) var requestPermissionsCallbacks: [CAPPluginCall]
+    private(set) var locationCallbacks: [CAPPluginCall]
+    private(set) var watchCallbacks: [String: CAPPluginCall]
+    private let capacitorBridge: CAPBridgeProtocol?
+
+    private var allCallbackGroups: [GeolocationCallbackGroup] {
+        [
+            .init(ids: requestPermissionsCallbacks, type: .requestPermissions),
+            .init(ids: locationCallbacks, type: .location),
+            .init(ids: Array(watchCallbacks.values), type: .watch)
+        ]
+    }
+    private var requestPermissionsCallbackGroup: GeolocationCallbackGroup? {
+        allCallbackGroups.first { $0.type == .requestPermissions }
+    }
+
+    init(capacitorBridge: CAPBridgeProtocol?) {
+        self.capacitorBridge = capacitorBridge
+        self.requestPermissionsCallbacks = []
+        self.locationCallbacks = []
+        self.watchCallbacks = [:]
+    }
+
+    func addRequestPermissionsCallback(capacitorCall call: CAPPluginCall) {
+        capacitorBridge?.saveCall(call)
+        requestPermissionsCallbacks.append(call)
+    }
+
+    func addLocationCallback(capacitorCall call: CAPPluginCall) {
+        capacitorBridge?.saveCall(call)
+        locationCallbacks.append(call)
+    }
+
+    func addWatchCallback(_ watchId: String, capacitorCall call: CAPPluginCall) {
+        capacitorBridge?.saveCall(call)
+        watchCallbacks[watchId] = call
+    }
+
+    func clearRequestPermissionsCallbacks() {
+        requestPermissionsCallbacks.forEach {
+            capacitorBridge?.releaseCall($0)
+        }
+        requestPermissionsCallbacks.removeAll()
+    }
+
+    func clearWatchCallbackIfExists(_ watchId: String) {
+        if let callbackToRemove = watchCallbacks[watchId] {
+            capacitorBridge?.releaseCall(callbackToRemove)
+            watchCallbacks.removeValue(forKey: watchId)
+        }
+    }
+
+    func clearLocationCallbacks() {
+        locationCallbacks.forEach {
+            capacitorBridge?.releaseCall($0)
+        }
+        locationCallbacks.removeAll()
+    }
+
+    func sendSuccess(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    func sendSuccess(_ call: CAPPluginCall, with data: PluginCallResultData) {
+        call.resolve(data)
+    }
+
+    func sendRequestPermissionsSuccess(_ permissionsResult: String) {
+        if let group = requestPermissionsCallbackGroup {
+            let data = [
+                Constants.AuthorisationStatus.ResultKey.location: permissionsResult,
+                Constants.AuthorisationStatus.ResultKey.coarseLocation: permissionsResult
+            ]
+            send(.success(data), to: group)
+        }
+    }
+
+    func sendSuccess(with position: IONGLOCPositionModel) {
+        createPluginResult(status: .success(position.toJSObject()))
+    }
+
+    func sendError(_ call: CAPPluginCall, error: GeolocationError) {
+        let errorModel = error.toCodeMessagePair()
+        call.reject(errorModel.1, errorModel.0)
+    }
+
+    func sendError(_ error: GeolocationError) {
+        createPluginResult(status: .error(error.toCodeMessagePair()))
+    }
+}
+
+private enum CallResultStatus {
+    typealias SuccessModel = JSObject
+    typealias ErrorModel = (code: String, message: String)
+
+    case success(_ data: SuccessModel)
+    case error(_ codeAndMessage: ErrorModel)
+}
+
+private extension GeolocationCallbackManager {
+
+    func createPluginResult(status: CallResultStatus) {
+        allCallbackGroups.forEach {
+            send(status, to: $0)
+        }
+    }
+
+    func send(_ callResultStatus: CallResultStatus, to group: GeolocationCallbackGroup) {
+        group.ids.forEach { call in
+            call.keepAlive = group.type.shouldKeepCallback
+            switch callResultStatus {
+            case .success(let data):
+                call.resolve(data)
+            case .error(let error):
+                call.reject(error.message, error.code)
+            }
+        }
+
+        if group.type.shouldClearAfterSending {
+            clearCallbacks(for: group.type)
+        }
+    }
+
+    func clearCallbacks(for type: GeolocationCallbackType) {
+        if case .location = type {
+            clearLocationCallbacks()
+        } else if case .requestPermissions = type {
+            clearRequestPermissionsCallbacks()
+        }
+    }
+}

package/ios/Sources/GeolocationPlugin/GeolocationConstants.swift

@@ -0,0 +1,36 @@
+enum Constants {
+    enum Arguments {
+        static let enableHighAccuracy = "enableHighAccuracy"
+        static let id = "id"
+    }
+
+    enum AuthorisationStatus {
+        enum ResultKey {
+            static let location = "location"
+            static let coarseLocation = "coarseLocation"
+        }
+
+        enum Status {
+            static let denied: String = "denied"
+            static let granted: String = "granted"
+            static let prompt: String = "prompt"
+        }
+    }
+
+    enum LocationUsageDescription {
+        static let always: String = "NSLocationAlwaysAndWhenInUseUsageDescription"
+        static let whenInUse: String = "NSLocationWhenInUseUsageDescription"
+    }
+
+    enum Position {
+        static let altitude: String = "altitude"
+        static let coords: String = "coords"
+        static let heading: String = "heading"
+        static let accuracy: String = "accuracy"
+        static let latitude: String = "latitude"
+        static let longitude: String = "longitude"
+        static let speed: String = "speed"
+        static let timestamp: String = "timestamp"
+        static let altitudeAccuracy: String = "altitudeAccuracy"
+    }
+}

package/ios/Sources/GeolocationPlugin/GeolocationError.swift

@@ -0,0 +1,44 @@
+enum GeolocationMethod: String {
+    case getCurrentPosition
+    case watchPosition
+    case clearWatch
+}
+
+enum GeolocationError: Error {
+    case locationServicesDisabled
+    case permissionDenied
+    case permissionRestricted
+    case positionUnavailable
+    case inputArgumentsIssue(target: GeolocationMethod)
+
+    func toCodeMessagePair() -> (String, String) {
+        ("OS-PLUG-GLOC-\(String(format: "%04d", code))", description)
+    }
+}
+
+private extension GeolocationError {
+    var code: Int {
+        switch self {
+        case .positionUnavailable: 2
+        case .permissionDenied: 3
+        case .locationServicesDisabled: 7
+        case .permissionRestricted: 8
+        case .inputArgumentsIssue(let target):
+            switch target {
+            case .getCurrentPosition: 4
+            case .watchPosition: 5
+            case .clearWatch: 6
+            }
+        }
+    }
+
+    var description: String {
+        switch self {
+        case .positionUnavailable: "There was en error trying to obtain the location."
+        case .permissionDenied: "Location permission request was denied."
+        case .locationServicesDisabled: "Location services are not enabled."
+        case .permissionRestricted: "Application's use of location services was restricted."
+        case .inputArgumentsIssue(let target): "The '\(target.rawValue)' input parameters aren't valid."
+        }
+    }
+}

package/ios/Sources/GeolocationPlugin/GeolocationPlugin.swift

@@ -0,0 +1,184 @@
+import Capacitor
+import IONGeolocationLib
+
+import Combine
+
+@objc(GeolocationPlugin)
+public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "GeolocationPlugin"
+    public let jsName = "Geolocation"
+    public let pluginMethods: [CAPPluginMethod] = [
+        .init(name: "getCurrentPosition", returnType: CAPPluginReturnPromise),
+        .init(name: "watchPosition", returnType: CAPPluginReturnCallback),
+        .init(name: "clearWatch", returnType: CAPPluginReturnPromise),
+        .init(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        .init(name: "requestPermissions", returnType: CAPPluginReturnPromise)
+    ]
+
+    private var locationService: (any IONGLOCService)?
+    private var cancellables = Set<AnyCancellable>()
+    private var callbackManager: GeolocationCallbackManager?
+    private var isInitialised: Bool = false
+
+    override public func load() {
+        self.locationService = IONGLOCManagerWrapper()
+        self.callbackManager = .init(capacitorBridge: bridge)
+    }
+
+    @objc func getCurrentPosition(_ call: CAPPluginCall) {
+        shouldSetupBindings()
+        let enableHighAccuracy = call.getBool(Constants.Arguments.enableHighAccuracy, false)
+        handleLocationRequest(enableHighAccuracy, call: call)
+    }
+
+    @objc func watchPosition(_ call: CAPPluginCall) {
+        shouldSetupBindings()
+        let enableHighAccuracy = call.getBool(Constants.Arguments.enableHighAccuracy, false)
+        let watchUUID = call.callbackId
+        handleLocationRequest(enableHighAccuracy, watchUUID: watchUUID, call: call)
+    }
+
+    @objc func clearWatch(_ call: CAPPluginCall) {
+        shouldSetupBindings()
+        guard let callbackId = call.getString(Constants.Arguments.id) else {
+            callbackManager?.sendError(.inputArgumentsIssue(target: .clearWatch))
+            return
+        }
+        callbackManager?.clearWatchCallbackIfExists(callbackId)
+
+        if (callbackManager?.watchCallbacks.isEmpty) ?? false {
+            locationService?.stopMonitoringLocation()
+        }
+
+        callbackManager?.sendSuccess(call)
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        guard checkIfLocationServicesAreEnabled(call) else { return }
+
+        let status = switch locationService?.authorisationStatus {
+        case .restricted, .denied: Constants.AuthorisationStatus.Status.denied
+        case .authorisedAlways, .authorisedWhenInUse: Constants.AuthorisationStatus.Status.granted
+        default: Constants.AuthorisationStatus.Status.prompt
+        }
+
+        let callResultData = [
+            Constants.AuthorisationStatus.ResultKey.location: status,
+            Constants.AuthorisationStatus.ResultKey.coarseLocation: status
+        ]
+        callbackManager?.sendSuccess(call, with: callResultData)
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        guard checkIfLocationServicesAreEnabled(call) else { return }
+
+        if locationService?.authorisationStatus == .notDetermined {
+            shouldSetupBindings()
+            callbackManager?.addRequestPermissionsCallback(capacitorCall: call)
+        } else {
+            checkPermissions(call)
+        }
+    }
+}
+
+private extension GeolocationPlugin {
+    func shouldSetupBindings() {
+        guard !isInitialised else { return }
+        isInitialised = true
+        setupBindings()
+    }
+
+    func setupBindings() {
+        locationService?.authorisationStatusPublisher
+            .sink(receiveValue: { [weak self] status in
+                guard let self else { return }
+
+                switch status {
+                case .denied:
+                    self.onLocationPermissionNotGranted(error: .permissionDenied)
+                case .notDetermined:
+                    self.requestLocationAuthorisation(type: .whenInUse)
+                case .restricted:
+                    self.onLocationPermissionNotGranted(error: .permissionRestricted)
+                case .authorisedAlways, .authorisedWhenInUse:
+                    self.onLocationPermissionGranted()
+                @unknown default: break
+                }
+            })
+            .store(in: &cancellables)
+
+        locationService?.currentLocationPublisher
+            .sink(receiveCompletion: { [weak self] completion in
+                if case .failure(let error) = completion {
+                    print("An error was found while retrieving the location: \(error)")
+                    self?.callbackManager?.sendError(.positionUnavailable)
+                }
+            }, receiveValue: { [weak self] position in
+                self?.callbackManager?.sendSuccess(with: position)
+            })
+            .store(in: &cancellables)
+    }
+
+    func requestLocationAuthorisation(type requestType: IONGLOCAuthorisationRequestType) {
+        DispatchQueue.global(qos: .background).async {
+            guard self.checkIfLocationServicesAreEnabled() else { return }
+            self.locationService?.requestAuthorisation(withType: requestType)
+        }
+    }
+
+    func checkIfLocationServicesAreEnabled(_ call: CAPPluginCall? = nil) -> Bool {
+        guard locationService?.areLocationServicesEnabled() == true else {
+                call.map { callbackManager?.sendError($0, error: .locationServicesDisabled) }
+                    ?? callbackManager?.sendError(.locationServicesDisabled)
+                return false
+            }
+        return true
+    }
+
+    func onLocationPermissionNotGranted(error: GeolocationError) {
+        let shouldNotifyRequestPermissionsResult = callbackManager?.requestPermissionsCallbacks.isEmpty == false
+        let shouldNotifyPermissionError = callbackManager?.locationCallbacks.isEmpty == false ||  callbackManager?.watchCallbacks.isEmpty == false
+
+        if shouldNotifyRequestPermissionsResult {
+            self.callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.denied)
+        }
+        if shouldNotifyPermissionError {
+            self.callbackManager?.sendError(error)
+        }
+    }
+
+    func onLocationPermissionGranted() {
+        let shouldNotifyPermissionGranted = callbackManager?.requestPermissionsCallbacks.isEmpty == false
+        // should request location if callbacks below exist and are not empty
+        let shouldRequestCurrentPosition = callbackManager?.locationCallbacks.isEmpty == false
+        let shouldRequestLocationMonitoring = callbackManager?.watchCallbacks.isEmpty == false
+
+        if shouldNotifyPermissionGranted {
+            callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.granted)
+        }
+        if shouldRequestCurrentPosition {
+            locationService?.requestSingleLocation()
+        }
+        if shouldRequestLocationMonitoring {
+            locationService?.startMonitoringLocation()
+        }
+    }
+
+    func handleLocationRequest(_ enableHighAccuracy: Bool, watchUUID: String? = nil, call: CAPPluginCall) {
+        let configurationModel = IONGLOCConfigurationModel(enableHighAccuracy: enableHighAccuracy)
+        locationService?.updateConfiguration(configurationModel)
+
+        if let watchUUID {
+            callbackManager?.addWatchCallback(watchUUID, capacitorCall: call)
+        } else {
+            callbackManager?.addLocationCallback(capacitorCall: call)
+        }
+
+        switch locationService?.authorisationStatus {
+        case .authorisedAlways, .authorisedWhenInUse: onLocationPermissionGranted()
+        case .denied: callbackManager?.sendError(.permissionDenied)
+        case .restricted: callbackManager?.sendError(.permissionRestricted)
+        default: break
+        }
+    }
+}

package/ios/Sources/GeolocationPlugin/IONGLOCPositionModel+JSONTransformer.swift

@@ -0,0 +1,23 @@
+import Capacitor
+import IONGeolocationLib
+
+extension IONGLOCPositionModel {
+    func toJSObject() -> JSObject {
+        [
+            Constants.Position.timestamp: timestamp,
+            Constants.Position.coords: coordsJSObject
+        ]
+    }
+
+    private var coordsJSObject: JSObject {
+        [
+            Constants.Position.altitude: altitude,
+            Constants.Position.heading: course,
+            Constants.Position.accuracy: horizontalAccuracy,
+            Constants.Position.latitude: latitude,
+            Constants.Position.longitude: longitude,
+            Constants.Position.speed: speed,
+            Constants.Position.altitudeAccuracy: verticalAccuracy
+        ]
+    }
+}

package/ios/Tests/GeolocationTests/GeolocationTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import GeolocationCapacitorPlugin
+
+class GeolocationPluginCapacitorTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = GeolocationPluginCapacitor()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@nitra/geolocation",
+  "version": "7.1.1",
+  "description": "The Geolocation API provides simple methods for getting and tracking the current position of the device using GPS, along with altitude, heading, and speed information if available.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorGeolocation.podspec"
+  ],
+  "author": "Outsystems",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ionic-team/capacitor-geolocation.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ionic-team/capacitor-geolocation/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme GeolocationCapacitor -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api GeolocationPlugin --output-readme README.md --output-json dist/docs.json && cp README.md ../../README.md",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@capacitor/synapse": "^1.0.1"
+  },
+  "devDependencies": {
+    "@capacitor/android": "next",
+    "@capacitor/core": "next",
+    "@capacitor/docgen": "^0.2.2",
+    "@capacitor/ios": "next",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "@types/node": "^20.14.8",
+    "eslint": "^8.57.0",
+    "prettier": "^3.3.3",
+    "prettier-plugin-java": "^2.6.4",
+    "rimraf": "^6.0.1",
+    "rollup": "^2.78.1",
+    "semantic-release": "^24.0.0",
+    "swiftlint": "^2.0.0",
+    "typescript": "~5.4.5"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}