@mappedin/blue-dot 6.0.1-beta.57 → 6.0.1-beta.58

package/lib/esm/index.d.ts

@@ -1,18 +1,24 @@
 // Generated by dts-bundle v0.7.3
 // Dependencies for this module:
-//   ../blue-dot/@packages/internal/common/pubsub
 //   ../blue-dot/@mappedin/mappedin-js
+//   ../blue-dot/@packages/internal/common/extensions
+//   ../blue-dot/@packages/internal/common/pubsub
+//   ../blue-dot/type-fest
+//   ../blue-dot/zod
 //   ../blue-dot/three
 
 declare module '@mappedin/blue-dot' {
     export { BlueDot } from '@mappedin/blue-dot/blue-dot/src/blue-dot';
-    export type { BlueDotEvents, BlueDotEventPayloads, BlueDotPositionUpdate, BlueDotState, BlueDotAction, FollowMode, FollowCameraOptions, BlueDotOptions, } from '@mappedin/blue-dot/blue-dot/src/types';
+    export type { BlueDotEvents, BlueDotEventPayloads, BlueDotPositionUpdate, BlueDotStatus, BlueDotAction, FollowMode, FollowCameraOptions, BlueDotState, BlueDotPositionProcessor, BlueDotPositionUpdateWithFloor, BlueDotUpdateOptions, GeolocationPositionExtended, } from '@mappedin/blue-dot/blue-dot/src/types';
 }
 
 declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
+    import type { Floor, MapView, Model } from '@mappedin/mappedin-js';
+    import { Coordinate } from '@mappedin/mappedin-js';
+    import type { MapViewExtension } from '@packages/internal/common/extensions';
     import { PubSub } from '@packages/internal/common/pubsub';
-    import type { MapView } from '@mappedin/mappedin-js';
-    import type { BlueDotEventPayloads, BlueDotOptions, BlueDotPositionUpdate, BlueDotState, FollowCameraOptions, FollowMode } from '@mappedin/blue-dot/blue-dot/src/types';
+    import type { BlueDotEventPayloads, BlueDotState, BlueDotPositionProcessor, BlueDotPositionUpdate, BlueDotStatus, BlueDotUpdateOptions, FollowCameraOptions, FollowMode, GeolocationPositionExtended, BlueDotUpdateState } from '@mappedin/blue-dot/blue-dot/src/types';
+    import type { ReadonlyDeep } from 'type-fest';
     /**
         * Show a Blue Dot indicating the device's position on the map.
         *
@@ -36,45 +42,62 @@ declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
         *
         * ```
         */
