@octane-xplat/geolocation 0.0.0-nightly.g14544fe

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alec Larson
+
+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,97 @@
+# `@octane-xplat/geolocation`
+
+```sh
+pnpm add @octane-xplat/geolocation
+```
+
+Device geolocation behind one capability object. iOS and Android run
+`@nativescript/geolocation`; web uses `navigator.geolocation`; the macOS
+AppKit target uses Core Location through a package-owned native facade. Hosts
+without that facade or location purpose strings report `supported: false`.
+
+```ts
+import { geolocation } from '@octane-xplat/geolocation'
+
+if ((await geolocation.ensure()) === 'granted') {
+	const pos = await geolocation.impl!.getCurrentPosition()
+	// { latitude, longitude, accuracy, altitude, heading, speed, timestamp }
+}
+```
+
+The shared capability contract: `supported` reports whether an
+implementation exists on this target, `ensure()` resolves
+`'granted' | 'denied' | 'unsupported'` (it prompts where the platform
+defers the prompt), and `impl` is the service once usable. Nullable
+`altitude`/`heading`/`speed` mean the platform did not report them.
+
+On iOS and Android, position failures preserve the plugin's original error;
+a numeric `code` is not guaranteed. Web and macOS failures use codes 1
+(denied), 2 (unavailable), and 3 (timeout). Handle an unclassified failure too:
+
+```ts
+import { geolocation } from '@octane-xplat/geolocation'
+
+if ((await geolocation.ensure()) === 'granted') {
+	try {
+		const position = await geolocation.impl!.getCurrentPosition()
+		console.log(position.latitude, position.longitude)
+	} catch (error) {
+		const code = (error as { code?: number }).code
+		console.log(code === undefined ? 'Location failed' : `Location failed: ${code}`)
+	}
+}
+```
+
+Guide: [Using device features](../../docs/platform/platform-services.md)
+per-target availability: [platform notes](../../.agents/docs/notes/platform-notes.md).
+Exercised by the harness `Services` screen
+([`packages/app/src/Services.tsrx`](../app/src/Services.tsrx)).
+
+## macOS host setup
+
+The existing Xplat native build discovers this package's `platforms/macos`
+sources and links CoreLocation. Add both purpose strings to the application
+Info.plist before requesting permission. An unsigned command-line host without
+an application bundle remains unsupported.
+
+```xml
+<key>NSLocationUsageDescription</key>
+<string>Show places near your current location.</string>
+<key>NSLocationWhenInUseUsageDescription</key>
+<string>Show places near your current location while you use the app.</string>
+```
+
+Sandboxed applications also need the location entitlement in their signing
+entitlements file. The application owns its purpose text and signing settings.
+
+```xml
+<key>com.apple.security.personal-information.location</key>
+<true/>
+```
+
+Location denial or disabled system Location Services returns `denied`. A
+permission request with no decision after 30 seconds returns `unsupported`
+and can be retried. Position failures reject with code 1 (denied), 2
+(unavailable), or 3 (timeout). Times are milliseconds; omitted timeout waits
+without a deadline, and omitted maximumAge requires a fresh fix.
+
+```ts
+import { geolocation } from '@octane-xplat/geolocation'
+
+if ((await geolocation.ensure()) === 'granted') {
+	try {
+		const position = await geolocation.impl!.getCurrentPosition({
+			enableHighAccuracy: true,
+			timeout: 10000,
+			maximumAge: 5000,
+		})
+		console.log(position.latitude, position.longitude)
+	} catch (error) {
+		console.log('Location failed', (error as { code?: number }).code)
+	}
+}
+```
+
+Automated coverage checks native delegate cleanup and the service adapter.
+Real AppKit permission prompts, signed/sandboxed delivery, and physical location
+accuracy still require the manual test plan in the implementation commit.

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@octane-xplat/geolocation",
+  "version": "0.0.0-nightly.g14544fe",
+  "description": "Device geolocation for Octane xplat — matching web + NativeScript implementations",
+  "keywords": [
+    "android",
+    "cross-platform",
+    "geolocation",
+    "gps",
+    "ios",
+    "location",
+    "nativescript",
+    "octane",
+    "web",
+    "xplat"
+  ],
+  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/geolocation",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/octane-xplat/octane-xplat",
+    "directory": "packages/geolocation"
+  },
+  "files": [
+    "src",
+    "platforms",
+    "types",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "macos": {
+        "types": "./types/generated/index.macos.d.ts",
+        "default": "./src/index.macos.ts"
+      },
+      "types": "./types/generated/index.d.ts",
+      "default": "./src/index.ts"
+    },
+    "./*": {
+      "types": "./types/generated/*.d.ts",
+      "default": "./src/*"
+    },
+    "./*.ts": {
+      "types": "./types/generated/*.d.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nativescript/geolocation": "9.0.0"
+  },
+  "devDependencies": {
+    "@nativescript-community/octane": "0.2.5",
+    "@nativescript/core": "9.1.3",
+    "@nativescript/types": "9.1.4",
+    "@tsrx/typescript-plugin": "0.4.11",
+    "octane": "0.11.0",
+    "tsrx-typegen": "0.3.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@nativescript-community/octane": ">=0.2.1 <1",
+    "@nativescript/core": ">=9.1.0 <10",
+    "octane": ">=0.6.3 <1"
+  },
+  "peerDependenciesMeta": {
+    "@nativescript-community/octane": {
+      "optional": true
+    },
+    "@nativescript/core": {
+      "optional": true
+    }
+  },
+  "nativescript": {
+    "platforms": {
+      "android": "9.1.0",
+      "ios": "9.1.0"
+    }
+  },
+  "xplat": {
+    "macos": {
+      "frameworks": [
+        "Foundation",
+        "CoreLocation"
+      ]
+    }
+  },
+  "scripts": {
+    "test:packed": "node tests/packed-consumer.mjs",
+    "test": "node --experimental-strip-types --test tests/geolocation.macos.test.ts",
+    "test:macos": "node tests/verify-macos.mjs && node tests/verify-host.mjs",
+    "typegen": "tsrx-typegen --project tsconfig.types.json",
+    "pack:check": "tsrx-typegen --pack-check"
+  }
+}

