@symbiote-native/location 0.1.1 → 0.1.3

package/README.md

@@ -1,14 +1,15 @@
 # @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`.
+Find out where the user is, which way they face and whether they are walking, turn an address into
+coordinates and back, and keep tracking in the background or watch for entering a region. One API
+for every [SymbioteNative](../../README.md) adapter (React, Vue, Svelte, Solid and Angular).
 
-Foreground position, heading, geocoding, and motion activity, plus background location updates
-and geofencing — registered as tasks through [`@symbiote-native/task-manager`](../task-manager).
+It wraps [`expo-location`](https://github.com/expo/expo/tree/main/packages/expo-location).
+Functions and streams live in a shared `core`; the three permission hooks
+(`useForegroundPermissions`, `useBackgroundPermissions`, `useMotionActivityPermissions`) are
+per-adapter over the shared `createPermissionHook` factory, and Angular gets one
+`*PermissionsService` each. Background updates and geofencing register as tasks through
+[`@symbiote-native/task-manager`](../task-manager).
 
 ## Install
 
@@ -24,36 +25,36 @@ npx @symbiote-native/cli new my-app --location
 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
+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>
+<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.
+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
+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 —
+`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"]` —
+`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
@@ -61,9 +62,9 @@ into the same array `@symbiote-native/audio`/`@symbiote-native/task-manager` may
 
 </details>
 
-**Background location — opt-in, asked for you.** `ACCESS_BACKGROUND_LOCATION`,
+**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
+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
@@ -74,19 +75,20 @@ option reminder. Said no, or ran non-interactively (CI, piped stdin)? Run it any
 npx @symbiote-native/cli grant location
 ```
 
-Idempotent — safe to run again even if already granted.
+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'
+src/core/     location.ts (every function), subscribers.ts (the watchId-keyed event-subscriber
+              machinery shared by position/heading/motion-activity watches),
+              geolocation-polyfill.ts, location-permission-api.ts (get/request pairs the hooks
+              bind to), native-module.ts (requireNativeModule resolution), types.ts.
+src/react|vue|solid|svelte/  use-location-permissions: the three permission hooks
+src/angular/  location-permissions.service: Foreground/Background/MotionActivityPermissionsService
 ```
 
-`./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
+Each adapter subpath re-exports `core` plus its own hooks. `./angular` ships through a separate
 `ngc`/AOT build (`build-ngc/`).
 
 ## Use it
@@ -112,7 +114,7 @@ if (granted) {
 ```
 
 Background updates and geofencing register a task defined with
-[`@symbiote-native/task-manager`](../task-manager)'s `defineTask` — the task itself must be
+[`@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
@@ -140,8 +142,10 @@ if (granted) {
 }
 ```
 
-Identical import surface on every adapter — `@symbiote-native/location/react`, `/vue`, `/svelte`,
-`/solid`, `/angular` all re-export the same functions.
+Identical function surface on every adapter: `@symbiote-native/location/react`, `/vue`, `/svelte`,
+`/solid`, `/angular`. The permission hooks return the adapter's own reactive box (React tuple,
+Vue `Ref`, Solid `Accessor`, Svelte rune object); on Angular inject the matching service and call
+`connect()` for a signal, `get()` / `request()` to refresh.
 
 ## API
 
@@ -156,12 +160,13 @@ watchHeadingAsync(callback, errorHandler?): Promise<ILocationSubscription>
 geocodeAsync(address: string): Promise<ILocationGeocodedLocation[]>
 reverseGeocodeAsync(location): Promise<ILocationGeocodedAddress[]>
 getForegroundPermissionsAsync() / requestForegroundPermissionsAsync(): Promise<ILocationPermissionResponse>
-useForegroundPermissions(options?)
+useForegroundPermissions(options?)                                   // Angular: ForegroundPermissionsService
 getBackgroundPermissionsAsync() / requestBackgroundPermissionsAsync(): Promise<PermissionResponse>
 useBackgroundPermissions(options?)
 hasServicesEnabledAsync(): Promise<boolean>
 getMotionActivityPermissionsAsync() / requestMotionActivityPermissionsAsync(): Promise<PermissionResponse>
 useMotionActivityPermissions(options?)
+installWebGeolocationPolyfill(): void                                // navigator.geolocation
 getMotionActivityAsync(): Promise<IMotionActivityObject>
 watchMotionActivityAsync(callback, errorHandler?): Promise<ILocationSubscription>       // foreground only
 isBackgroundLocationAvailableAsync(): Promise<boolean>
@@ -175,19 +180,42 @@ 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
+- **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
+- **`watchMotionActivityAsync` is foreground-only** - updates pause while the app is backgrounded
   and resume when it returns, per upstream's own contract.
+- **Ask foreground first, then background.** Background permission is a separate, stricter prompt.
+- **Background tracking has hard limits.** It stops if the user terminates the app. On Android a
+  terminated app does not restart on a location or geofence event; on iOS the system relaunches it
+  for a new geofence event.
+- **Emulators need a location set.** Android Emulator: Settings > Location > Use location (and turn
+  off Improve Location Accuracy). iOS Simulator: Features > Location, anything but None.
 - **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.
 
+## Common questions
+
+- **`getCurrentPositionAsync` hangs on some Android devices.** Race it against your own timer, fall
+  back to `getLastKnownPositionAsync()`, and prefer `watchPositionAsync` for updates.
+- **Stops updating in the background after minutes on Android.** Pass `foregroundService` to
+  `startLocationUpdatesAsync`.
+- **Background permission denied right away.** Ask foreground first; after Allow Once, a background
+  request in the same session silently fails.
+- **Accuracy and battery.** `Accuracy.Balanced` for most uses.
+- **Killed app.** Background tracking stops when the user terminates the app.
+
+Sources: [Expo docs: Location](https://docs.expo.dev/versions/latest/sdk/location/),
+[expo/expo#33981](https://github.com/expo/expo/issues/33981),
+[expo/expo#39851](https://github.com/expo/expo/issues/39851),
+[expo/expo#26825](https://github.com/expo/expo/issues/26825),
+[expo/expo#14076](https://github.com/expo/expo/issues/14076).
+
 ## Test it
 
-No Fabric/Descriptor angle at all — every function here is a pure async-function surface plus a
+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.
+listeners directly (`src/core/location.test.ts`) - no `installFabric()`, no ViewConfig.

package/build/angular/index.d.ts

@@ -1 +1,2 @@
 export * from '../core';
+export { ForegroundPermissionsService, BackgroundPermissionsService, MotionActivityPermissionsService, } from './services/location-permissions.service';

package/build/angular/index.js

@@ -1,4 +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.
+// @symbiote-native/location/angular: the core plus the permission services, the location
+// streams need no service wrapper
 export * from '../core/index.js';
+export { ForegroundPermissionsService, BackgroundPermissionsService, MotionActivityPermissionsService, } from './services/location-permissions.service.js';

package/build/angular/services/location-permissions.service.d.ts

@@ -0,0 +1,12 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { ILocationPermissionResponse } from '../../core';
+import type { PermissionResponse } from 'expo-modules-core';
+export declare class ForegroundPermissionsService extends PermissionsServiceBase<ILocationPermissionResponse> {
+    constructor();
+}
+export declare class BackgroundPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+}
+export declare class MotionActivityPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+}

package/build/angular/services/location-permissions.service.js

@@ -0,0 +1,104 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable } from '@angular/core';
+import { backgroundPermissionMethods, foregroundPermissionMethods, motionActivityPermissionMethods, } from '../../core/location-permission-api.js';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+// Angular twin of `../../react`'s location permission hooks
+let ForegroundPermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var ForegroundPermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ForegroundPermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(foregroundPermissionMethods.getMethod, foregroundPermissionMethods.requestMethod);
+        }
+    };
+    return ForegroundPermissionsService = _classThis;
+})();
+export { ForegroundPermissionsService };
+let BackgroundPermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var BackgroundPermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BackgroundPermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(backgroundPermissionMethods.getMethod, backgroundPermissionMethods.requestMethod);
+        }
+    };
+    return BackgroundPermissionsService = _classThis;
+})();
+export { BackgroundPermissionsService };
+let MotionActivityPermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var MotionActivityPermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            MotionActivityPermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(motionActivityPermissionMethods.getMethod, motionActivityPermissionMethods.requestMethod);
+        }
+    };
+    return MotionActivityPermissionsService = _classThis;
+})();
+export { MotionActivityPermissionsService };

package/build/core/geolocation-polyfill.d.ts

@@ -0,0 +1,2 @@
+/** Polyfills `navigator.geolocation` for interop with the React Native and Web geolocation API. */
+export declare function installWebGeolocationPolyfill(): void;

package/build/core/geolocation-polyfill.js

@@ -0,0 +1,52 @@
+import { Platform } from 'expo-modules-core';
+import { expoLocation } from './native-module.js';
+import { locationSubscriber } from './subscribers.js';
+import { LocationAccuracy } from './types.js';
+function convertGeolocationOptions(options) {
+    return {
+        accuracy: options.enableHighAccuracy
+            ? LocationAccuracy.High
+            : LocationAccuracy.Balanced,
+    };
+}
+async function requestCurrentPosition(success, error, options) {
+    try {
+        await expoLocation.requestPermissionsAsync();
+        success(await expoLocation.getCurrentPositionAsync(convertGeolocationOptions(options)));
+    }
+    catch (cause) {
+        error(cause);
+    }
+}
+// Returns undefined like the web API, the async work runs detached and reports through `error`
+function getCurrentPosition(success, error = () => { }, options = {}) {
+    void requestCurrentPosition(success, error, options);
+}
+function watchPosition(success, error = () => { }, options = {}) {
+    const watchId = locationSubscriber.registerCallback(success);
+    expoLocation
+        .watchPositionImplAsync(watchId, convertGeolocationOptions(options))
+        .catch((cause) => {
+        locationSubscriber.unregisterCallback(watchId);
+        error({ watchId, message: cause.message, code: cause.code });
+    });
+    return watchId;
+}
+function clearWatch(watchId) {
+    locationSubscriber.unregisterCallback(watchId);
+}
+/** Polyfills `navigator.geolocation` for interop with the React Native and Web geolocation API. */
+export function installWebGeolocationPolyfill() {
+    if (Platform.OS === 'web')
+        return;
+    if (!Reflect.has(globalThis, 'window'))
+        Reflect.set(globalThis, 'window', globalThis);
+    const windowObject = Reflect.get(globalThis, 'window');
+    if (!Reflect.has(windowObject, 'navigator'))
+        Reflect.set(windowObject, 'navigator', {});
+    Reflect.set(Reflect.get(windowObject, 'navigator'), 'geolocation', {
+        getCurrentPosition,
+        watchPosition,
+        clearWatch,
+    });
+}

package/build/core/index.d.ts

@@ -1,5 +1,6 @@
 export { PermissionStatus, type PermissionHookOptions, type PermissionExpiration, } from 'expo-modules-core';
 export { getCurrentWatchId } from './subscribers';
+export { installWebGeolocationPolyfill } from './geolocation-polyfill';
 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

@@ -1,5 +1,6 @@
 export { PermissionStatus, } from 'expo-modules-core';
 export { getCurrentWatchId } from './subscribers.js';
+export { installWebGeolocationPolyfill } from './geolocation-polyfill.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-permission-api.d.ts

@@ -0,0 +1,13 @@
+import { getBackgroundPermissionsAsync, getForegroundPermissionsAsync, getMotionActivityPermissionsAsync, requestBackgroundPermissionsAsync, requestForegroundPermissionsAsync, requestMotionActivityPermissionsAsync } from './location';
+export declare const foregroundPermissionMethods: {
+    getMethod: typeof getForegroundPermissionsAsync;
+    requestMethod: typeof requestForegroundPermissionsAsync;
+};
+export declare const backgroundPermissionMethods: {
+    getMethod: typeof getBackgroundPermissionsAsync;
+    requestMethod: typeof requestBackgroundPermissionsAsync;
+};
+export declare const motionActivityPermissionMethods: {
+    getMethod: typeof getMotionActivityPermissionsAsync;
+    requestMethod: typeof requestMotionActivityPermissionsAsync;
+};

package/build/core/location-permission-api.js

@@ -0,0 +1,15 @@
+// `methods` every adapter's location permission hooks bind to the shared
+// `@symbiote-native/{react,vue,solid,svelte}` `createPermissionHook` factory
+import { getBackgroundPermissionsAsync, getForegroundPermissionsAsync, getMotionActivityPermissionsAsync, requestBackgroundPermissionsAsync, requestForegroundPermissionsAsync, requestMotionActivityPermissionsAsync, } from './location.js';
+export const foregroundPermissionMethods = {
+    getMethod: getForegroundPermissionsAsync,
+    requestMethod: requestForegroundPermissionsAsync,
+};
+export const backgroundPermissionMethods = {
+    getMethod: getBackgroundPermissionsAsync,
+    requestMethod: requestBackgroundPermissionsAsync,
+};
+export const motionActivityPermissionMethods = {
+    getMethod: getMotionActivityPermissionsAsync,
+    requestMethod: requestMotionActivityPermissionsAsync,
+};

package/build/core/location.d.ts

@@ -12,14 +12,11 @@ export declare function geocodeAsync(address: string): Promise<ILocationGeocoded
 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>;

package/build/core/location.js

@@ -1,4 +1,4 @@
-import { createPermissionHook, Platform } from 'expo-modules-core';
+import { Platform } from 'expo-modules-core';
 import { expoLocation } from './native-module.js';
 import { headingSubscriber, locationErrorSubscriber, locationSubscriber, motionActivitySubscriber, } from './subscribers.js';
 import { LocationAccuracy } from './types.js';
@@ -85,20 +85,12 @@ export async function 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();
 }
@@ -108,10 +100,6 @@ export async function 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() {

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

@@ -4,6 +4,7 @@ export type INativeLocationModule = {
     addListener(eventName: string, listener: (event: unknown) => void): EventSubscription;
     getProviderStatusAsync(): Promise<ILocationProviderStatus>;
     enableNetworkProviderAsync(): Promise<void>;
+    requestPermissionsAsync(): Promise<void>;
     getCurrentPositionAsync(options: ILocationOptions): Promise<ILocationObject>;
     getLastKnownPositionAsync(options: ILocationLastKnownOptions): Promise<ILocationObject | null>;
     watchPositionImplAsync(watchId: number, options: ILocationOptions): Promise<void>;

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions';

package/build/react/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions.js';

package/build/react/use-location-permissions.d.ts

@@ -0,0 +1,11 @@
+import type { ILocationPermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { PermissionResponse } from 'expo-modules-core';
+export type IUseLocationPermissionsHook<TPermission> = (options?: IPermissionHookBehavior) => [
+    TPermission | null,
+    () => Promise<TPermission>,
+    () => Promise<TPermission>
+];
+export declare const useForegroundPermissions: IUseLocationPermissionsHook<ILocationPermissionResponse>;
+export declare const useBackgroundPermissions: IUseLocationPermissionsHook<PermissionResponse>;
+export declare const useMotionActivityPermissions: IUseLocationPermissionsHook<PermissionResponse>;

package/build/react/use-location-permissions.js

@@ -0,0 +1,6 @@
+import { createPermissionHook } from '@symbiote-native/react';
+import { backgroundPermissionMethods, foregroundPermissionMethods, motionActivityPermissionMethods, } from '../core/location-permission-api.js';
+// React twin of `expo-location`'s permission hooks
+export const useForegroundPermissions = createPermissionHook(foregroundPermissionMethods);
+export const useBackgroundPermissions = createPermissionHook(backgroundPermissionMethods);
+export const useMotionActivityPermissions = createPermissionHook(motionActivityPermissionMethods);

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions';

package/build/solid/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions.js';

package/build/solid/use-location-permissions.d.ts

@@ -0,0 +1,12 @@
+import type { ILocationPermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { PermissionResponse } from 'expo-modules-core';
+import type { Accessor } from 'solid-js';
+export type IUseLocationPermissionsHook<TPermission> = (options?: IPermissionHookBehavior) => [
+    Accessor<TPermission | null>,
+    () => Promise<TPermission>,
+    () => Promise<TPermission>
+];
+export declare const useForegroundPermissions: IUseLocationPermissionsHook<ILocationPermissionResponse>;
+export declare const useBackgroundPermissions: IUseLocationPermissionsHook<PermissionResponse>;
+export declare const useMotionActivityPermissions: IUseLocationPermissionsHook<PermissionResponse>;

package/build/solid/use-location-permissions.js

@@ -0,0 +1,6 @@
+import { createPermissionHook } from '@symbiote-native/solid';
+import { backgroundPermissionMethods, foregroundPermissionMethods, motionActivityPermissionMethods, } from '../core/location-permission-api.js';
+// Solid twin of `../react`'s location permission hooks
+export const useForegroundPermissions = createPermissionHook(foregroundPermissionMethods);
+export const useBackgroundPermissions = createPermissionHook(backgroundPermissionMethods);
+export const useMotionActivityPermissions = createPermissionHook(motionActivityPermissionMethods);

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions.svelte';

package/build/svelte/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions.svelte';

package/build/svelte/use-location-permissions.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { ILocationPermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { PermissionResponse } from 'expo-modules-core';
+export type IUseLocationPermissionsHook<TPermission> = (options?: IPermissionHookBehavior) => {
+    readonly status: TPermission | null;
+    requestPermission: () => Promise<TPermission>;
+    getPermission: () => Promise<TPermission>;
+};
+export declare const useForegroundPermissions: IUseLocationPermissionsHook<ILocationPermissionResponse>;
+export declare const useBackgroundPermissions: IUseLocationPermissionsHook<PermissionResponse>;
+export declare const useMotionActivityPermissions: IUseLocationPermissionsHook<PermissionResponse>;

package/build/svelte/use-location-permissions.svelte.js

@@ -0,0 +1,6 @@
+import { createPermissionHook } from '@symbiote-native/svelte/runes/create-permission-hook';
+import { backgroundPermissionMethods, foregroundPermissionMethods, motionActivityPermissionMethods, } from '../core/location-permission-api.js';
+// Svelte twin of `../react`'s location permission hooks
+export const useForegroundPermissions = createPermissionHook(foregroundPermissionMethods);
+export const useBackgroundPermissions = createPermissionHook(backgroundPermissionMethods);
+export const useMotionActivityPermissions = createPermissionHook(motionActivityPermissionMethods);

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions';

package/build/vue/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useForegroundPermissions, useBackgroundPermissions, useMotionActivityPermissions, } from './use-location-permissions.js';

package/build/vue/use-location-permissions.d.ts

@@ -0,0 +1,12 @@
+import type { ILocationPermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { PermissionResponse } from 'expo-modules-core';
+import type { Ref } from '@vue/runtime-core';
+export type IUseLocationPermissionsHook<TPermission> = (options?: IPermissionHookBehavior) => [
+    Ref<TPermission | null>,
+    () => Promise<TPermission>,
+    () => Promise<TPermission>
+];
+export declare const useForegroundPermissions: IUseLocationPermissionsHook<ILocationPermissionResponse>;
+export declare const useBackgroundPermissions: IUseLocationPermissionsHook<PermissionResponse>;
+export declare const useMotionActivityPermissions: IUseLocationPermissionsHook<PermissionResponse>;

package/build/vue/use-location-permissions.js

@@ -0,0 +1,6 @@
+import { createPermissionHook } from '@symbiote-native/vue';
+import { backgroundPermissionMethods, foregroundPermissionMethods, motionActivityPermissionMethods, } from '../core/location-permission-api.js';
+// Vue twin of `../react`'s location permission hooks
+export const useForegroundPermissions = createPermissionHook(foregroundPermissionMethods);
+export const useBackgroundPermissions = createPermissionHook(backgroundPermissionMethods);
+export const useMotionActivityPermissions = createPermissionHook(motionActivityPermissionMethods);

package/build-ngc/angular/index.d.ts

@@ -1 +1,2 @@
 export * from '../core';
+export { ForegroundPermissionsService, BackgroundPermissionsService, MotionActivityPermissionsService, } from './services/location-permissions.service';