-    export class BlueDot {
+    export class BlueDot implements MapViewExtension<BlueDotState> {
             #private;
             /**
                 * Create a new {@link BlueDot} instance.
                 */
             constructor(mapView: MapView);
+            /**
+                * Get the Model for the BlueDot core element.
+                */
+            get dotModel(): Model | undefined;
+            /**
+                * Get the Model for the accuracy ring.
+                */
+            get accuracyRingModel(): Model | undefined;
+            /**
+                * Get the Model for the heading cone.
+                */
+            get headingConeModel(): Model | undefined;
+            /**
+                * Whether the BlueDot is currently enabled.
+                */
+            get isEnabled(): boolean;
             /**
                 * The current state of the BlueDot. Can be 'hidden', 'active', 'inactive', or 'disabled'.
-                * Listen for state changes using the 'state-change' event.
+                * Listen for state changes using the 'status-change' event.
                 *
                 * @example
-                * mapView.BlueDot.on('state-change', ({ state }) => {
-                *   if (state === 'active') {
+                * mapView.BlueDot.on('status-change', ({ status }) => {
+                *   if (status === 'active') {
                 *     // BlueDot is visible and tracking
                 *   }
                 * });
                 */
-            get state(): BlueDotState;
+            get status(): BlueDotStatus;
             /**
                 * Whether the BlueDot is currently following the user (camera follow mode).
                 */
-            get following(): boolean;
+            get isFollowing(): boolean;
             /**
                 * The direction the user is facing in degrees from north clockwise.
                 * @see https://developer.mozilla.org/en-US/docs/Web/API/GeolocationCoordinates/heading
                 */
-            get heading(): number | null | undefined;
+            get heading(): GeolocationPosition['coords']['heading'] | undefined;
             /**
                 * The accuracy of the current position in metres.
                 */
-            get accuracy(): number | undefined;
+            get accuracy(): GeolocationPosition['coords']['accuracy'] | undefined;
             /**
                 * The coordinate of the current position.
                 */
-            get coordinate(): import("@mappedin/mappedin-js").Coordinate | undefined;
+            get coordinate(): Coordinate | undefined;
+            getState: () => ReadonlyDeep<BlueDotState>;
             /**
                 * The floor the Blue Dot is currently on. If undefined, the Blue Dot will appear on every floor.
                 */
-            get floor(): import("@mappedin/mappedin-js").Floor | undefined;
+            get floor(): Floor | undefined;
             /**
                 * Enable the Blue Dot. It will be hidden until a position is received either from the browser or by calling {@link BlueDot.update}.
                 * @param options - The options to setup the Blue Dot (see {@link BlueDotOptions}).
@@ -87,19 +110,41 @@ declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
                 *
                 * @see See the [BlueDot Guide](https://developer.mappedin.com/web-sdk/blue-dot) for more information.
                 */
-            enable: (options?: BlueDotOptions) => void;
+            enable: (options?: BlueDotUpdateState) => void;
             /**
                 * Disable the Blue Dot. It will be hidden and no longer update.
                 */
             disable: () => void;
+            /**
+                * Subscribe to a BlueDot event.
+                * @param eventName The name of the event to listen for.
+                * @param fn The function to call when the event is emitted.
+                */
             on: PubSub<BlueDotEventPayloads>['on'];
+            /**
+                * Unsubscribe from a BlueDot event.
+                * @param eventName The name of the event to unsubscribe from.
+                * @param fn The function to unsubscribe from the event.
+                */
             off: PubSub<BlueDotEventPayloads>['off'];
+            /**
+                * Update the BlueDot state after it has been enabled.
+                * This allows overriding previously set values like colors, and other options.
+                * @param options - The options to update
+                *
+                * @example Update color and accuracy ring
+                * mapView.BlueDot.updateState({
+                *   color: '#ff0000',
+                *   accuracyRing: { color: '#ff0000', opacity: 0.5 }
+                * });
+                */
+            updateState: (options: BlueDotUpdateState) => void;
             /**
                 * Enable or disable the devices's geolocation listener to automatically position the Blue Dot.
                 * If enabled, the device will request permission to access the user's precise location.
                 * @param watch - Whether to enable or disable the listener.
                 */
-            watchDevicePosition: (watch?: boolean) => void;
+            watchDevicePosition: (watch: boolean) => void;
             /**
                 * Manually override some position properties of the Blue Dot.
                 * Accepts a full GeolocationPosition object or a partial {@link BlueDotPositionUpdate} object.
@@ -112,7 +157,7 @@ declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
                 * api.BlueDot.update({ accuracy: 'device', heading: 'device' });
                 * ```
                 */
-            update: (position: BlueDotPositionUpdate) => void;
+            update: (position: GeolocationPositionExtended | BlueDotPositionUpdate | undefined, options?: BlueDotUpdateOptions) => void;
             /**
                 * Set the camera to follow the BlueDot in various modes. User interaction will cancel following automatically.
                 * @param mode The follow mode ('position-only', 'position-and-heading', 'position-and-path-direction', or false to disable).
@@ -122,13 +167,46 @@ declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
                 * mapView.BlueDot.follow('position-and-heading', { zoomLevel: 21, pitch: 45 });
                 */
             follow: (mode: FollowMode, cameraOptions?: FollowCameraOptions) => void;
+            /**
+                * Set a position processor callback that allows intercepting and modifying device/geolocation position updates before they are applied.
+                *
+                * **Note**: This processor only applies to automatic position updates from device geolocation.
+                * Manual position updates via `update()` method bypass the processor and are applied directly.
+                *
+                * @param processor - A callback function that receives current state and incoming update. Return undefined to discard the update, or return a modified update object.
+                *
+                * @example Discard inaccurate positions
+                * ```ts
+                * blueDot.setPositionProcessor((current, incoming) => {
+                *   if (incoming.accuracy && incoming.accuracy > 50) {
+                *     return undefined; // Discard update
+                *   }
+                *   return incoming; // Accept update
+                * });
+                * ```
+                *
+                * @example Modify incoming positions
+                * ```ts
+                * blueDot.setPositionProcessor((current, incoming) => {
+                *   // Apply custom smoothing or validation logic
+                *   return {
+                *     ...incoming,
+                *     accuracy: Math.min(incoming.accuracy || 100, 10) // Cap accuracy
+                *   };
+                * });
+                * ```
+                */
+            setPositionProcessor(processor?: BlueDotPositionProcessor): void;
             destroy: () => void;
     }
 }
 
 declare module '@mappedin/blue-dot/blue-dot/src/types' {
     import type { Coordinate, Floor } from '@mappedin/mappedin-js';
+    import type z from 'zod';
     import type { EasingCurve } from '@mappedin/blue-dot/packages/common';
+    import type { positionSchema } from '@mappedin/blue-dot/blue-dot/src/schemas';
+    import type { PartialDeep } from 'type-fest';
     export type FollowMode = 
     /** Camera position follows the Blue Dot's position. */
     'position-only'
@@ -177,15 +255,15 @@ declare module '@mappedin/blue-dot/blue-dot/src/types' {
                     coordinate: Coordinate;
             };
             /**
-                * Emitted when the Blue Dot's state changes.
+                * Emitted when the Blue Dot's status changes.
                 */
-            'state-change': {
+            'status-change': {
                     /**
-                        * The new state of the Blue Dot.
+                        * The new status of the Blue Dot.
                         */
-                    state: BlueDotState;
+                    status: BlueDotStatus;
                     /**
-                        * The action that caused the state change.
+                        * The action that caused the status change.
                         */
                     action: BlueDotAction;
             };
@@ -215,79 +293,98 @@ declare module '@mappedin/blue-dot/blue-dot/src/types' {
             /**
                 * Emitted when the user hovers over the Blue Dot.
                 */
-            hover: undefined;
+            hover: {
+                    coordinate: Coordinate;
+            };
     };
     export type BlueDotEvents = keyof BlueDotEventPayloads;
-    export type BlueDotState = 'hidden' | 'active' | 'inactive' | 'disabled';
+    export type BlueDotStatus = 'hidden' | 'active' | 'inactive' | 'disabled';
     export type BlueDotAction = 'timeout' | 'error' | 'position-update' | 'enable' | 'disable' | 'initialize';
-    export type BlueDotOptions = {
+    export type BlueDotState = {
             /**
                 * The radius of the BlueDot in pixels. The BlueDot will maintain this size clamped to a minimum of 0.35 metres.
                 * @default 10
                 */
-            radius?: number;
+            radius: number;
             /**
                 * The color of the BlueDot core element.
                 * @default #2266ff
                 */
-            color?: string;
+            color: string;
             /**
                 * The color of the BlueDot when it has timed out and gone inactive.
                 * @default #808080
                 */
-            inactiveColor?: string;
+            inactiveColor: string;
             /**
                 * Options for the accuracy ring around the BlueDot.
                 */
-            accuracyRing?: {
+            accuracyRing: {
                     /**
                         * The color of the accuracy ring.
                         * @default #2266ff
                         */
-                    color?: string;
+                    color: string;
                     /**
                         * The opacity of the accuracy ring.
                         * @default 0.3
                         */
-                    opacity?: number;
+                    opacity: number;
             };
             /**
                 * Options for the heading directional indicator.
                 */
-            heading?: {
+            heading: {
                     /**
                         * The color of the heading cone.
                         * @default #2266ff
                         */
-                    color?: string;
+                    color: string;
                     /**
                         * The opacity of the heading cone.
                         * @default 0.7
                         */
-                    opacity?: number;
+                    opacity: number;
+                    /**
+                        * Whether to display the heading cone when the BlueDot is inactive (timed out).
+                        * @default false
+                        */
+                    displayWhenInactive: boolean;
             };
             /**
                 * The duration of the timeout in milliseconds.
                 * If the BlueDot does not receive a position update within this time, it will grey out until a position is received.
                 * @default 30000
                 */
-            timeout?: number;
+            timeout: number;
             /**
                 * Whether to watch the device's position.
                 * @default true
                 */
-            watchDevicePosition?: boolean;
+            watchDevicePosition: boolean;
             /**
                 * Whether to log debug messages.
                 * @default false
                 */
-            debug?: boolean;
+            debug: boolean;
             /**
                 * The maximum acceptable accuracy in meters. Position updates with accuracy exceeding this value will be dropped.
                 * @default 50
                 */
-            accuracyThreshold?: number;
+            accuracyThreshold: number;
+            /**
+                * The initial state of the BlueDot when enabled.
+                * @default 'hidden'
+                */
+            initialState: 'hidden' | 'inactive';
+            /**
+                * @hidden
+                * Whether the BlueDot must remain within the map bounds. Disabling this will disable analytics as well.
+                * @default true
+                */
+            preventOutOfBounds: boolean;
     };
+    export type BlueDotUpdateState = PartialDeep<BlueDotState>;
     /**
         * Position update options for the {@link BlueDot.update} method.
         */
@@ -320,6 +417,43 @@ declare module '@mappedin/blue-dot/blue-dot/src/types' {
                 * Set to `undefined` to disable floor level and show the BlueDot on all floors.
                 */
             floorOrFloorId?: Floor | string | 'device' | undefined;
+            /**
+                * Timestamp of the position update in milliseconds.
+                */
+            timestamp?: number;
+    };
+    export type BlueDotPositionUpdateWithFloor = Omit<BlueDotPositionUpdate, 'floorOrFloorId'> & {
+            floor?: Floor | 'device' | undefined;
+    };
+    export type ParsedBlueDotPosition = z.infer<typeof positionSchema>;
+    export type BlueDotPositionProcessor = (current: BlueDotPositionUpdateWithFloor, incoming: BlueDotPositionUpdateWithFloor) => BlueDotPositionUpdateWithFloor | undefined;
+    export type StateTransitions = {
+            [Action in BlueDotAction]?: BlueDotStatus;
+    };
+    export type StateMachine = {
+            [State in BlueDotStatus]: {
+                    actions: StateTransitions;
+            };
+    };
+    /**
+        * Options for the BlueDot update method.
+        */
+    export type BlueDotUpdateOptions = {
+            /**
+                * If true, maintains the current state and skips timers and analytics for this update.
+                * @default false
+                */
+            silent?: boolean;
+            /**
+                * If true, animates the position change. If false, updates immediately.
+                * @default true
+                */
+            animate?: boolean;
+    };
+    export type GeolocationPositionExtended = GeolocationPosition & {
+            coords: GeolocationPosition['coords'] & {
+                    readonly floorLevel?: number;
+            };
     };
 }
 
@@ -337,6 +471,31 @@ declare module '@mappedin/blue-dot/packages/common' {
     export * from '@mappedin/blue-dot/packages/common/interpolate';
 }
 
+declare module '@mappedin/blue-dot/blue-dot/src/schemas' {
+    import z from 'zod';
+    export const geolocationPositionSchema: z.ZodObject<{
+        coords: z.ZodObject<{
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+            accuracy: z.ZodNumber;
+            altitude: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+            altitudeAccuracy: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+            heading: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+            speed: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+            floorLevel: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>;
+    export const positionSchema: z.ZodObject<{
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        floor: z.ZodOptional<z.ZodAny>;
+        accuracy: z.ZodOptional<z.ZodNumber>;
+        heading: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}
+
 declare module '@mappedin/blue-dot/packages/common/Mappedin.Logger' {
     export const MI_DEBUG_KEY = "mi-debug";
     export const MI_ERROR_LABEL = "[MappedinJS]";
@@ -447,6 +606,30 @@ declare module '@mappedin/blue-dot/packages/common/utils' {
     export { clampWithWarning } from '@mappedin/blue-dot/packages/common/math-utils';
     export { arraysEqual } from '@mappedin/blue-dot/packages/common/array-utils';
     export function isBrowser(): boolean;
+    /**
+        * Calculates the simple Euclidean distance between two geographic coordinates.
+        *
+        * This treats longitude and latitude as Cartesian coordinates on a flat plane.
+        * It's the fastest distance calculation but least accurate for geographic data.
+        * Best used for relative distance comparisons rather than actual measurements.
+        *
+        * @param point1 - The first point's longitude and latitude as [longitude, latitude].
+        * @param point2 - The second point's longitude and latitude as [longitude, latitude].
+        * @returns The Euclidean distance between the two points in meters.
+        */
+    export function euclideanDistance(point1: Position, point2: Position): number;
+    /**
+        * Calculates the approximate distance between two geographic coordinates on Earth's surface.
+        *
+        * This function uses the equirectangular approximation method to compute the distance, which simplifies
+        * the math and speeds up calculations, but is less accurate over long distances compared to other methods
+        * like the haversine formula.
+        *
+        * @param point1 - The first point's longitude and latitude as [longitude, latitude].
+        * @param point2 - The second point's longitude and latitude as [longitude, latitude].
+        * @returns The approximate distance between the two points in meters.
+        */
+    export function equirectangularDistance(point1: Position, point2: Position): number;
 }
 
 declare module '@mappedin/blue-dot/packages/common/async' {

package/lib/esm/index.js

@@ -1,233 +1,10 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import {
+  BlueDot,
+  init_define_process
+} from "./chunk-TPJ6NPMJ.js";
 
-// ../packages/common/pubsub.ts
-var PubSub = class {
-  static {
-    __name(this, "PubSub");
-  }
-  /**
-   * @private
-   * @internal
-   */
-  _subscribers = {};
-  /**
-   * @private
-   * @internal
-   */
-  _destroyed = false;
-  /**
-   * @private
-   * @internal
-   */
-  publish(eventName, data) {
-    if (!this._subscribers || !this._subscribers[eventName] || this._destroyed) {
-      return;
-    }
-    this._subscribers[eventName].forEach(function(fn) {
-      if (typeof fn !== "function") {
-        return;
-      }
-      fn(data);
-    });
-  }
-  /**
-   * Subscribe a function to an event.
-   *
-   * @param eventName An event name which, when fired, will call the provided
-   * function.
-   * @param fn A callback that gets called when the corresponding event is fired. The
-   * callback will get passed an argument with a type that's one of event payloads.
-   * @example
-   * // Subscribe to the 'click' event
-   * const handler = (event) => {
-   *  const { coordinate } = event;
-   *  const { latitude, longitude } = coordinate;
-   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
-   * };
-   * map.on('click', handler);
-   */
-  on(eventName, fn) {
-    if (!this._subscribers || this._destroyed) {
-      this._subscribers = {};
-    }
-    this._subscribers[eventName] = this._subscribers[eventName] || [];
-    this._subscribers[eventName].push(fn);
-  }
-  /**
-   * Unsubscribe a function previously subscribed with {@link on}
-   *
-   * @param eventName An event name to which the provided function was previously
-   * subscribed.
-   * @param fn A function that was previously passed to {@link on}. The function must
-   * have the same reference as the function that was subscribed.
-   * @example
-   * // Unsubscribe from the 'click' event
-   * const handler = (event) => {
-   * 	console.log('Map was clicked', event);
-   * };
-   * map.off('click', handler);
-   */
-  off(eventName, fn) {
-    if (!this._subscribers || this._subscribers[eventName] == null || this._destroyed) {
-      return;
-    }
-    const itemIdx = this._subscribers[eventName].indexOf(fn);
-    if (itemIdx !== -1) {
-      this._subscribers[eventName].splice(itemIdx, 1);
-    }
-  }
-  /**
-   * @private
-   * @internal
-   */
-  destroy() {
-    this._destroyed = true;
-    this._subscribers = {};
-  }
-};
-
-// src/blue-dot.ts
-var BlueDot = class {
-  static {
-    __name(this, "BlueDot");
-  }
-  #pubsub = new PubSub();
-  #mapView;
-  /**
-   * Create a new {@link BlueDot} instance.
-   */
-  constructor(mapView) {
-    this.#mapView = mapView;
-    this.#mapView.__BlueDot.on("blue-dot-position-error", (e) => {
-      this.#pubsub.publish("error", e);
-    });
-    this.#mapView.__BlueDot.on("blue-dot-position-update", (e) => {
-      this.#pubsub.publish("position-update", e);
-    });
-    this.#mapView.__BlueDot.on("blue-dot-state-change", (e) => {
-      this.#pubsub.publish("state-change", e);
-    });
-    this.#mapView.__BlueDot.on("blue-dot-follow-change", (e) => {
-      this.#pubsub.publish("follow-change", e);
-    });
-    this.#mapView.__BlueDot.on("click", (e) => {
-      this.#pubsub.publish("click", e);
-    });
-    this.#mapView.__BlueDot.on("hover", () => {
-      this.#pubsub.publish("hover");
-    });
-  }
-  /**
-   * The current state of the BlueDot. Can be 'hidden', 'active', 'inactive', or 'disabled'.
-   * Listen for state changes using the 'state-change' event.
-   *
-   * @example
-   * mapView.BlueDot.on('state-change', ({ state }) => {
-   *   if (state === 'active') {
-   *     // BlueDot is visible and tracking
-   *   }
-   * });
-   */
-  get state() {
-    return this.#mapView.__BlueDot.state;
-  }
-  /**
-   * Whether the BlueDot is currently following the user (camera follow mode).
-   */
-  get following() {
-    return this.#mapView.__BlueDot.following;
-  }
-  /**
-   * The direction the user is facing in degrees from north clockwise.
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/GeolocationCoordinates/heading
-   */
-  get heading() {
-    return this.#mapView.__BlueDot.heading;
-  }
-  /**
-   * The accuracy of the current position in metres.
-   */
-  get accuracy() {
-    return this.#mapView.__BlueDot.accuracy;
-  }
-  /**
-   * The coordinate of the current position.
-   */
-  get coordinate() {
-    return this.#mapView.__BlueDot.coordinate;
-  }
-  /**
-   * The floor the Blue Dot is currently on. If undefined, the Blue Dot will appear on every floor.
-   */
-  get floor() {
-    return this.#mapView.__BlueDot.floor;
-  }
-  /**
-   * Enable the Blue Dot. It will be hidden until a position is received either from the browser or by calling {@link BlueDot.update}.
-   * @param options - The options to setup the Blue Dot (see {@link BlueDotOptions}).
-   *
-   * @example Enable with default options
-   * mapView.BlueDot.enable();
-   *
-   * @example Enable with custom color and accuracy ring
-   * mapView.BlueDot.enable({ color: '#00ff00', accuracyRing: { color: '#00ff00', opacity: 0.2 } });
-   *
-   * @see See the [BlueDot Guide](https://developer.mappedin.com/web-sdk/blue-dot) for more information.
-   */
-  enable = /* @__PURE__ */ __name((options) => {
-    this.#mapView.__BlueDot.enable(options);
-  }, "enable");
-  /**
-   * Disable the Blue Dot. It will be hidden and no longer update.
-   */
-  disable = /* @__PURE__ */ __name(() => {
-    this.#mapView.__BlueDot.disable();
-  }, "disable");
-  on = /* @__PURE__ */ __name((eventName, fn) => {
-    this.#pubsub.on(eventName, fn);
-  }, "on");
-  off = /* @__PURE__ */ __name((eventName, fn) => {
-    this.#pubsub.off(eventName, fn);
-  }, "off");
-  /**
-   * Enable or disable the devices's geolocation listener to automatically position the Blue Dot.
-   * If enabled, the device will request permission to access the user's precise location.
-   * @param watch - Whether to enable or disable the listener.
-   */
-  watchDevicePosition = /* @__PURE__ */ __name((watch = true) => {
-    this.#mapView.__BlueDot.watchDevicePosition(watch);
-  }, "watchDevicePosition");
-  /**
-   * Manually override some position properties of the Blue Dot.
-   * Accepts a full GeolocationPosition object or a partial {@link BlueDotPositionUpdate} object.
-   * @example Manually set the accuracy and heading
-   * ```ts
-   * api.BlueDot.update({ accuracy: 10, heading: 90 });
-   * ```
-   * @example Reset accuracy and heading to device values
-   * ```ts
-   * api.BlueDot.update({ accuracy: 'device', heading: 'device' });
-   * ```
-   */
-  update = /* @__PURE__ */ __name((position) => {
-    this.#mapView.__BlueDot.update(position);
-  }, "update");
-  /**
-   * Set the camera to follow the BlueDot in various modes. User interaction will cancel following automatically.
-   * @param mode The follow mode ('position-only', 'position-and-heading', 'position-and-path-direction', or false to disable).
-   * @param cameraOptions Optional camera options (zoom, pitch, etc.).
-   *
-   * @example
-   * mapView.BlueDot.follow('position-and-heading', { zoomLevel: 21, pitch: 45 });
-   */
-  follow = /* @__PURE__ */ __name((mode, cameraOptions) => {
-    this.#mapView.__BlueDot.follow(mode, cameraOptions);
-  }, "follow");
-  destroy = /* @__PURE__ */ __name(() => {
-    this.#pubsub.destroy();
-  }, "destroy");
-};
+// src/index.ts
+init_define_process();
 export {
   BlueDot
 };