package/platforms/macos/include/XplatGeolocation.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+@interface XplatGeolocation : NSObject
++ (BOOL)isAvailable;
++ (void)ensure:(void (^)(NSString *result))completion;
++ (void)position:(BOOL)highAccuracy timeout:(double)timeout maximumAge:(double)maximumAge
+      completion:(void (^)(NSString *positionJSON, NSInteger code, NSString *message))completion;
+@end

package/platforms/macos/src/XplatGeolocation.m

@@ -0,0 +1,125 @@
+#import "XplatGeolocation.h"
+#import <CoreLocation/CoreLocation.h>
+
+// Each operation owns its manager/delegate until completion. All access and JS
+// callbacks occur on the main queue; concurrent callers cannot replace callbacks.
+@interface XplatLocationRequest : NSObject <CLLocationManagerDelegate>
+@property(nonatomic, strong) CLLocationManager *manager;
+@property(nonatomic, copy) void (^permission)(NSString *);
+@property(nonatomic, copy) void (^position)(NSString *, NSInteger, NSString *);
+@property(nonatomic) BOOL finished;
+@property(nonatomic) BOOL started;
+@property(nonatomic) double maximumAge;
+@property(nonatomic, strong) NSDate *startedAt;
+- (void)authorization;
+- (void)finish:(CLLocation *)location code:(NSInteger)code message:(NSString *)message;
+@end
+
+static NSMutableSet<XplatLocationRequest *> *requests;
+static CLLocation *cachedLocation;
+
+@implementation XplatLocationRequest
+- (void)finish:(CLLocation *)location code:(NSInteger)code message:(NSString *)message {
+    if (self.finished) return;
+    self.finished = YES;
+    [self.manager stopUpdatingLocation];
+    self.manager.delegate = nil;
+    NSDictionary *value = nil;
+    if (location) {
+        cachedLocation = location;
+        value = @{@"latitude": @(location.coordinate.latitude), @"longitude": @(location.coordinate.longitude),
+                  @"accuracy": @(location.horizontalAccuracy),
+                  @"altitude": location.verticalAccuracy >= 0 ? @(location.altitude) : NSNull.null,
+                  @"heading": location.course >= 0 ? @(location.course) : NSNull.null,
+                  @"speed": location.speed >= 0 ? @(location.speed) : NSNull.null,
+                  @"timestamp": @(location.timestamp.timeIntervalSince1970 * 1000)};
+    }
+    if (self.permission) self.permission(code == 0 ? @"granted" : code == 1 ? @"denied" : @"unsupported");
+    NSString *json = value ? [[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:value options:0 error:nil] encoding:NSUTF8StringEncoding] : nil;
+    if (self.position) self.position(json, code, message ?: @"");
+    self.permission = nil;
+    self.position = nil;
+    [requests removeObject:self];
+}
+- (void)authorization {
+    if (self.finished) return;
+    CLAuthorizationStatus status = self.manager.authorizationStatus;
+    if (status == kCLAuthorizationStatusDenied || status == kCLAuthorizationStatusRestricted ||
+        !CLLocationManager.locationServicesEnabled) {
+        [self finish:nil code:1 message:@"Location permission denied or services disabled"];
+    } else if (status == kCLAuthorizationStatusAuthorizedAlways) {
+        if (self.permission) {
+            [self finish:nil code:0 message:nil];
+        } else if (!self.started) {
+            self.started = YES;
+            double age = -cachedLocation.timestamp.timeIntervalSinceNow * 1000;
+            if (cachedLocation && self.maximumAge > 0 && age >= 0 && age <= self.maximumAge) {
+                [self finish:cachedLocation code:0 message:nil];
+            } else {
+                [self.manager startUpdatingLocation];
+            }
+        }
+    }
+}
+- (void)locationManagerDidChangeAuthorization:(CLLocationManager *)manager { [self authorization]; }
+- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations {
+    CLLocation *location = locations.lastObject;
+    if (!location || location.horizontalAccuracy < 0) return;
+    double age = -location.timestamp.timeIntervalSinceNow * 1000;
+    // A zero maximumAge must not reuse a fix obtained before this request.
+    if (self.maximumAge > 0 ? age > self.maximumAge : [location.timestamp compare:self.startedAt] == NSOrderedAscending) return;
+    [self finish:location code:0 message:nil];
+}
+- (void)locationManager:(CLLocationManager *)manager didFailWithError:(NSError *)error {
+    if ([error.domain isEqualToString:kCLErrorDomain] && error.code == kCLErrorLocationUnknown) return;
+    NSInteger code = [error.domain isEqualToString:kCLErrorDomain] && error.code == kCLErrorDenied ? 1 : 2;
+    [self finish:nil code:code message:code == 1 ? @"Location permission denied" : @"Location unavailable"];
+}
+@end
+
+@implementation XplatGeolocation
++ (BOOL)isAvailable {
+    NSBundle *bundle = NSBundle.mainBundle;
+    NSString *purpose = [bundle objectForInfoDictionaryKey:@"NSLocationUsageDescription"];
+    NSString *whenInUse = [bundle objectForInfoDictionaryKey:@"NSLocationWhenInUseUsageDescription"];
+    return bundle.bundleIdentifier.length > 0 && [purpose isKindOfClass:NSString.class] && purpose.length > 0 &&
+           [whenInUse isKindOfClass:NSString.class] && whenInUse.length > 0;
+}
++ (void)begin:(BOOL)high timeout:(double)timeout maximumAge:(double)maximumAge
+    permission:(void (^)(NSString *))permission position:(void (^)(NSString *, NSInteger, NSString *))position {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (![self isAvailable]) {
+            if (permission) permission(@"unsupported");
+            if (position) position(nil, 2, @"Location host is not configured");
+            return;
+        }
+        if (!requests) requests = NSMutableSet.new;
+        XplatLocationRequest *request = XplatLocationRequest.new;
+        request.permission = permission;
+        request.position = position;
+        request.maximumAge = maximumAge;
+        request.startedAt = NSDate.date;
+        request.manager = CLLocationManager.new;
+        request.manager.desiredAccuracy = high ? kCLLocationAccuracyBest : kCLLocationAccuracyThreeKilometers;
+        [requests addObject:request];
+        request.manager.delegate = request;
+        [request authorization];
+        if (request.finished) return;
+        if (request.manager.authorizationStatus == kCLAuthorizationStatusNotDetermined) {
+            [request.manager requestWhenInUseAuthorization];
+        }
+        if (timeout >= 0) {
+            __weak XplatLocationRequest *weakRequest = request;
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(MIN(timeout, (double)INT64_MAX / NSEC_PER_MSEC) * NSEC_PER_MSEC)),
+                           dispatch_get_main_queue(), ^{ [weakRequest finish:nil code:3 message:@"Location request timed out"]; });
+        }
+    });
+}
++ (void)ensure:(void (^)(NSString *))completion {
+    [self begin:NO timeout:30000 maximumAge:0 permission:completion position:nil];
+}
++ (void)position:(BOOL)highAccuracy timeout:(double)timeout maximumAge:(double)maximumAge
+      completion:(void (^)(NSString *, NSInteger, NSString *))completion {
+    [self begin:highAccuracy timeout:timeout maximumAge:maximumAge permission:nil position:completion];
+}
+@end

