Implement delegated Geolocation

src/delegated-geolocation.ts

@@ -0,0 +1,42 @@
+import { StdGeolocation } from "./types/std.js";
+
+let canConstruct = false;
+
+export function createDelegatedGeolocation(_: {
+  delegates: StdGeolocation[];
+}): {
+  geolocation: StdGeolocation;
+  selectDelegate: SelectDelegate;
+} {
+  canConstruct = true;
+
+  return {
+    geolocation: new Geolocation(),
+
+    selectDelegate() {},
+  };
+}
+
+export type SelectDelegate = (delegate: StdGeolocation) => void;
+
+export class Geolocation {
+  /**
+   * @deprecated Use the `createDelegatedPermissions()` function instead.
+   */
+  constructor() {
+    if (!canConstruct) throw new TypeError("Illegal constructor");
+    canConstruct = false;
+  }
+
+  getCurrentPosition(): void {
+    throw new Error("Not implemented");
+  }
+
+  watchPosition(): number {
+    throw new Error("Not implemented");
+  }
+
+  clearWatch(): void {
+    throw new Error("Not implemented");
+  }
+}

src/index.ts

@@ -1,3 +1,5 @@
+export { createDelegatedGeolocation } from "./delegated-geolocation.js";
+export type { SelectDelegate } from "./delegated-geolocation.js";
 export {
   GeolocationCoordinates,
   createCoordinates,

test/jest/delegated.spec.ts

@@ -0,0 +1,84 @@
+import {
+  Permissions,
+  createPermissionStore,
+  createPermissions,
+} from "fake-permissions";
+import { GEOLOCATION } from "fake-permissions/constants/permission-name";
+import { PROMPT } from "fake-permissions/constants/permission-state";
+import {
+  MutableLocationServices,
+  SelectDelegate,
+  User,
+  createDelegatedGeolocation,
+  createGeolocation,
+  createLocationServices,
+  createUser,
+} from "../../src/index.js";
+import { StdGeolocation } from "../../src/types/std.js";
+
+describe("Delegated geolocation", () => {
+  let locationServicesA: MutableLocationServices;
+  let locationServicesB: MutableLocationServices;
+  let permissionsA: Permissions<typeof GEOLOCATION>;
+  let permissionsB: Permissions<typeof GEOLOCATION>;
+  let userA: User<typeof GEOLOCATION>;
+  let userB: User<typeof GEOLOCATION>;
+  let delegateA: StdGeolocation;
+  let delegateB: StdGeolocation;
+  let geolocation: StdGeolocation;
+  let selectDelegate: SelectDelegate;
+
+  beforeEach(() => {
+    locationServicesA = createLocationServices();
+    locationServicesB = createLocationServices();
+
+    const permissionStoreA = createPermissionStore({
+      initialStates: new Map([[{ name: GEOLOCATION }, PROMPT]]),
+    });
+    const permissionStoreB = createPermissionStore({
+      initialStates: new Map([[{ name: GEOLOCATION }, PROMPT]]),
+    });
+
+    permissionsA = createPermissions({ permissionStore: permissionStoreA });
+    permissionsB = createPermissions({ permissionStore: permissionStoreB });
+
+    userA = createUser({
+      locationServices: locationServicesA,
+      permissionStore: permissionStoreA,
+    });
+    userB = createUser({
+      locationServices: locationServicesB,
+      permissionStore: permissionStoreB,
+    });
+
+    delegateA = createGeolocation({
+      async requestPermission(descriptor) {
+        return userA.requestPermission(descriptor);
+      },
+
+      locationServices: locationServicesA,
+      permissions: permissionsA,
+    });
+    delegateB = createGeolocation({
+      async requestPermission(descriptor) {
+        return userB.requestPermission(descriptor);
+      },
+
+      locationServices: locationServicesB,
+      permissions: permissionsB,
+    });
+
+    ({ geolocation, selectDelegate } = createDelegatedGeolocation({
+      delegates: [delegateA, delegateB],
+    }));
+  });
+
+  it("cannot be instantiated directly", async () => {
+    const instantiateGeolocation = () => {
+      new (geolocation.constructor as new (p: object) => unknown)({});
+    };
+
+    expect(instantiateGeolocation).toThrow(TypeError);
+    expect(instantiateGeolocation).toThrow("Illegal constructor");
+  });
+});