Add basic permission management

src/constants/permission-state.ts

@@ -0,0 +1,5 @@
+import { StdPermissionState } from "../types/std.js";
+
+export const PROMPT = "prompt" satisfies StdPermissionState;
+export const GRANTED = "granted" satisfies StdPermissionState;
+export const DENIED = "denied" satisfies StdPermissionState;

src/geolocation-position-error.ts

@@ -6,6 +6,14 @@ const TIMEOUT: StdGeolocationPositionError["TIMEOUT"] = 3;
 
 let canConstruct = false;
 
+export function createPermissionDeniedError(
+  message: string,
+): StdGeolocationPositionError {
+  canConstruct = true;
+
+  return new GeolocationPositionError(PERMISSION_DENIED, message);
+}
+
 export function createPositionUnavailableError(
   message: string,
 ): StdGeolocationPositionError {

src/geolocation.ts

@@ -1,5 +1,6 @@
 import { errorMessage } from "./error.js";
 import {
+  createPermissionDeniedError,
   createPositionUnavailableError,
   createTimeoutError,
   isGeolocationPositionError,
@@ -67,9 +68,13 @@ export class Geolocation {
     throw new Error("Method not implemented clearWatch");
   }
 
-  #readPosition({
+  async #readPosition({
     timeout = Infinity,
   }: StdPositionOptions): Promise<StdGeolocationPosition> {
+    if (!(await this.#locationServices.requestPermission())) {
+      throw createPermissionDeniedError("");
+    }
+
     if (!Number.isFinite(timeout)) return this.#locationServices.getPosition();
 
     return new Promise((resolve, reject) => {

src/location-services.ts

@@ -1,17 +1,32 @@
 import { sleep } from "./async.js";
+import { GRANTED, PROMPT } from "./constants/permission-state.js";
 import { createPositionUnavailableError } from "./geolocation-position-error.js";
 import { createPosition } from "./geolocation-position.js";
-import { StdGeolocationPosition } from "./types/std.js";
+import { StdGeolocationPosition, StdPermissionState } from "./types/std.js";
 
 export interface LocationServices {
+  requestPermission(): Promise<boolean>;
   getPosition(): Promise<StdGeolocationPosition>;
+}
+
+export interface MutableLocationServices extends LocationServices {
+  setPermissionState(state: StdPermissionState): void;
   setPosition(position: StdGeolocationPosition | undefined): void;
 }
 
-export function createLocationServices(): LocationServices {
+export function createLocationServices(): MutableLocationServices {
+  let permissionState: StdPermissionState = PROMPT;
   let position: StdGeolocationPosition | undefined;
 
   return {
+    async requestPermission() {
+      return permissionState === GRANTED;
+    },
+
+    setPermissionState(nextState) {
+      permissionState = nextState;
+    },
+
     async getPosition() {
       // systems should not rely on the position being available immediately
       await sleep(0);

src/types/std.ts

@@ -5,3 +5,5 @@ export type StdGeolocationPositionError = globalThis.GeolocationPositionError;
 export type StdPositionCallback = globalThis.PositionCallback;
 export type StdPositionErrorCallback = globalThis.PositionErrorCallback;
 export type StdPositionOptions = globalThis.PositionOptions;
+
+export type StdPermissionState = globalThis.PermissionState;