package/src/geolocation.macos.ts

@@ -0,0 +1,71 @@
+// Package-owned Core Location facade, loaded by the existing macOS native graph.
+import type { Capability, GeolocationImpl, GeolocationPosition, PermissionResult } from './types'
+
+declare const XplatGeolocation: {
+	isAvailable(): boolean
+	ensure(completion: (result: PermissionResult) => void): void
+	positionTimeoutMaximumAgeCompletion(
+		highAccuracy: boolean,
+		timeout: number,
+		maximumAge: number,
+		completion: (positionJSON: string | null, code: number, message: string) => void,
+	): void
+}
+
+const available = () => typeof XplatGeolocation !== 'undefined' && XplatGeolocation.isAvailable()
+
+const milliseconds = (value: number | undefined, fallback: number) =>
+	value === undefined || Number.isNaN(value) ? fallback : Math.max(0, value)
+
+const impl: GeolocationImpl = {
+	getCurrentPosition(options) {
+		return new Promise((resolve, reject) => {
+			if (!available()) {
+				reject(Object.assign(new Error('Location host unavailable'), { code: 2 }))
+
+				return
+			}
+
+			const timeout = milliseconds(options?.timeout, Infinity)
+			XplatGeolocation.positionTimeoutMaximumAgeCompletion(
+				options?.enableHighAccuracy ?? false,
+				timeout === Infinity ? -1 : timeout,
+				milliseconds(options?.maximumAge, 0),
+				(positionJSON, code, message) => {
+					if (code === 0 && positionJSON) {
+						try {
+							resolve(JSON.parse(positionJSON) as GeolocationPosition)
+						} catch (error) {
+							reject(error)
+						}
+					} else {
+						reject(
+							Object.assign(new Error(message || 'Location unavailable'), {
+								code: code || 2,
+							}),
+						)
+					}
+				},
+			)
+		})
+	},
+}
+
+export const geolocation: Capability<GeolocationImpl> = {
+	get supported() {
+		return available()
+	},
+	async ensure() {
+		if (!available()) {
+			return 'unsupported'
+		}
+
+		return new Promise<PermissionResult>((resolve) => XplatGeolocation.ensure(resolve))
+	},
+	get impl() {
+		return available() ? impl : null
+	},
+}
+
+const permissionOwners = ((globalThis as any).__xplatPermissionOwners ??= {})
+permissionOwners.location = () => geolocation.ensure()

