@tokamakdev/plugin-location 0.1.0-beta.106 → 0.1.0-beta.112

package/events/index.ts

@@ -1,18 +1,18 @@
 import { defineEvent } from "@tokamakdev/plugin/events";
 
-import type { LocationErrorEvent, LocationUpdate, RegionTransition, Visit } from "../src/index.js";
+import "../src/types.js";
 
 /**
  * Receives the positions of continuous updates and significant changes in native builds: on
  * screen, off screen, or after the system launches the app for them.
  */
-export const onLocationUpdate = defineEvent<LocationUpdate>("location.update");
+export const onLocationUpdate = defineEvent("location.update");
 
 /** Receives each region entry or exit, including one that launches the app. */
-export const onRegionTransition = defineEvent<RegionTransition>("location.region");
+export const onRegionTransition = defineEvent("location.region");
 
 /** Apple only: receives each arrival at or departure from a place, including one that launches the app. */
-export const onVisit = defineEvent<Visit>("location.visit");
+export const onVisit = defineEvent("location.visit");
 
 /** Receives failures of background location services, such as a region the system cannot monitor. */
-export const onLocationError = defineEvent<LocationErrorEvent>("location.error");
+export const onLocationError = defineEvent("location.error");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamakdev/plugin-location",
-  "version": "0.1.0-beta.106",
+  "version": "0.1.0-beta.112",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mantty/tokamak.git",
@@ -9,10 +9,12 @@
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
-    "./events": "./events/index.ts"
+    "./events": "./events/index.ts",
+    "./apple": "./apple/bindings.ts",
+    "./android": "./android/bindings.ts"
   },
   "peerDependencies": {
-    "@tokamakdev/plugin": "0.1.0-beta.106"
+    "@tokamakdev/plugin": "0.1.0-beta.112"
   },
   "files": [
     "android",

package/src/android.ts

@@ -0,0 +1,138 @@
+import type { TokamakContext } from "@tokamakdev/plugin";
+import { applicationContext, release } from "@tokamakdev/plugin/bindings";
+
+import {
+  CancellationSignal,
+  Consumer,
+  Context,
+  Location,
+  LocationListener,
+  LocationManager,
+  SystemClock,
+  type Executor,
+} from "../android/bindings.js";
+import { permissionDenied, unavailable, within } from "./errors.js";
+import type { Position, PositionOptions } from "./types.js";
+
+/**
+ * The device's position: the provider's last known when no older than `maximumAge`, or a new fix
+ * within `timeout`. Null when Android finds none.
+ */
+export async function currentPosition(ctx: TokamakContext, { maximumAge = 0, timeout }: PositionOptions): Promise<Position | null> {
+  const { context, manager } = await locationManager(ctx);
+  const name = await provider(manager);
+  const recent = await manager.getLastKnownLocation(name);
+  if (recent && await age(ctx, recent) <= maximumAge) return await position(recent);
+  const [signal, executor] = await Promise.all([CancellationSignal.new(ctx), mainExecutor(context)]);
+  let consumer: Consumer | undefined;
+  let finished = false;
+  const found = new Promise<Position | null>((resolve, reject) => {
+    Consumer.implement(ctx, {
+      accept(location) { resolve(location instanceof Location ? position(location) : null); },
+    }).then(async (created) => {
+      consumer = created;
+      if (finished) {
+        release(created);
+        return;
+      }
+      await manager.getCurrentLocation(name, signal, executor, created);
+    }).catch((failure: unknown) => { reject(locationError(failure as Error)); });
+  });
+  return within(found, timeout, () => {
+    finished = true;
+    void signal.cancel();
+    if (consumer) release(consumer);
+  });
+}
+
+/** Passes each position the provider reports to `next`, and its failures to `error`, until the returned function is called. */
+export async function watchPositions(
+  ctx: TokamakContext,
+  next: (position: Position) => void,
+  error: (error: unknown) => void,
+): Promise<() => void> {
+  const { context, manager } = await locationManager(ctx);
+  const [name, executor] = await Promise.all([provider(manager), mainExecutor(context)]);
+  const listener = await LocationListener.implement(ctx, {
+    async onLocationChanged(location) {
+      next(await position(location));
+      release(location);
+    },
+    onProviderDisabled() { error(unavailable("Location provider is unavailable")); },
+  });
+  try {
+    await manager.requestLocationUpdates(name, 1000, 0, executor, listener);
+  } catch (failure) {
+    release(listener);
+    throw locationError(failure as Error);
+  }
+  return () => {
+    void manager.removeUpdates(listener).finally(() => { release(listener); });
+  };
+}
+
+async function locationManager(ctx: TokamakContext): Promise<{ context: Context; manager: LocationManager }> {
+  const context = new Context(await applicationContext(ctx));
+  const manager = await context.getSystemService(Context.LOCATION_SERVICE);
+  if (!(manager instanceof LocationManager)) throw unavailable("The device has no location service");
+  return { context, manager };
+}
+
+async function mainExecutor(context: Context): Promise<Executor> {
+  const executor = await context.getMainExecutor();
+  if (!executor) throw unavailable("The app has no main executor");
+  return executor;
+}
+
+/** The first enabled of the GPS, network and fused providers, or any other enabled provider. */
+async function provider(manager: LocationManager): Promise<string> {
+  for (const name of [LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER, LocationManager.FUSED_PROVIDER]) {
+    if (await manager.isProviderEnabled(name)) return name;
+  }
+  const [other] = await manager.getProviders(true);
+  if (!other) throw unavailable("No location provider is available");
+  return other;
+}
+
+/** The milliseconds since Android took `location`. */
+async function age(ctx: TokamakContext, location: Location): Promise<number> {
+  const [now, taken] = await Promise.all([SystemClock.elapsedRealtimeNanos(ctx), location.getElapsedRealtimeNanos()]);
+  return (now - taken) / 1_000_000;
+}
+
+async function position(location: Location): Promise<Position> {
+  const [latitude, longitude, accuracy, hasAltitude, altitude, hasVertical, vertical, hasBearing, bearing, hasSpeed, speed, time] =
+    await Promise.all([
+      location.getLatitude(),
+      location.getLongitude(),
+      location.getAccuracy(),
+      location.hasAltitude(),
+      location.getAltitude(),
+      location.hasVerticalAccuracy(),
+      location.getVerticalAccuracyMeters(),
+      location.hasBearing(),
+      location.getBearing(),
+      location.hasSpeed(),
+      location.getSpeed(),
+      location.getTime(),
+    ]);
+  return {
+    coords: {
+      latitude,
+      longitude,
+      accuracy,
+      altitude: hasAltitude ? altitude : null,
+      altitudeAccuracy: hasVertical ? vertical : null,
+      heading: hasBearing ? bearing : null,
+      speed: hasSpeed ? speed : null,
+    },
+    timestamp: time,
+  };
+}
+
+/** The error a failed Android call rejected with, as location operations name it. */
+function locationError(failure: Error): Error {
+  if (!(failure instanceof DOMException)) return failure;
+  const exception = (failure.cause as { exception?: string } | undefined)?.exception;
+  return exception === "java.lang.SecurityException" ? permissionDenied() : unavailable(failure.message);
+}

package/src/apple.ts

@@ -0,0 +1,117 @@
+import type { TokamakContext } from "@tokamakdev/plugin";
+import { release } from "@tokamakdev/plugin/bindings";
+
+import { CLLocationManager, CLLocationManagerDelegate, type CLLocation } from "../apple/bindings.js";
+import { permissionDenied, unavailable, within } from "./errors.js";
+import type { Position, PositionOptions } from "./types.js";
+
+/** The Core Location error codes the plugin tells apart. */
+const locationUnknown = 0;
+const denied = 1;
+
+/** The device's position: Core Location's latest when no older than `maximumAge`, or a new fix within `timeout`. */
+export async function currentPosition(ctx: TokamakContext, { maximumAge = 0, timeout }: PositionOptions): Promise<Position> {
+  const manager = await CLLocationManager.init(ctx);
+  try {
+    const recent = await manager.location();
+    if (recent && Date.now() - (await recent.timestamp()).getTime() <= maximumAge) return await position(recent);
+    return await nextFix(ctx, manager, timeout);
+  } finally {
+    release(manager);
+  }
+}
+
+/** The next fix `manager` takes, asking again while Core Location does not know the position yet. */
+function nextFix(ctx: TokamakContext, manager: CLLocationManager, timeout: number | undefined): Promise<Position> {
+  let delegate: CLLocationManagerDelegate | undefined;
+  let finished = false;
+  const found = new Promise<Position>((resolve, reject) => {
+    CLLocationManagerDelegate.implement(ctx, {
+      locationManagerDidUpdateLocations(_, locations) {
+        const latest = locations.at(-1);
+        if (latest) resolve(position(latest));
+      },
+      locationManagerDidFailWithError(_, error) {
+        if (code(error) === locationUnknown) manager.requestLocation().catch(reject);
+        else reject(locationError(error));
+      },
+    }).then(async (created) => {
+      delegate = created;
+      if (finished) {
+        release(created);
+        return;
+      }
+      await manager.setDelegate(created);
+      await manager.requestLocation();
+    }).catch(reject);
+  });
+  return within(found, timeout, () => {
+    finished = true;
+    if (delegate) release(delegate);
+  });
+}
+
+/** Passes each position Core Location reports to `next`, and its failures to `error`, until the returned function is called. */
+export async function watchPositions(
+  ctx: TokamakContext,
+  next: (position: Position) => void,
+  error: (error: unknown) => void,
+): Promise<() => void> {
+  const manager = await CLLocationManager.init(ctx);
+  const delegate = await CLLocationManagerDelegate.implement(ctx, {
+    async locationManagerDidUpdateLocations(updated, locations) {
+      release(updated);
+      for (const location of locations) {
+        next(await position(location));
+        release(location);
+      }
+    },
+    locationManagerDidFailWithError(updated, failure) {
+      release(updated);
+      if (code(failure) !== locationUnknown) error(locationError(failure));
+    },
+  });
+  await manager.setDelegate(delegate);
+  await manager.startUpdatingLocation();
+  return () => {
+    void manager.stopUpdatingLocation().finally(() => {
+      release(delegate);
+      release(manager);
+    });
+  };
+}
+
+async function position(location: CLLocation): Promise<Position> {
+  const [coordinate, accuracy, altitude, verticalAccuracy, course, speed, timestamp] = await Promise.all([
+    location.coordinate(),
+    location.horizontalAccuracy(),
+    location.altitude(),
+    location.verticalAccuracy(),
+    location.course(),
+    location.speed(),
+    location.timestamp(),
+  ]);
+  // Core Location reports a negative accuracy, course or speed when it has none.
+  return {
+    coords: {
+      latitude: coordinate.latitude,
+      longitude: coordinate.longitude,
+      accuracy,
+      altitude: verticalAccuracy >= 0 ? altitude : null,
+      altitudeAccuracy: verticalAccuracy >= 0 ? verticalAccuracy : null,
+      heading: course >= 0 ? course : null,
+      speed: speed >= 0 ? speed : null,
+    },
+    timestamp: timestamp.getTime(),
+  };
+}
+
+/** The code of a Core Location error. */
+function code(error: DOMException): number | undefined {
+  const cause = error.cause as { domain?: string; code?: number } | undefined;
+  return cause?.domain === "kCLErrorDomain" ? cause.code : undefined;
+}
+
+function locationError(error: DOMException): DOMException {
+  return code(error) === denied ? permissionDenied() : unavailable(error.message);
+}

package/src/errors.ts

@@ -0,0 +1,34 @@
+/** The errors location operations reject with. */
+
+export function permissionDenied(): DOMException {
+  return new DOMException("Location permission was denied", "NotAllowedError");
+}
+
+export function backgroundDenied(): DOMException {
+  return new DOMException("Location permission does not cover the background", "NotAllowedError");
+}
+
+export function timedOut(): DOMException {
+  return new DOMException("Location was not found in time", "TimeoutError");
+}
+
+export function unavailable(message: string): DOMException {
+  return new DOMException(message, "NotReadableError");
+}
+
+/**
+ * Rejects once `timeout` milliseconds pass without `found` settling, running `stop` either way. An
+ * undefined `timeout` waits as long as it takes.
+ */
+export async function within<T>(found: Promise<T>, timeout: number | undefined, stop: () => void): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const expired = new Promise<never>((_, reject) => {
+    if (timeout !== undefined) timer = setTimeout(() => { reject(timedOut()); }, timeout);
+  });
+  try {
+    return await Promise.race([found, expired]);
+  } finally {
+    clearTimeout(timer);
+    stop();
+  }
+}

