@elizaos/capacitor-location 1.0.0

package/ElizaosCapacitorLocation.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'ElizaosCapacitorLocation'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license'] || { :type => 'MIT' }
+  s.homepage = 'https://elizaos.ai'
+  s.authors = { 'elizaOS' => 'dev@elizaos.ai' }
+  s.source = { :git => 'https://github.com/elizaOS/eliza.git', :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/android/build.gradle

@@ -0,0 +1,45 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+apply plugin: 'com.android.library'
+android {
+    namespace = "ai.eliza.plugins.location"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    maven {
+        url = uri(rootProject.ext.mavenCentralMirrorUrl)
+    }
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation 'com.google.android.gms:play-services-location:21.3.0'
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    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,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+</manifest>

package/android/src/main/java/ai/eliza/plugins/location/LocationPlugin.kt

@@ -0,0 +1,346 @@
+package ai.eliza.plugins.location
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.location.Location
+import android.os.Build
+import android.os.Looper
+import androidx.core.content.ContextCompat
+import com.getcapacitor.JSObject
+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.*
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * ElizaLocation Capacitor Plugin
+ *
+ * Provides location services using Google Play Services FusedLocationProviderClient.
+ * Supports one-shot position, continuous watching, maxAge caching, and background location.
+ */
+@CapacitorPlugin(
+    name = "ElizaLocation",
+    permissions = [
+        Permission(alias = "location", strings = [
+            Manifest.permission.ACCESS_FINE_LOCATION,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ]),
+        Permission(alias = "background", strings = [
+            Manifest.permission.ACCESS_BACKGROUND_LOCATION
+        ])
+    ]
+)
+class LocationPlugin : Plugin() {
+
+    private var fusedLocationClient: FusedLocationProviderClient? = null
+    private val watches = ConcurrentHashMap<String, LocationCallback>()
+    private var pendingCall: PluginCall? = null
+    private var pendingAction: String? = null
+
+    // Cache the last known location for maxAge support
+    private var lastKnownLocation: Location? = null
+
+    override fun load() {
+        super.load()
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(activity)
+    }
+
+    // ── getCurrentPosition ──────────────────────────────────────────────
+
+    @PluginMethod
+    fun getCurrentPosition(call: PluginCall) {
+        if (!hasRequiredPermissions()) {
+            pendingCall = call
+            pendingAction = "getCurrentPosition"
+            requestAllPermissions(call, "handlePermissionResult")
+            return
+        }
+        getCurrentPositionInternal(call)
+    }
+
+    private fun getCurrentPositionInternal(call: PluginCall) {
+        val accuracy = call.getString("accuracy") ?: "high"
+        val timeout = call.getDouble("timeout") ?: 10000.0
+        val maxAge = call.getDouble("maxAge") ?: 0.0
+        val priority = mapAccuracyToPriority(accuracy)
+
+        // maxAge > 0: try returning cached location if fresh enough (mirrors classic bestLastKnown)
+        if (maxAge > 0) {
+            try {
+                fusedLocationClient?.lastLocation?.addOnSuccessListener { cached ->
+                    if (cached != null) {
+                        val age = System.currentTimeMillis() - cached.time
+                        if (age <= maxAge.toLong()) {
+                            lastKnownLocation = cached
+                            call.resolve(buildLocationResult(cached, cached = true))
+                            return@addOnSuccessListener
+                        }
+                    }
+                    // Cache miss — fall through to a fresh fix
+                    requestFreshLocation(call, priority, timeout, maxAge)
+                }?.addOnFailureListener {
+                    requestFreshLocation(call, priority, timeout, maxAge)
+                }
+                return
+            } catch (_: SecurityException) {
+                // Permission lost between check and call — fall through
+            }
+        }
+
+        requestFreshLocation(call, priority, timeout, maxAge)
+    }
+
+    /** Request a fresh location using CurrentLocationRequest. */
+    private fun requestFreshLocation(call: PluginCall, priority: Int, timeout: Double, maxAge: Double) {
+        val request = CurrentLocationRequest.Builder()
+            .setPriority(priority)
+            .setMaxUpdateAgeMillis(maxAge.toLong())
+            .setDurationMillis(timeout.toLong())
+            .build()
+
+        try {
+            fusedLocationClient?.getCurrentLocation(request, null)
+                ?.addOnSuccessListener { location ->
+                    if (location != null) {
+                        lastKnownLocation = location
+                        call.resolve(buildLocationResult(location, cached = false))
+                    } else {
+                        val err = buildErrorEvent("POSITION_UNAVAILABLE", "Unable to get location")
+                        notifyListeners("error", err)
+                        call.reject("Unable to get location")
+                    }
+                }
+                ?.addOnFailureListener { e ->
+                    val code = if (e is SecurityException) "PERMISSION_DENIED" else "POSITION_UNAVAILABLE"
+                    val err = buildErrorEvent(code, "Location error: ${e.message}")
+                    notifyListeners("error", err)
+                    call.reject("Location error: ${e.message}")
+                }
+        } catch (e: SecurityException) {
+            val err = buildErrorEvent("PERMISSION_DENIED", "Location permission required")
+            notifyListeners("error", err)
+            call.reject("Location permission required")
+        }
+    }
+
+    // ── watchPosition ───────────────────────────────────────────────────
+
+    @PluginMethod
+    fun watchPosition(call: PluginCall) {
+        if (!hasRequiredPermissions()) {
+            pendingCall = call
+            pendingAction = "watchPosition"
+            requestAllPermissions(call, "handlePermissionResult")
+            return
+        }
+        watchPositionInternal(call)
+    }
+
+    private fun watchPositionInternal(call: PluginCall) {
+        val accuracy = call.getString("accuracy") ?: "high"
+        val minInterval = call.getDouble("minInterval") ?: 0.0
+        val minDistance = call.getDouble("minDistance") ?: 0.0
+        val priority = mapAccuracyToPriority(accuracy)
+
+        val watchId = UUID.randomUUID().toString()
+
+        val request = LocationRequest.Builder(priority, minInterval.toLong())
+            .setMinUpdateDistanceMeters(minDistance.toFloat())
+            .build()
+
+        val callback = object : LocationCallback() {
+            override fun onLocationResult(result: LocationResult) {
+                for (location in result.locations) {
+                    lastKnownLocation = location
+                    notifyListeners("locationChange", buildLocationResult(location, cached = false))
+                }
+            }
+
+            override fun onLocationAvailability(availability: LocationAvailability) {
+                if (!availability.isLocationAvailable) {
+                    notifyListeners("error", buildErrorEvent(
+                        "POSITION_UNAVAILABLE",
+                        "Location services became unavailable"
+                    ))
+                }
+            }
+        }
+
+        try {
+            fusedLocationClient?.requestLocationUpdates(
+                request,
+                callback,
+                Looper.getMainLooper()
+            )
+
+            watches[watchId] = callback
+            call.resolve(JSObject().apply {
+                put("watchId", watchId)
+            })
+        } catch (e: SecurityException) {
+            notifyListeners("error", buildErrorEvent("PERMISSION_DENIED", "Location permission required"))
+            call.reject("Location permission required")
+        }
+    }
+
+    // ── clearWatch ──────────────────────────────────────────────────────
+
+    @PluginMethod
+    fun clearWatch(call: PluginCall) {
+        val watchId = call.getString("watchId")
+        if (watchId == null) {
+            call.reject("Missing watchId")
+            return
+        }
+
+        val callback = watches.remove(watchId)
+        if (callback != null) {
+            fusedLocationClient?.removeLocationUpdates(callback)
+        }
+        call.resolve()
+    }
+
+    // ── Permissions ─────────────────────────────────────────────────────
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        call.resolve(buildPermissionResult())
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        if (hasRequiredPermissions()) {
+            call.resolve(buildPermissionResult())
+            return
+        }
+        pendingAction = "requestPermissions"
+        requestAllPermissions(call, "handlePermissionResult")
+    }
+
+    @PermissionCallback
+    private fun handlePermissionResult(call: PluginCall) {
+        if (hasRequiredPermissions()) {
+            when (pendingAction) {
+                "getCurrentPosition" -> {
+                    pendingAction = null
+                    pendingCall = null
+                    getCurrentPositionInternal(call)
+                }
+                "watchPosition" -> {
+                    pendingAction = null
+                    pendingCall = null
+                    watchPositionInternal(call)
+                }
+                else -> {
+                    pendingAction = null
+                    pendingCall = null
+                    call.resolve(buildPermissionResult())
+                }
+            }
+        } else {
+            pendingAction = null
+            pendingCall = null
+            notifyListeners("error", buildErrorEvent("PERMISSION_DENIED", "Location permission denied"))
+            call.reject("Location permission denied")
+        }
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────
+
+    override fun hasRequiredPermissions(): Boolean {
+        return getPermissionState("location") == com.getcapacitor.PermissionState.GRANTED
+    }
+
+    /** Map accuracy string from JS to Play Services Priority constant. */
+    private fun mapAccuracyToPriority(accuracy: String): Int {
+        return when (accuracy) {
+            "best" -> Priority.PRIORITY_HIGH_ACCURACY
+            "high" -> Priority.PRIORITY_HIGH_ACCURACY
+            "medium" -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+            "low" -> Priority.PRIORITY_LOW_POWER
+            "passive" -> Priority.PRIORITY_PASSIVE
+            else -> Priority.PRIORITY_HIGH_ACCURACY
+        }
+    }
+
+    private fun buildPermissionResult(): JSObject {
+        val locationState = getPermissionState("location")
+        val locationStatus = when (locationState) {
+            com.getcapacitor.PermissionState.GRANTED -> "granted"
+            com.getcapacitor.PermissionState.DENIED -> "denied"
+            else -> "prompt"
+        }
+
+        val result = JSObject().apply {
+            put("location", locationStatus)
+        }
+
+        // Background location is a separate permission on Android 10+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            val bgGranted = ContextCompat.checkSelfPermission(
+                context, Manifest.permission.ACCESS_BACKGROUND_LOCATION
+            ) == PackageManager.PERMISSION_GRANTED
+
+            val bgStatus = when {
+                bgGranted -> "granted"
+                // If foreground isn't granted, background is implicitly denied
+                locationStatus != "granted" -> "denied"
+                else -> "prompt"
+            }
+            result.put("background", bgStatus)
+        } else {
+            // Pre-Q: background is granted with foreground
+            result.put("background", locationStatus)
+        }
+
+        return result
+    }
+
+    private fun buildLocationResult(location: Location, cached: Boolean): JSObject {
+        val coords = JSObject().apply {
+            put("latitude", location.latitude)
+            put("longitude", location.longitude)
+            if (location.hasAltitude()) {
+                put("altitude", location.altitude)
+            }
+            put("accuracy", location.accuracy.toDouble())
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && location.hasVerticalAccuracy()) {
+                put("altitudeAccuracy", location.verticalAccuracyMeters.toDouble())
+            }
+            if (location.hasSpeed()) {
+                put("speed", location.speed.toDouble())
+            }
+            if (location.hasBearing()) {
+                put("heading", location.bearing.toDouble())
+            }
+            put("timestamp", location.time)
+        }
+
+        return JSObject().apply {
+            put("coords", coords)
+            put("cached", cached)
+        }
+    }
+
+    private fun buildErrorEvent(code: String, message: String): JSObject {
+        return JSObject().apply {
+            put("code", code)
+            put("message", message)
+        }
+    }
+
+    // ── Lifecycle ───────────────────────────────────────────────────────
+
+    override fun handleOnDestroy() {
+        super.handleOnDestroy()
+        for ((_, callback) in watches) {
+            fusedLocationClient?.removeLocationUpdates(callback)
+        }
+        watches.clear()
+    }
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,133 @@
+import type { PluginListenerHandle } from "@capacitor/core";
+/**
+ * Location accuracy level
+ */
+export type LocationAccuracy = "best" | "high" | "medium" | "low" | "passive";
+/**
+ * Location coordinates
+ */
+export interface LocationCoordinates {
+    /** Latitude in degrees */
+    latitude: number;
+    /** Longitude in degrees */
+    longitude: number;
+    /** Altitude in meters (if available) */
+    altitude?: number;
+    /** Horizontal accuracy in meters */
+    accuracy: number;
+    /** Vertical accuracy in meters (if available) */
+    altitudeAccuracy?: number;
+    /** Speed in meters per second (if available) */
+    speed?: number;
+    /** Heading in degrees (if available) */
+    heading?: number;
+    /** Timestamp of the location */
+    timestamp: number;
+}
+/**
+ * Options for getting location
+ */
+export interface LocationOptions {
+    /** Desired accuracy level (default: high) */
+    accuracy?: LocationAccuracy;
+    /** Maximum age of cached location in milliseconds (default: 0 = no cache) */
+    maxAge?: number;
+    /** Timeout in milliseconds (default: 10000) */
+    timeout?: number;
+}
+/**
+ * Options for watching location
+ */
+export interface WatchLocationOptions extends LocationOptions {
+    /** Minimum distance in meters to trigger an update (default: 0) */
+    minDistance?: number;
+    /** Minimum time interval in milliseconds between updates (default: 0) */
+    minInterval?: number;
+}
+/**
+ * Location result
+ */
+export interface LocationResult {
+    /** The location coordinates */
+    coords: LocationCoordinates;
+    /** Whether this is from cache */
+    cached: boolean;
+}
+/**
+ * Location permission status
+ */
+export interface LocationPermissionStatus {
+    /** Current permission status */
+    location: "granted" | "denied" | "prompt";
+    /** Whether background location is allowed (iOS/Android) */
+    background?: "granted" | "denied" | "prompt";
+}
+/**
+ * Location error event
+ */
+export interface LocationErrorEvent {
+    /** Error code */
+    code: "PERMISSION_DENIED" | "POSITION_UNAVAILABLE" | "TIMEOUT" | "UNKNOWN";
+    /** Error message */
+    message: string;
+}
+/**
+ * Location Plugin Interface
+ *
+ * Provides access to device location services including GPS, network,
+ * and fused location providers.
+ */
+export interface LocationPlugin {
+    /**
+     * Get the current location
+     *
+     * @param options - Location options
+     * @returns Promise resolving to location result
+     */
+    getCurrentPosition(options?: LocationOptions): Promise<LocationResult>;
+    /**
+     * Start watching location changes
+     *
+     * Location updates are delivered via the 'locationChange' event.
+     *
+     * @param options - Watch options
+     * @returns Promise resolving to a watch ID
+     */
+    watchPosition(options?: WatchLocationOptions): Promise<{
+        watchId: string;
+    }>;
+    /**
+     * Stop watching location changes
+     *
+     * @param options - Watch ID to stop
+     * @returns Promise that resolves when watch is stopped
+     */
+    clearWatch(options: {
+        watchId: string;
+    }): Promise<void>;
+    /**
+     * Check location permission status
+     *
+     * @returns Promise resolving to permission status
+     */
+    checkPermissions(): Promise<LocationPermissionStatus>;
+    /**
+     * Request location permissions
+     *
+     * @returns Promise resolving to permission status after request
+     */
+    requestPermissions(): Promise<LocationPermissionStatus>;
+    /**
+     * Add listener for location changes (when watching)
+     */
+    addListener(eventName: "locationChange", listenerFunc: (location: LocationResult) => void): Promise<PluginListenerHandle>;
+    /**
+     * Add listener for location errors
+     */
+    addListener(eventName: "error", listenerFunc: (error: LocationErrorEvent) => void): Promise<PluginListenerHandle>;
+    /**
+     * Remove all listeners
+     */
+    removeAllListeners(): Promise<void>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/esm/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,iCAAiC;IACjC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,gCAAgC;IAChC,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C,2DAA2D;IAC3D,UAAU,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iBAAiB;IACjB,IAAI,EAAE,mBAAmB,GAAG,sBAAsB,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEvE;;;;;;;OAOG;IACH,aAAa,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE5E;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExD;;;;OAIG;IACH,gBAAgB,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAEtD;;;;OAIG;IACH,kBAAkB,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAExD;;OAEG;IACH,WAAW,CACT,SAAS,EAAE,gBAAgB,EAC3B,YAAY,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,GAC/C,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEjC;;OAEG;IACH,WAAW,CACT,SAAS,EAAE,OAAO,EAClB,YAAY,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAChD,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEjC;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC"}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":""}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { LocationPlugin } from "./definitions";
+export * from "./definitions";
+export declare const Location: LocationPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,cAAc,eAAe,CAAC;AAI9B,eAAO,MAAM,QAAQ,gBAEnB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from "@capacitor/core";
+export * from "./definitions";
+const loadWeb = () => import("./web").then((m) => new m.LocationWeb());
+export const Location = registerPlugin("ElizaLocation", {
+    web: loadWeb,
+});
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,cAAc,eAAe,CAAC;AAE9B,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;AAEvE,MAAM,CAAC,MAAM,QAAQ,GAAG,cAAc,CAAiB,eAAe,EAAE;IACtE,GAAG,EAAE,OAAO;CACb,CAAC,CAAC"}

package/dist/esm/web.d.ts

@@ -0,0 +1,20 @@
+import { WebPlugin } from "@capacitor/core";
+import type { LocationOptions, LocationPermissionStatus, LocationResult, WatchLocationOptions } from "./definitions";
+/**
+ * Web implementation of the Location Plugin
+ *
+ * Uses the browser Geolocation API.
+ */
+export declare class LocationWeb extends WebPlugin {
+    private watches;
+    getCurrentPosition(options?: LocationOptions): Promise<LocationResult>;
+    watchPosition(options?: WatchLocationOptions): Promise<{
+        watchId: string;
+    }>;
+    clearWatch(options: {
+        watchId: string;
+    }): Promise<void>;
+    checkPermissions(): Promise<LocationPermissionStatus>;
+    requestPermissions(): Promise<LocationPermissionStatus>;
+}
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACxB,cAAc,EACd,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB;;;;GAIG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC,OAAO,CAAC,OAAO,CAA6B;IAEtC,kBAAkB,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAmDtE,aAAa,CACjB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAsDzB,UAAU,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQvD,gBAAgB,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAqBrD,kBAAkB,IAAI,OAAO,CAAC,wBAAwB,CAAC;CAc9D"}