package/src/geolocation.ts

@@ -0,0 +1,57 @@
+// Geolocation — native leaf. The plugin's enableLocationRequest() owns the
+// runtime prompt; getCurrentLocation() is normalized to the web position shape.
+import * as geolocationApi from '@nativescript/geolocation'
+import { CoreTypes } from '@nativescript/core'
+import type { Capability, GeolocationImpl, GeolocationPosition } from './types'
+
+function asPosition(nativeLocation: any): GeolocationPosition {
+	const android = nativeLocation.android
+	const ios = nativeLocation.ios
+	const heading = nativeLocation.direction ?? nativeLocation.heading
+	const speed = nativeLocation.speed
+	return {
+		latitude: nativeLocation.latitude,
+		longitude: nativeLocation.longitude,
+		accuracy: Math.max(0, nativeLocation.horizontalAccuracy ?? nativeLocation.accuracy ?? 0),
+		// Altitude itself can be negative; iOS validity uses verticalAccuracy.
+		altitude:
+			(android && !android.hasAltitude()) || (ios && ios.verticalAccuracy < 0)
+				? null
+				: (nativeLocation.altitude ?? null),
+		heading: (android && !android.hasBearing()) || heading == null || heading < 0 ? null : heading,
+		speed: (android && !android.hasSpeed()) || speed == null || speed < 0 ? null : speed,
+		timestamp: Number(nativeLocation.timestamp ?? Date.now()),
+	}
+}
+
+const impl: GeolocationImpl = {
+	async getCurrentPosition(options) {
+		const nativePosition = await geolocationApi.getCurrentLocation({
+			desiredAccuracy: options?.enableHighAccuracy
+				? CoreTypes.Accuracy.high
+				: CoreTypes.Accuracy.any,
+			maximumAge: options?.maximumAge,
+			timeout: options?.timeout,
+		})
+
+		return asPosition(nativePosition)
+	},
+}
+
+export const geolocation: Capability<GeolocationImpl> = {
+	supported: true,
+	async ensure() {
+		try {
+			await geolocationApi.enableLocationRequest()
+			return 'granted'
+		} catch {
+			return 'denied'
+		}
+	},
+	impl,
+}
+
+// See @octane-xplat/media for the pattern — registers the kind this leaf owns
+// for the platform permissions dispatcher.
+const permissionOwners = ((globalThis as any).__xplatPermissionOwners ??= {})
+permissionOwners.location = () => geolocation.ensure()