package/src/index.ts

@@ -1,18 +1,16 @@
-import { Plugin } from "@tokamakdev/plugin";
-import * as web from "../web/index.js";
-import { nonEmptyText } from "./checks.js";
-import { monitoredRegion, validatePermissionRequest, validateSetup, validateUpdateOptions } from "./options.js";
+import { Plugin, lifecycleStage, type JsonStream, type TokamakContext } from "@tokamakdev/plugin";
+import { valueStream } from "@tokamakdev/plugin/streams";
+
+import * as android from "./android.js";
+import * as apple from "./apple.js";
+import { backgroundDenied, permissionDenied, unavailable } from "./errors.js";
 import type {
-  ErrorListener,
-  Listener,
   LocationErrorEvent,
   LocationPermission,
   LocationUpdate,
   MonitoredRegion,
   PermissionRequest,
   Position,
-  PositionCallback,
-  PositionErrorCallback,
   PositionOptions,
   Region,
   RegionTransition,
@@ -24,37 +22,78 @@ import type {
 export type * from "./types.js";
 
 class Location extends Plugin {
-  constructor() {
-    super("location");
+  readonly #ctx: TokamakContext;
+
+  constructor(ctx: TokamakContext) {
+    super(ctx, "location");
+    this.#ctx = ctx;
   }
 
   /**
    * Applies long-term location awareness, replacing the previous configuration, which the plugin keeps
-   * and applies again at each start. Rejects with `TypeError`, changing nothing, when a value is
-   * invalid, and on Apple platforms with `NotSupportedError` where the device cannot monitor
-   * significant changes.
+   * and applies again at each start. Rejects on Apple platforms with `NotSupportedError` where the
+   * device cannot monitor significant changes.
    */
-  async setup(config: SetupConfig): Promise<void> {
-    validateSetup(config, "config");
-    return this.hasNativeTransport ? this.call("setup", config) : web.unsupported();
+  setup(config: SetupConfig): Promise<void> {
+    return this.call("setup", config);
   }
 
-  getCurrentPosition(options: PositionOptions = {}): Promise<Position> {
-    if (!this.hasNativeTransport) return web.getCurrentPosition(options);
-    return this.call("getCurrentPosition", {
-      maximumAge: milliseconds(options.maximumAge ?? 0),
-      timeout: milliseconds(options.timeout ?? unlimited),
-    });
-  }
-
-  watchPosition(next: PositionCallback, error: PositionErrorCallback): () => void {
-    if (!this.hasNativeTransport) return web.watchPosition(next, error);
-    return this.listen("watchPosition", next, error);
+  /**
+   * The device's position, asking for in-use permission where the user has not answered. Rejects
+   * with `NotAllowedError` without it, `TimeoutError` after `timeout`, and `NotReadableError`
+   * when location is unavailable.
+   */
+  async getCurrentPosition(options: PositionOptions = {}): Promise<Position> {
+    await this.#authorize();
+    const position = await this.#platform().currentPosition(this.#ctx, options);
+    if (position) return position;
+    // Android finds no position in the background without background permission.
+    const background = await lifecycleStage(this.#ctx) === "background";
+    throw background && (await this.permission()).background !== "granted" ? backgroundDenied() : unavailable("Location is unavailable");
+  }
+
+  /** Positions as the device moves, after `getCurrentPosition`'s permission checks. A slow reader receives the newest. */
+  watchPosition(): JsonStream<Position> {
+    return valueStream<Position>((next, error) => {
+      let stop: (() => void) | undefined;
+      let stopped = false;
+      this.#authorize()
+        .then(() => this.#platform().watchPositions(this.#ctx, next, error))
+        .then((started) => {
+          if (stopped) started();
+          else stop = started;
+        }, error);
+      return () => {
+        stopped = true;
+        stop?.();
+      };
+    }, "dropOldest");
+  }
+
+  /** Requires location services and in-use permission, asking for it where the user has not answered. */
+  async #authorize(): Promise<void> {
+    if (!await this.servicesEnabled()) throw unavailable("Location services are disabled");
+    let { inUse } = await this.permission();
+    if (inUse === "prompt") ({ inUse } = await this.requestPermission());
+    if (inUse !== "granted") throw permissionDenied();
+  }
+
+  /** The platform's composition of its location SDK. */
+  #platform(): typeof apple | typeof android {
+    switch (this.#ctx.platform) {
+      case "ios":
+      case "macos":
+        return apple;
+      case "android":
+        return android;
+      default:
+        throw new DOMException("Location is not supported on this platform", "NotSupportedError");
+    }
   }
 
   /** The app's in-use and background permission, and the precision it gets. Never asks. */
   permission(): Promise<LocationPermission> {
-    return this.hasNativeTransport ? this.call("permission") : web.permission();
+    return this.call("permission");
   }
 
   /**
@@ -62,19 +101,18 @@ class Location extends Plugin {
    * Android asks for background permission once in-use permission is granted. Rejects with
    * `NeedsUIError` when a prompt would show off screen.
    */
-  async requestPermission(options: PermissionRequest = {}): Promise<LocationPermission> {
-    validatePermissionRequest(options, "options");
-    return this.hasNativeTransport ? this.call("requestPermission", options) : web.unsupported();
+  requestPermission(options: PermissionRequest = {}): Promise<LocationPermission> {
+    return this.call("requestPermission", options);
   }
 
   /** Whether location services are on for the device. While they are off, nothing locates. */
   servicesEnabled(): Promise<boolean> {
-    return this.hasNativeTransport ? this.call("servicesEnabled") : web.unsupported();
+    return this.call("servicesEnabled");
   }
 
   /** Opens the app's page in the system settings, where the user changes its location permission. */
   openSettings(): Promise<void> {
-    return this.hasNativeTransport ? this.call("openSettings") : web.unsupported();
+    return this.call("openSettings");
   }
 
   /**
@@ -85,18 +123,17 @@ class Location extends Plugin {
    * without the `background-updates` build setting, and with `NeedsUIError` when Android does not
    * allow the service to start off screen.
    */
-  async startUpdates(options: UpdateOptions = {}): Promise<void> {
-    validateUpdateOptions(options, "options");
-    return this.hasNativeTransport ? this.call("startUpdates", options) : web.unsupported();
+  startUpdates(options: UpdateOptions = {}): Promise<void> {
+    return this.call("startUpdates", options);
   }
 
   stopUpdates(): Promise<void> {
-    return this.hasNativeTransport ? this.call("stopUpdates") : web.unsupported();
+    return this.call("stopUpdates");
   }
 
   /** The options of the running updates, or null when none are running. */
   getUpdates(): Promise<UpdateOptions | null> {
-    return this.hasNativeTransport ? this.call("getUpdates") : web.unsupported();
+    return this.call("getUpdates");
   }
 
   /**
@@ -105,51 +142,39 @@ class Location extends Plugin {
    * region starts outside, so a device already inside reports an entry. Rejects with
    * `NotAllowedError` without precise location, and with `QuotaExceededError` beyond Apple's 20.
    */
-  async addRegion(region: Region): Promise<void> {
-    const monitored = monitoredRegion(region);
-    return this.hasNativeTransport ? this.call("addRegion", monitored) : web.unsupported();
+  addRegion(region: Region): Promise<void> {
+    return this.call("addRegion", region);
   }
 
   /** The monitored regions. */
   getRegions(): Promise<MonitoredRegion[]> {
-    return this.hasNativeTransport ? this.call("getRegions") : web.unsupported();
+    return this.call("getRegions");
   }
 
-  async removeRegion(id: string): Promise<void> {
-    nonEmptyText(id, "id");
-    return this.hasNativeTransport ? this.call("removeRegion", { id }) : web.unsupported();
+  removeRegion(id: string): Promise<void> {
+    return this.call("removeRegion", { id });
   }
 
   /** Receives the updates the Worker's `onLocationUpdate` receives, while the listening page or Worker runs. */
-  onLocationUpdate(listener: Listener<LocationUpdate>, error: ErrorListener = report): () => void {
-    return this.hasNativeTransport ? this.listen("onLocationUpdate", listener, error) : () => undefined;
+  onLocationUpdate(): JsonStream<LocationUpdate> {
+    return this.stream("onLocationUpdate", null, "dropOldest");
   }
 
   /** Receives the transitions the Worker's `onRegionTransition` receives, while the listening page or Worker runs. */
-  onRegionTransition(listener: Listener<RegionTransition>, error: ErrorListener = report): () => void {
-    return this.hasNativeTransport ? this.listen("onRegionTransition", listener, error) : () => undefined;
+  onRegionTransition(): JsonStream<RegionTransition> {
+    return this.stream("onRegionTransition");
   }
 
   /** Apple only: receives the visits the Worker's `onVisit` receives, while the listening page or Worker runs. */
-  onVisit(listener: Listener<Visit>, error: ErrorListener = report): () => void {
-    return this.hasNativeTransport ? this.listen("onVisit", listener, error) : () => undefined;
+  onVisit(): JsonStream<Visit> {
+    return this.stream("onVisit");
   }
 
   /** Receives the failures the Worker's `onLocationError` receives, while the listening page or Worker runs. */
-  onLocationError(listener: Listener<LocationErrorEvent>, error: ErrorListener = report): () => void {
-    return this.hasNativeTransport ? this.listen("onLocationError", listener, error) : () => undefined;
+  onLocationError(): JsonStream<LocationErrorEvent> {
+    return this.stream("onLocationError");
   }
 }
 
-function report(error: DOMException): void {
-  console.error(error);
-}
-
-const unlimited = 0xffffffff;
-
-/** `value` clamped to whole milliseconds, as the Geolocation API reads its options. */
-function milliseconds(value: number): number {
-  return Number.isNaN(value) ? 0 : Math.min(Math.max(Math.round(value), 0), unlimited);
-}
 
-export const location = new Location();
+export function location(ctx: TokamakContext): Location { return new Location(ctx); }

package/src/types.ts

@@ -174,3 +174,15 @@ export interface LocationErrorEvent {
 
 export type Listener<T> = (event: T) => void;
 export type ErrorListener = (error: DOMException) => void;
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace -- events are declared by merging into Tokamak.Events.
+  namespace Tokamak {
+    interface Events {
+      "location.update": LocationUpdate;
+      "location.region": RegionTransition;
+      "location.visit": Visit;
+      "location.error": LocationErrorEvent;
+    }
+  }
+}

package/tokamak-plugin.json

@@ -1,6 +1,26 @@
 {
-  "schemaVersion": 1,
+  "schemaVersion": 2,
   "id": "location",
+  "bindings": {
+    "apple": {
+      "sdk": "26.2",
+      "modules": [
+        "CoreLocation",
+        "_LocationEssentials"
+      ]
+    },
+    "android": {
+      "sdk": 35,
+      "modules": [
+        "android.location",
+        "android.content.Context",
+        "android.os.CancellationSignal",
+        "android.os.SystemClock",
+        "java.util.concurrent.Executor",
+        "java.util.function.Consumer"
+      ]
+    }
+  },
   "settings": {
     "background": {
       "kind": "boolean",
@@ -14,7 +34,10 @@
     },
     "precision": {
       "kind": "enum",
-      "values": ["precise", "approximate"],
+      "values": [
+        "precise",
+        "approximate"
+      ],
       "default": "precise",
       "description": "The precision the app declares; approximate leaves out precise location"
     },
@@ -63,5 +86,49 @@
         "android/LocationUpdates.kt"
       ]
     }
+  },
+  "api": {
+    "module": "src/index.ts",
+    "export": "location"
+  },
+  "web": {
+    "module": "web/client.ts",
+    "export": "location"
+  },
+  "operations": {
+    "getCurrentPosition": {
+      "foreground": [
+        "ios"
+      ]
+    },
+    "watchPosition": {
+      "foreground": [
+        "ios"
+      ]
+    },
+    "requestPermission": {
+      "foreground": [
+        "ios",
+        "android"
+      ]
+    },
+    "openSettings": {
+      "foreground": [
+        "ios",
+        "android"
+      ]
+    },
+    "startUpdates": {
+      "foreground": [
+        "ios",
+        "android"
+      ]
+    },
+    "onVisit": {
+      "platforms": {
+        "ios": true,
+        "macos": true
+      }
+    }
   }
 }