@symbiote-native/location 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,193 @@
+# @symbiote-native/location
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-location`](https://github.com/expo/expo/tree/main/packages/expo-location) usable from
+**every** adapter — React, Vue, Svelte, Solid, and Angular. Every export is a plain async
+function or a `usePermissions`-style hook built by `expo-modules-core`'s `createPermissionHook`,
+so there is no adapter-specific state to wrap: the React, Vue, Svelte, Solid, and Angular entry
+points are plain re-exports of the same `core`.
+
+Foreground position, heading, geocoding, and motion activity, plus background location updates
+and geofencing — registered as tasks through [`@symbiote-native/task-manager`](../task-manager).
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --location
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --location
+```
+
+Either way: installs `@symbiote-native/location`, wires the native autolinking automatically, and — since
+this package has an optional, policy-sensitive Android bundle — asks at the end whether to grant
+background location too (see the note below the manual-install block). See
+[`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/location
+```
+
+`expo-location` and `expo-modules-core` come along as regular dependencies, pinned to exact
+versions — never install them yourself, and never add the `expo` meta-package to your project.
+
+## Required one-time step: native autolinking wiring
+
+Same one-time step as every other `expo-modules-core` package this project ships — see
+[`@symbiote-native/local-auth`'s README](../local-auth/README.md#required-one-time-step-native-autolinking-wiring)
+and the `symbiote-expo-native-module` project skill.
+
+`native-link.json` declares four iOS `Info.plist` usage-description keys
+(`NSLocationAlwaysAndWhenInUseUsageDescription`, `NSLocationAlwaysUsageDescription`,
+`NSLocationWhenInUseUsageDescription`, `NSMotionUsageDescription`) with generic default text —
+override any of them by setting the same key yourself before or after install
+(`@symbiote-native/expo-modules-link`'s patcher is additive-only). Android's two base permissions
+(`ACCESS_COARSE_LOCATION`/`ACCESS_FINE_LOCATION`) already ship in `expo-location`'s own
+`AndroidManifest.xml` and merge automatically.
+
+`native-link.json` also declares `ios.infoPlistArrayKeys.UIBackgroundModes: ["location"]` —
+upstream's own `withLocation.ts` config plugin always adds it, since without it iOS silently
+stops delivering `startLocationUpdatesAsync` updates once the app backgrounds. Wired
+automatically by the same postinstall step (see `@symbiote-native/expo-modules-link`), merged
+into the same array `@symbiote-native/audio`/`@symbiote-native/task-manager` may also populate.
+
+</details>
+
+**Background location — opt-in, asked for you.** `ACCESS_BACKGROUND_LOCATION`,
+`FOREGROUND_SERVICE`, `FOREGROUND_SERVICE_LOCATION`, and `ACTIVITY_RECOGNITION` (+ its Play
+Services counterpart) are Android permissions opt-in by default, matching upstream — requesting
+background location triggers Play Console policy review, so it's a deliberate choice, never a
+package side effect. `new --location`/`add --location` above already ask, interactively, whether
+to grant them; say yes and the trio (minus `ACTIVITY_RECOGNITION`, still a hand-edit) lands in
+your `AndroidManifest.xml` for you, along with the `startLocationUpdatesAsync` `foregroundService`
+option reminder. Said no, or ran non-interactively (CI, piped stdin)? Run it any time after:
+
+```bash
+npx @symbiote-native/cli grant location
+```
+
+Idempotent — safe to run again even if already granted.
+
+## Shape
+
+```
+src/core/     location.ts (every function + the two useXPermissions hooks), subscribers.ts (the
+              watchId-keyed event-subscriber machinery shared by position/heading/motion-activity
+              watches), native-module.ts (requireNativeModule resolution), types.ts.
+src/angular/  @symbiote-native/location/angular — export * from '../core'
+```
+
+`./react`, `./vue`, `./svelte`, and `./solid` are `exports`-map aliases straight onto
+`src/core/`. `./angular` stays a physical file/subpath since Angular ships through a separate
+`ngc`/AOT build (`build-ngc/`).
+
+## Use it
+
+```ts
+import {
+  getCurrentPositionAsync,
+  requestForegroundPermissionsAsync,
+  watchPositionAsync,
+} from '@symbiote-native/location';
+
+const { granted } = await requestForegroundPermissionsAsync();
+if (granted) {
+  const position = await getCurrentPositionAsync();
+  const subscription = await watchPositionAsync(
+    { distanceInterval: 10 },
+    location => {
+      console.log(location.coords);
+    },
+  );
+  // later: subscription.remove();
+}
+```
+
+Background updates and geofencing register a task defined with
+[`@symbiote-native/task-manager`](../task-manager)'s `defineTask` — the task itself must be
+defined at module scope, since native can relaunch the JS bundle headlessly to run it:
+
+```ts
+// index.ts, alongside AppRegistry.registerComponent
+import { defineTask } from '@symbiote-native/task-manager';
+
+const SYNC_TASK = 'background-location-sync';
+
+defineTask(SYNC_TASK, async ({ data, error }) => {
+  if (error) return;
+  const { locations } = data as { locations: unknown[] };
+  await syncLocations(locations);
+});
+```
+
+```ts
+import {
+  requestBackgroundPermissionsAsync,
+  startLocationUpdatesAsync,
+} from '@symbiote-native/location';
+
+const { granted } = await requestBackgroundPermissionsAsync();
+if (granted) {
+  await startLocationUpdatesAsync(SYNC_TASK, { distanceInterval: 100 });
+}
+```
+
+Identical import surface on every adapter — `@symbiote-native/location/react`, `/vue`, `/svelte`,
+`/solid`, `/angular` all re-export the same functions.
+
+## API
+
+```ts
+getProviderStatusAsync(): Promise<ILocationProviderStatus>
+enableNetworkProviderAsync(): Promise<void>                          // android
+getCurrentPositionAsync(options?): Promise<ILocationObject>
+getLastKnownPositionAsync(options?): Promise<ILocationObject | null>
+watchPositionAsync(options, callback, errorHandler?): Promise<ILocationSubscription>
+getHeadingAsync(): Promise<ILocationHeadingObject>
+watchHeadingAsync(callback, errorHandler?): Promise<ILocationSubscription>
+geocodeAsync(address: string): Promise<ILocationGeocodedLocation[]>
+reverseGeocodeAsync(location): Promise<ILocationGeocodedAddress[]>
+getForegroundPermissionsAsync() / requestForegroundPermissionsAsync(): Promise<ILocationPermissionResponse>
+useForegroundPermissions(options?)
+getBackgroundPermissionsAsync() / requestBackgroundPermissionsAsync(): Promise<PermissionResponse>
+useBackgroundPermissions(options?)
+hasServicesEnabledAsync(): Promise<boolean>
+getMotionActivityPermissionsAsync() / requestMotionActivityPermissionsAsync(): Promise<PermissionResponse>
+useMotionActivityPermissions(options?)
+getMotionActivityAsync(): Promise<IMotionActivityObject>
+watchMotionActivityAsync(callback, errorHandler?): Promise<ILocationSubscription>       // foreground only
+isBackgroundLocationAvailableAsync(): Promise<boolean>
+startLocationUpdatesAsync(taskName, options?) / stopLocationUpdatesAsync(taskName) / hasStartedLocationUpdatesAsync(taskName)
+startGeofencingAsync(taskName, regions) / stopGeofencingAsync(taskName) / hasStartedGeofencingAsync(taskName)
+```
+
+Plus the `Accuracy`/`ActivityType`/`GeofencingEventType`/`GeofencingRegionState` enum aliases and
+every `ILocation*`/`IMotionActivity*` type, ported from upstream's `Location.ts`/`Location.types.ts`
+with this repo's `I`-prefix convention for exported types (`ts-js-best-practices`).
+
+## Notes
+
+- **Motion activity needs no location permission at all** — it reads Play Services activity
+  recognition / the iOS motion coprocessor directly, gated only by its own
+  `getMotionActivityPermissionsAsync`/`requestMotionActivityPermissionsAsync`.
+- **`watchMotionActivityAsync` is foreground-only** — updates pause while the app is backgrounded
+  and resume when it returns, per upstream's own contract.
+- **No Expo Go warning.** Upstream logs a one-time console warning about background-location
+  limits when running inside Expo Go; this project never runs under Expo Go
+  (`<examples_vs_dot_examples>` in root CLAUDE.md), so the check and the warning are dropped
+  rather than ported.
+
+## Test it
+
+No Fabric/Descriptor angle at all — every function here is a pure async-function surface plus a
+handful of `watchId`-keyed event subscriptions, never a view or per-instance state. Tests inject a
+fake native-module object in place of the real `requireNativeModule` resolution and fire the wired
+listeners directly (`src/core/location.test.ts`) — no `installFabric()`, no ViewConfig.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/location/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core/index.js';

package/build/core/index.d.ts

@@ -0,0 +1,5 @@
+export { PermissionStatus, type PermissionHookOptions, type PermissionExpiration, } from 'expo-modules-core';
+export { getCurrentWatchId } from './subscribers';
+export * from './location';
+export * from './types';
+export { LocationAccuracy as Accuracy, LocationActivityType as ActivityType, LocationGeofencingEventType as GeofencingEventType, LocationGeofencingRegionState as GeofencingRegionState, } from './types';

package/build/core/index.js

@@ -0,0 +1,5 @@
+export { PermissionStatus, } from 'expo-modules-core';
+export { getCurrentWatchId } from './subscribers.js';
+export * from './location.js';
+export * from './types.js';
+export { LocationAccuracy as Accuracy, LocationActivityType as ActivityType, LocationGeofencingEventType as GeofencingEventType, LocationGeofencingRegionState as GeofencingRegionState, } from './types.js';

package/build/core/location.d.ts

@@ -0,0 +1,39 @@
+import type { ILocationCallback, ILocationErrorCallback, ILocationGeocodedAddress, ILocationGeocodedLocation, ILocationHeadingCallback, ILocationHeadingObject, ILocationLastKnownOptions, ILocationObject, ILocationOptions, ILocationPermissionResponse, ILocationProviderStatus, ILocationRegion, ILocationSubscription, ILocationTaskOptions, IMotionActivityCallback, IMotionActivityObject, PermissionResponse } from './types';
+export declare function getProviderStatusAsync(): Promise<ILocationProviderStatus>;
+/** @platform android */
+export declare function enableNetworkProviderAsync(): Promise<void>;
+export declare function getCurrentPositionAsync(options?: ILocationOptions): Promise<ILocationObject>;
+export declare function getLastKnownPositionAsync(options?: ILocationLastKnownOptions): Promise<ILocationObject | null>;
+export declare function watchPositionAsync(options: ILocationOptions, callback: ILocationCallback, errorHandler?: ILocationErrorCallback): Promise<ILocationSubscription>;
+export declare function watchHeadingAsync(callback: ILocationHeadingCallback, errorHandler?: ILocationErrorCallback): Promise<ILocationSubscription>;
+/** Waits for a couple of heading updates and returns the first accurate-enough one. */
+export declare function getHeadingAsync(): Promise<ILocationHeadingObject>;
+export declare function geocodeAsync(address: string): Promise<ILocationGeocodedLocation[]>;
+export declare function reverseGeocodeAsync(location: Pick<ILocationGeocodedLocation, 'latitude' | 'longitude'>): Promise<ILocationGeocodedAddress[]>;
+export declare function getForegroundPermissionsAsync(): Promise<ILocationPermissionResponse>;
+export declare function requestForegroundPermissionsAsync(): Promise<ILocationPermissionResponse>;
+export declare const useForegroundPermissions: (options?: import("expo-modules-core").PermissionHookOptions<object> | undefined) => [ILocationPermissionResponse | null, () => Promise<ILocationPermissionResponse>, () => Promise<ILocationPermissionResponse>];
+export declare function getBackgroundPermissionsAsync(): Promise<PermissionResponse>;
+export declare function requestBackgroundPermissionsAsync(): Promise<PermissionResponse>;
+export declare const useBackgroundPermissions: (options?: import("expo-modules-core").PermissionHookOptions<object> | undefined) => [PermissionResponse | null, () => Promise<PermissionResponse>, () => Promise<PermissionResponse>];
+export declare function hasServicesEnabledAsync(): Promise<boolean>;
+export declare function getMotionActivityPermissionsAsync(): Promise<PermissionResponse>;
+export declare function requestMotionActivityPermissionsAsync(): Promise<PermissionResponse>;
+export declare const useMotionActivityPermissions: (options?: import("expo-modules-core").PermissionHookOptions<object> | undefined) => [PermissionResponse | null, () => Promise<PermissionResponse>, () => Promise<PermissionResponse>];
+/** No location permission required — uses Play Services activity recognition / the iOS motion
+ *  coprocessor directly. */
+export declare function getMotionActivityAsync(): Promise<IMotionActivityObject>;
+/** Foreground-only — updates pause while the app is backgrounded. */
+export declare function watchMotionActivityAsync(callback: IMotionActivityCallback, errorHandler?: ILocationErrorCallback): Promise<ILocationSubscription>;
+export declare function isBackgroundLocationAvailableAsync(): Promise<boolean>;
+/** Register a task (defined with `@symbiote-native/task-manager`'s `defineTask`) to keep
+ *  receiving location updates while the app is backgrounded. */
+export declare function startLocationUpdatesAsync(taskName: string, options?: ILocationTaskOptions): Promise<void>;
+export declare function stopLocationUpdatesAsync(taskName: string): Promise<void>;
+export declare function hasStartedLocationUpdatesAsync(taskName: string): Promise<boolean>;
+/** Register a task (defined with `@symbiote-native/task-manager`'s `defineTask`) to receive
+ *  enter/exit events for the given regions, including while the app is backgrounded. Calling
+ *  this again with a new region array replaces the regions already being watched. */
+export declare function startGeofencingAsync(taskName: string, regions?: ILocationRegion[]): Promise<void>;
+export declare function stopGeofencingAsync(taskName: string): Promise<void>;
+export declare function hasStartedGeofencingAsync(taskName: string): Promise<boolean>;

package/build/core/location.js

@@ -0,0 +1,204 @@
+import { createPermissionHook, Platform } from 'expo-modules-core';
+import { expoLocation } from './native-module.js';
+import { headingSubscriber, locationErrorSubscriber, locationSubscriber, motionActivitySubscriber, } from './subscribers.js';
+import { LocationAccuracy } from './types.js';
+export async function getProviderStatusAsync() {
+    return expoLocation.getProviderStatusAsync();
+}
+/** @platform android */
+export async function enableNetworkProviderAsync() {
+    if (Platform.OS === 'android') {
+        return expoLocation.enableNetworkProviderAsync();
+    }
+}
+export async function getCurrentPositionAsync(options = {}) {
+    return expoLocation.getCurrentPositionAsync(options);
+}
+export async function getLastKnownPositionAsync(options = {}) {
+    return expoLocation.getLastKnownPositionAsync(options);
+}
+export async function watchPositionAsync(options, callback, errorHandler) {
+    const watchId = locationSubscriber.registerCallback(callback);
+    if (errorHandler)
+        locationErrorSubscriber.registerCallbackForId(watchId, errorHandler);
+    await expoLocation.watchPositionImplAsync(watchId, options);
+    return {
+        remove() {
+            locationSubscriber.unregisterCallback(watchId);
+            if (errorHandler)
+                locationErrorSubscriber.unregisterCallback(watchId);
+        },
+    };
+}
+export async function watchHeadingAsync(callback, errorHandler) {
+    const watchId = headingSubscriber.registerCallback(callback);
+    if (errorHandler)
+        locationErrorSubscriber.registerCallbackForId(watchId, errorHandler);
+    await expoLocation.watchDeviceHeading(watchId);
+    return {
+        remove() {
+            headingSubscriber.unregisterCallback(watchId);
+            if (errorHandler)
+                locationErrorSubscriber.unregisterCallback(watchId);
+        },
+    };
+}
+/** Waits for a couple of heading updates and returns the first accurate-enough one. */
+export async function getHeadingAsync() {
+    return new Promise((resolve, reject) => {
+        let tries = 0;
+        let subscriber;
+        watchHeadingAsync(heading => {
+            if (heading.accuracy > 1 || tries > 5) {
+                subscriber?.remove();
+                resolve(heading);
+            }
+            else {
+                tries += 1;
+            }
+        }, reason => {
+            subscriber?.remove();
+            reject(new Error(reason));
+        })
+            .then(sub => {
+            subscriber = sub;
+        })
+            .catch(reject);
+    });
+}
+export async function geocodeAsync(address) {
+    if (typeof address !== 'string') {
+        throw new TypeError(`Address to geocode must be a string. Got ${address} instead.`);
+    }
+    return expoLocation.geocodeAsync(address);
+}
+export async function reverseGeocodeAsync(location) {
+    if (typeof location.latitude !== 'number' ||
+        typeof location.longitude !== 'number') {
+        throw new TypeError('Location to reverse-geocode must be an object with number properties `latitude` and `longitude`.');
+    }
+    return expoLocation.reverseGeocodeAsync(location);
+}
+export async function getForegroundPermissionsAsync() {
+    return expoLocation.getForegroundPermissionsAsync();
+}
+export async function requestForegroundPermissionsAsync() {
+    return expoLocation.requestForegroundPermissionsAsync();
+}
+export const useForegroundPermissions = createPermissionHook({
+    getMethod: getForegroundPermissionsAsync,
+    requestMethod: requestForegroundPermissionsAsync,
+});
+export async function getBackgroundPermissionsAsync() {
+    return expoLocation.getBackgroundPermissionsAsync();
+}
+export async function requestBackgroundPermissionsAsync() {
+    return expoLocation.requestBackgroundPermissionsAsync();
+}
+export const useBackgroundPermissions = createPermissionHook({
+    getMethod: getBackgroundPermissionsAsync,
+    requestMethod: requestBackgroundPermissionsAsync,
+});
+export async function hasServicesEnabledAsync() {
+    return expoLocation.hasServicesEnabledAsync();
+}
+export async function getMotionActivityPermissionsAsync() {
+    return expoLocation.getMotionActivityPermissionsAsync();
+}
+export async function requestMotionActivityPermissionsAsync() {
+    return expoLocation.requestMotionActivityPermissionsAsync();
+}
+export const useMotionActivityPermissions = createPermissionHook({
+    getMethod: getMotionActivityPermissionsAsync,
+    requestMethod: requestMotionActivityPermissionsAsync,
+});
+/** No location permission required — uses Play Services activity recognition / the iOS motion
+ *  coprocessor directly. */
+export async function getMotionActivityAsync() {
+    return new Promise((resolve, reject) => {
+        let subscriber;
+        watchMotionActivityAsync(activity => {
+            subscriber?.remove();
+            resolve(activity);
+        }, reason => {
+            subscriber?.remove();
+            reject(new Error(reason));
+        })
+            .then(sub => {
+            subscriber = sub;
+        })
+            .catch(reject);
+    });
+}
+/** Foreground-only — updates pause while the app is backgrounded. */
+export async function watchMotionActivityAsync(callback, errorHandler) {
+    const watchId = motionActivitySubscriber.registerCallback(callback);
+    if (errorHandler)
+        locationErrorSubscriber.registerCallbackForId(watchId, errorHandler);
+    await expoLocation.watchMotionActivityImplAsync(watchId);
+    return {
+        remove() {
+            motionActivitySubscriber.unregisterCallback(watchId);
+            // forgetCallback, not unregisterCallback: the native watch was already torn down above by
+            // motionActivitySubscriber; re-issuing removeWatchAsync for the same id would hit this
+            // native module's location-permission guard and throw for a motion-activity-only caller.
+            if (errorHandler)
+                locationErrorSubscriber.forgetCallback(watchId);
+        },
+    };
+}
+function assertValidTaskName(taskName) {
+    if (!taskName || typeof taskName !== 'string') {
+        throw new Error(`\`taskName\` must be a non-empty string. Got ${taskName} instead.`);
+    }
+}
+function assertValidRegions(regions) {
+    if (!regions || regions.length === 0) {
+        throw new Error('Regions array cannot be empty. Use `stopGeofencingAsync` if you want to stop geofencing all regions');
+    }
+    for (const region of regions) {
+        if (typeof region.latitude !== 'number') {
+            throw new TypeError(`Region's latitude must be a number. Got '${region.latitude}' instead.`);
+        }
+        if (typeof region.longitude !== 'number') {
+            throw new TypeError(`Region's longitude must be a number. Got '${region.longitude}' instead.`);
+        }
+        if (typeof region.radius !== 'number') {
+            throw new TypeError(`Region's radius must be a number. Got '${region.radius}' instead.`);
+        }
+    }
+}
+export async function isBackgroundLocationAvailableAsync() {
+    const providerStatus = await getProviderStatusAsync();
+    return providerStatus.backgroundModeEnabled;
+}
+/** Register a task (defined with `@symbiote-native/task-manager`'s `defineTask`) to keep
+ *  receiving location updates while the app is backgrounded. */
+export async function startLocationUpdatesAsync(taskName, options = { accuracy: LocationAccuracy.Balanced }) {
+    assertValidTaskName(taskName);
+    await expoLocation.startLocationUpdatesAsync(taskName, options);
+}
+export async function stopLocationUpdatesAsync(taskName) {
+    assertValidTaskName(taskName);
+    await expoLocation.stopLocationUpdatesAsync(taskName);
+}
+export async function hasStartedLocationUpdatesAsync(taskName) {
+    assertValidTaskName(taskName);
+    return expoLocation.hasStartedLocationUpdatesAsync(taskName);
+}
+/** Register a task (defined with `@symbiote-native/task-manager`'s `defineTask`) to receive
+ *  enter/exit events for the given regions, including while the app is backgrounded. Calling
+ *  this again with a new region array replaces the regions already being watched. */
+export async function startGeofencingAsync(taskName, regions = []) {
+    assertValidTaskName(taskName);
+    assertValidRegions(regions);
+    await expoLocation.startGeofencingAsync(taskName, { regions });
+}
+export async function stopGeofencingAsync(taskName) {
+    assertValidTaskName(taskName);
+    await expoLocation.stopGeofencingAsync(taskName);
+}
+export async function hasStartedGeofencingAsync(taskName) {
+    assertValidTaskName(taskName);
+    return expoLocation.hasStartedGeofencingAsync(taskName);
+}

package/build/core/native-module.d.ts

@@ -0,0 +1,31 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { ILocationGeocodedAddress, ILocationGeocodedLocation, ILocationLastKnownOptions, ILocationObject, ILocationOptions, ILocationPermissionResponse, ILocationProviderStatus, ILocationRegion, ILocationTaskOptions, PermissionResponse } from './types';
+export type INativeLocationModule = {
+    addListener(eventName: string, listener: (event: unknown) => void): EventSubscription;
+    getProviderStatusAsync(): Promise<ILocationProviderStatus>;
+    enableNetworkProviderAsync(): Promise<void>;
+    getCurrentPositionAsync(options: ILocationOptions): Promise<ILocationObject>;
+    getLastKnownPositionAsync(options: ILocationLastKnownOptions): Promise<ILocationObject | null>;
+    watchPositionImplAsync(watchId: number, options: ILocationOptions): Promise<void>;
+    watchDeviceHeading(watchId: number): Promise<void>;
+    removeWatchAsync(watchId: number): Promise<void>;
+    geocodeAsync(address: string): Promise<ILocationGeocodedLocation[]>;
+    reverseGeocodeAsync(location: Pick<ILocationGeocodedLocation, 'latitude' | 'longitude'>): Promise<ILocationGeocodedAddress[]>;
+    getForegroundPermissionsAsync(): Promise<ILocationPermissionResponse>;
+    requestForegroundPermissionsAsync(): Promise<ILocationPermissionResponse>;
+    getBackgroundPermissionsAsync(): Promise<PermissionResponse>;
+    requestBackgroundPermissionsAsync(): Promise<PermissionResponse>;
+    hasServicesEnabledAsync(): Promise<boolean>;
+    getMotionActivityPermissionsAsync(): Promise<PermissionResponse>;
+    requestMotionActivityPermissionsAsync(): Promise<PermissionResponse>;
+    watchMotionActivityImplAsync(watchId: number): Promise<void>;
+    startLocationUpdatesAsync(taskName: string, options: ILocationTaskOptions): Promise<void>;
+    stopLocationUpdatesAsync(taskName: string): Promise<void>;
+    hasStartedLocationUpdatesAsync(taskName: string): Promise<boolean>;
+    startGeofencingAsync(taskName: string, options: {
+        regions: ILocationRegion[];
+    }): Promise<void>;
+    stopGeofencingAsync(taskName: string): Promise<void>;
+    hasStartedGeofencingAsync(taskName: string): Promise<boolean>;
+};
+export declare const expoLocation: INativeLocationModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_LOCATION_MODULE_NAME = 'ExpoLocation';
+export const expoLocation = requireNativeModule(EXPO_LOCATION_MODULE_NAME);

package/build/core/subscribers.d.ts

@@ -0,0 +1,23 @@
+import type { ILocationCallback, ILocationErrorCallback, ILocationHeadingCallback, IMotionActivityCallback } from './types';
+declare class Subscriber<TCallback extends ILocationCallback | ILocationHeadingCallback | ILocationErrorCallback | IMotionActivityCallback> {
+    private eventName;
+    private eventDataField;
+    private callbacks;
+    private eventSubscription;
+    constructor(eventName: string, eventDataField: string);
+    private maybeInitializeSubscription;
+    registerCallback(callback: TCallback): number;
+    registerCallbackForId(watchId: number, callback: TCallback): number;
+    unregisterCallback(id: number): void;
+    /** Drops the local callback without calling native removeWatchAsync — used when another
+     *  subscriber already tore down the same watchId natively. */
+    forgetCallback(id: number): void;
+    private releaseSubscriptionIfIdle;
+    private trigger;
+}
+export declare const locationSubscriber: Subscriber<ILocationCallback>;
+export declare const headingSubscriber: Subscriber<ILocationHeadingCallback>;
+export declare const locationErrorSubscriber: Subscriber<ILocationErrorCallback>;
+export declare const motionActivitySubscriber: Subscriber<IMotionActivityCallback>;
+export declare function getCurrentWatchId(): number;
+export {};

package/build/core/subscribers.js

@@ -0,0 +1,65 @@
+import { expoLocation } from './native-module.js';
+let nextWatchId = 0;
+class Subscriber {
+    eventName;
+    eventDataField;
+    callbacks = {};
+    eventSubscription = null;
+    constructor(eventName, eventDataField) {
+        this.eventName = eventName;
+        this.eventDataField = eventDataField;
+    }
+    maybeInitializeSubscription() {
+        if (this.eventSubscription)
+            return;
+        this.eventSubscription = expoLocation.addListener(this.eventName, (event) => this.trigger(event));
+    }
+    registerCallback(callback) {
+        this.maybeInitializeSubscription();
+        const id = ++nextWatchId;
+        this.callbacks[id] = callback;
+        return id;
+    }
+    registerCallbackForId(watchId, callback) {
+        this.maybeInitializeSubscription();
+        this.callbacks[watchId] = callback;
+        return watchId;
+    }
+    unregisterCallback(id) {
+        if (!this.callbacks[id])
+            return;
+        delete this.callbacks[id];
+        void expoLocation.removeWatchAsync(id);
+        this.releaseSubscriptionIfIdle();
+    }
+    /** Drops the local callback without calling native removeWatchAsync — used when another
+     *  subscriber already tore down the same watchId natively. */
+    forgetCallback(id) {
+        if (!this.callbacks[id])
+            return;
+        delete this.callbacks[id];
+        this.releaseSubscriptionIfIdle();
+    }
+    releaseSubscriptionIfIdle() {
+        if (Object.keys(this.callbacks).length === 0 && this.eventSubscription) {
+            this.eventSubscription.remove();
+            this.eventSubscription = null;
+        }
+    }
+    trigger(event) {
+        const callback = this.callbacks[event.watchId];
+        if (callback) {
+            callback(event[this.eventDataField]);
+        }
+        else {
+            void expoLocation.removeWatchAsync(event.watchId);
+        }
+    }
+}
+export const locationSubscriber = new Subscriber('Expo.locationChanged', 'location');
+export const headingSubscriber = new Subscriber('Expo.headingChanged', 'heading');
+export const locationErrorSubscriber = new Subscriber('Expo.locationError', 'reason');
+export const motionActivitySubscriber = new Subscriber('Expo.motionActivityChanged', 'activity');
+export function getCurrentWatchId() {
+    return nextWatchId;
+}