package/src/geolocation.web.ts

@@ -0,0 +1,78 @@
+// Geolocation — web leaf. The browser owns the permission prompt and returns
+// the platform-neutral position shape used by the service contract.
+import type { Capability, GeolocationImpl, GeolocationOptions, GeolocationPosition } from './types'
+
+const supported = typeof navigator !== 'undefined' && 'geolocation' in navigator
+
+function readPosition(options?: GeolocationOptions): Promise<GeolocationPosition> {
+	return new Promise((resolve, reject) => {
+		navigator.geolocation.getCurrentPosition(
+			(position) =>
+				resolve({
+					latitude: position.coords.latitude,
+					longitude: position.coords.longitude,
+					accuracy: position.coords.accuracy,
+					altitude: position.coords.altitude,
+					heading: position.coords.heading,
+					speed: position.coords.speed,
+					timestamp: position.timestamp,
+				}),
+			reject,
+			{
+				enableHighAccuracy: options?.enableHighAccuracy,
+				timeout: options?.timeout,
+				maximumAge: options?.maximumAge,
+			},
+		)
+	})
+}
+
+const impl: GeolocationImpl = {
+	getCurrentPosition: readPosition,
+}
+
+export const geolocation: Capability<GeolocationImpl> = {
+	supported,
+	async ensure() {
+		if (!supported) {
+			return 'unsupported'
+		}
+
+		try {
+			await readPosition({ timeout: 15000 })
+			return 'granted'
+		} catch (error) {
+			const code = (error as { code?: number }).code
+			if (code === 1) {
+				return 'denied'
+			}
+
+			if (code === 3) {
+				return 'granted'
+			}
+
+			// POSITION_UNAVAILABLE can precede authorization (inactive document).
+			// Only a permission query can establish access in that case.
+			if (code === 2 && navigator.permissions?.query) {
+				try {
+					const permission = await navigator.permissions.query({ name: 'geolocation' })
+					if (permission.state === 'granted') {
+						return 'granted'
+					}
+
+					if (permission.state === 'denied') {
+						return 'denied'
+					}
+				} catch {
+					// Some browsers expose Permissions but cannot query geolocation.
+				}
+			}
+
+			return 'unsupported'
+		}
+	},
+	impl,
+}
+
+const permissionOwners = ((globalThis as any).__xplatPermissionOwners ??= {})
+permissionOwners.location = () => geolocation.ensure()

package/src/geolocation.windows.ts

@@ -0,0 +1,9 @@
+// Windows leaf — @nativescript/geolocation ships no windows entry, so the
+// capability reports unsupported rather than breaking the import graph.
+import type { Capability, GeolocationImpl } from './types'
+
+export const geolocation: Capability<GeolocationImpl> = {
+	supported: false,
+	ensure: async () => 'unsupported',
+	impl: null,
+}

package/src/index.macos.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export { geolocation } from './geolocation.macos'

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export { geolocation } from './geolocation'

package/src/types.ts

@@ -0,0 +1,29 @@
+/** Optional capability — never throws for absence (docs/platform/platform-services.md). */
+export interface Capability<T> {
+	supported: boolean
+	ensure(): Promise<'granted' | 'denied' | 'unsupported'>
+	/** usable iff supported && ensured */
+	impl: T | null
+}
+
+export type PermissionResult = 'granted' | 'denied' | 'unsupported'
+
+export interface GeolocationOptions {
+	enableHighAccuracy?: boolean
+	timeout?: number
+	maximumAge?: number
+}
+
+export interface GeolocationPosition {
+	latitude: number
+	longitude: number
+	accuracy: number
+	altitude: number | null
+	heading: number | null
+	speed: number | null
+	timestamp: number
+}
+
+export interface GeolocationImpl {
+	getCurrentPosition(options?: GeolocationOptions): Promise<GeolocationPosition>
+}

package/types/generated/.tsrx-typegen-manifest.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "files": [
+    "geolocation.d.ts",
+    "geolocation.macos.d.ts",
+    "geolocation.web.d.ts",
+    "geolocation.windows.d.ts",
+    "index.d.ts",
+    "index.macos.d.ts",
+    "types.d.ts"
+  ]
+}

package/types/generated/geolocation.d.ts

@@ -0,0 +1,2 @@
+import type { Capability, GeolocationImpl } from './types.js';
+export declare const geolocation: Capability<GeolocationImpl>;

package/types/generated/geolocation.macos.d.ts

@@ -0,0 +1,2 @@
+import type { Capability, GeolocationImpl } from './types.js';
+export declare const geolocation: Capability<GeolocationImpl>;

package/types/generated/geolocation.web.d.ts

@@ -0,0 +1,2 @@
+import type { Capability, GeolocationImpl } from './types.js';
+export declare const geolocation: Capability<GeolocationImpl>;

package/types/generated/geolocation.windows.d.ts

@@ -0,0 +1,2 @@
+import type { Capability, GeolocationImpl } from './types.js';
+export declare const geolocation: Capability<GeolocationImpl>;

package/types/generated/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export { geolocation } from './geolocation.js';

package/types/generated/index.macos.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export { geolocation } from './geolocation.macos.js';

package/types/generated/types.d.ts

@@ -0,0 +1,25 @@
+/** Optional capability — never throws for absence (docs/platform/platform-services.md). */
+export interface Capability<T> {
+    supported: boolean;
+    ensure(): Promise<'granted' | 'denied' | 'unsupported'>;
+    /** usable iff supported && ensured */
+    impl: T | null;
+}
+export type PermissionResult = 'granted' | 'denied' | 'unsupported';
+export interface GeolocationOptions {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+}
+export interface GeolocationPosition {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    heading: number | null;
+    speed: number | null;
+    timestamp: number;
+}
+export interface GeolocationImpl {
+    getCurrentPosition(options?: GeolocationOptions): Promise<GeolocationPosition>;
+}