react-bkoi-gl 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './exports-mapbox';
+export { default as default } from './exports-mapbox';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./exports-mapbox.js";
+export { default } from "./exports-mapbox.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["default"],"sources":["../src/index.ts"],"sourcesContent":["export * from './exports-mapbox';\nexport {default as default} from './exports-mapbox';\n"],"mappings":";SACQA,OAAkB","ignoreList":[]}

package/dist/mapbox/create-ref.d.ts

@@ -0,0 +1,9 @@
+import type { MapInstance, MapStyle, Callbacks } from '../types';
+import type Mapbox from './mapbox';
+/** These methods may break the react binding if called directly */
+declare const skipMethods: readonly ["setMaxBounds", "setMinZoom", "setMaxZoom", "setMinPitch", "setMaxPitch", "setRenderWorldCopies", "setProjection", "setStyle", "addSource", "removeSource", "addLayer", "removeLayer", "setLayerZoomRange", "setFilter", "setPaintProperty", "setLayoutProperty", "setLight", "setTerrain", "setFog", "remove"];
+export declare type MapRef<MapT extends MapInstance> = {
+    getMap(): MapT;
+} & Omit<MapT, typeof skipMethods[number]>;
+export default function createRef<StyleT extends MapStyle, CallbacksT extends Callbacks, MapT extends MapInstance>(mapInstance: Mapbox<StyleT, CallbacksT, MapT>): MapRef<MapT> | null;
+export {};

package/dist/mapbox/create-ref.js

@@ -0,0 +1,64 @@
+const skipMethods = ['setMaxBounds', 'setMinZoom', 'setMaxZoom', 'setMinPitch', 'setMaxPitch', 'setRenderWorldCopies', 'setProjection', 'setStyle', 'addSource', 'removeSource', 'addLayer', 'removeLayer', 'setLayerZoomRange', 'setFilter', 'setPaintProperty', 'setLayoutProperty', 'setLight', 'setTerrain', 'setFog', 'remove'];
+export default function createRef(mapInstance) {
+  if (!mapInstance) {
+    return null;
+  }
+  const map = mapInstance.map;
+  const result = {
+    getMap: () => map,
+    getCenter: () => mapInstance.transform.center,
+    getZoom: () => mapInstance.transform.zoom,
+    getBearing: () => mapInstance.transform.bearing,
+    getPitch: () => mapInstance.transform.pitch,
+    getPadding: () => mapInstance.transform.padding,
+    getBounds: () => mapInstance.transform.getBounds(),
+    project: lnglat => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.project(lnglat);
+      map.transform = tr;
+      return result;
+    },
+    unproject: point => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.unproject(point);
+      map.transform = tr;
+      return result;
+    },
+    queryTerrainElevation: (lnglat, options) => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.queryTerrainElevation(lnglat, options);
+      map.transform = tr;
+      return result;
+    },
+    queryRenderedFeatures: (geometry, options) => {
+      const tr = map.transform;
+      map.transform = mapInstance.transform;
+      const result = map.queryRenderedFeatures(geometry, options);
+      map.transform = tr;
+      return result;
+    }
+  };
+  for (const key of getMethodNames(map)) {
+    if (!(key in result) && !skipMethods.includes(key)) {
+      result[key] = map[key].bind(map);
+    }
+  }
+  return result;
+}
+function getMethodNames(obj) {
+  const result = new Set();
+  let proto = obj;
+  while (proto) {
+    for (const key of Object.getOwnPropertyNames(proto)) {
+      if (key[0] !== '_' && typeof obj[key] === 'function' && key !== 'fire' && key !== 'setEventedParent') {
+        result.add(key);
+      }
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Array.from(result);
+}
+//# sourceMappingURL=create-ref.js.map

package/dist/mapbox/create-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ref.js","names":["skipMethods","createRef","mapInstance","map","result","getMap","getCenter","transform","center","getZoom","zoom","getBearing","bearing","getPitch","pitch","getPadding","padding","getBounds","project","lnglat","tr","unproject","point","queryTerrainElevation","options","queryRenderedFeatures","geometry","key","getMethodNames","includes","bind","obj","Set","proto","Object","getOwnPropertyNames","add","getPrototypeOf","Array","from"],"sources":["../../src/mapbox/create-ref.ts"],"sourcesContent":["import type {\n  MapInstance,\n  MapInstanceInternal,\n  MapStyle,\n  Callbacks,\n  LngLatLike,\n  PointLike\n} from '../types';\nimport type Mapbox from './mapbox';\n\n/** These methods may break the react binding if called directly */\nconst skipMethods = [\n  'setMaxBounds',\n  'setMinZoom',\n  'setMaxZoom',\n  'setMinPitch',\n  'setMaxPitch',\n  'setRenderWorldCopies',\n  'setProjection',\n  'setStyle',\n  'addSource',\n  'removeSource',\n  'addLayer',\n  'removeLayer',\n  'setLayerZoomRange',\n  'setFilter',\n  'setPaintProperty',\n  'setLayoutProperty',\n  'setLight',\n  'setTerrain',\n  'setFog',\n  'remove'\n] as const;\n\nexport type MapRef<MapT extends MapInstance> = {\n  getMap(): MapT;\n} & Omit<MapT, typeof skipMethods[number]>;\n\nexport default function createRef<\n  StyleT extends MapStyle,\n  CallbacksT extends Callbacks,\n  MapT extends MapInstance\n>(mapInstance: Mapbox<StyleT, CallbacksT, MapT>): MapRef<MapT> | null {\n  if (!mapInstance) {\n    return null;\n  }\n\n  const map = mapInstance.map as MapInstanceInternal<MapT>;\n  const result: any = {\n    getMap: () => map,\n\n    // Overwrite getters to use our shadow transform\n    getCenter: () => mapInstance.transform.center,\n    getZoom: () => mapInstance.transform.zoom,\n    getBearing: () => mapInstance.transform.bearing,\n    getPitch: () => mapInstance.transform.pitch,\n    getPadding: () => mapInstance.transform.padding,\n    getBounds: () => mapInstance.transform.getBounds(),\n    project: (lnglat: LngLatLike) => {\n      const tr = map.transform;\n      map.transform = mapInstance.transform;\n      const result = map.project(lnglat);\n      map.transform = tr;\n      return result;\n    },\n    unproject: (point: PointLike) => {\n      const tr = map.transform;\n      map.transform = mapInstance.transform;\n      const result = map.unproject(point);\n      map.transform = tr;\n      return result;\n    },\n    // options diverge between mapbox and maplibre\n    queryTerrainElevation: (lnglat: LngLatLike, options?: any) => {\n      const tr = map.transform;\n      map.transform = mapInstance.transform;\n      const result = map.queryTerrainElevation(lnglat, options);\n      map.transform = tr;\n      return result;\n    },\n    queryRenderedFeatures: (geometry?: any, options?: any) => {\n      const tr = map.transform;\n      map.transform = mapInstance.transform;\n      const result = map.queryRenderedFeatures(geometry, options);\n      map.transform = tr;\n      return result;\n    }\n  };\n\n  for (const key of getMethodNames(map)) {\n    // @ts-expect-error\n    if (!(key in result) && !skipMethods.includes(key)) {\n      result[key] = map[key].bind(map);\n    }\n  }\n\n  return result;\n}\n\nfunction getMethodNames(obj: Object) {\n  const result = new Set<string>();\n\n  let proto = obj;\n  while (proto) {\n    for (const key of Object.getOwnPropertyNames(proto)) {\n      if (\n        key[0] !== '_' &&\n        typeof obj[key] === 'function' &&\n        key !== 'fire' &&\n        key !== 'setEventedParent'\n      ) {\n        result.add(key);\n      }\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n  return Array.from(result);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/mapbox/mapbox.d.ts

@@ -0,0 +1,81 @@
+import type { Transform, ViewState, ViewStateChangeEvent, PointLike, PaddingOptions, MapStyle, ImmutableLike, LngLatBoundsLike, Callbacks, MapEvent, MapMouseEvent, MapInstance, MapInstanceInternal } from '../types';
+export declare type MapboxProps<StyleT extends MapStyle = MapStyle, CallbacksT extends Callbacks = {}> = Partial<ViewState> & CallbacksT & {
+    mapboxAccessToken?: string;
+    /** Camera options used when constructing the Map instance */
+    initialViewState?: Partial<ViewState> & {
+        /** The initial bounds of the map. If bounds is specified, it overrides longitude, latitude and zoom options. */
+        bounds?: LngLatBoundsLike;
+        /** A fitBounds options object to use only when setting the bounds option. */
+        fitBoundsOptions?: {
+            offset?: PointLike;
+            minZoom?: number;
+            maxZoom?: number;
+            padding?: number | PaddingOptions;
+        };
+    };
+    /** If provided, render into an external WebGL context */
+    gl?: WebGLRenderingContext;
+    /** For external controller to override the camera state */
+    viewState?: ViewState & {
+        width: number;
+        height: number;
+    };
+    /** Mapbox style */
+    mapStyle?: string | StyleT | ImmutableLike<StyleT>;
+    /** Enable diffing when the map style changes
+     * @default true
+     */
+    styleDiffing?: boolean;
+    /** The fog property of the style. Must conform to the Fog Style Specification .
+     * If `undefined` is provided, removes the fog from the map. */
+    fog?: StyleT['fog'];
+    /** Light properties of the map. */
+    light?: StyleT['light'];
+    /** Terrain property of the style. Must conform to the Terrain Style Specification .
+     * If `undefined` is provided, removes terrain from the map. */
+    terrain?: StyleT['terrain'];
+    /** Default layers to query on pointer events */
+    interactiveLayerIds?: string[];
+    /** CSS cursor */
+    cursor?: string;
+};
+/**
+ * A wrapper for mapbox-gl's Map class
+ */
+export default class Mapbox<StyleT extends MapStyle = MapStyle, CallbacksT extends Callbacks = {}, MapT extends MapInstance = MapInstance> {
+    private _MapClass;
+    private _map;
+    props: MapboxProps<StyleT, CallbacksT>;
+    private _renderTransform;
+    private _internalUpdate;
+    private _inRender;
+    private _hoveredFeatures;
+    private _deferredEvents;
+    static savedMaps: Mapbox[];
+    constructor(MapClass: {
+        new (options: any): MapInstance;
+    }, props: MapboxProps<StyleT, CallbacksT>, container: HTMLDivElement);
+    get map(): MapT;
+    get transform(): Transform;
+    setProps(props: MapboxProps<StyleT, CallbacksT>): void;
+    static reuse<StyleT extends MapStyle, CallbacksT extends Callbacks, MapT extends MapInstance>(props: MapboxProps<StyleT, CallbacksT>, container: HTMLDivElement): Mapbox<StyleT, CallbacksT, MapT>;
+    _initialize(container: HTMLDivElement): void;
+    recycle(): void;
+    destroy(): void;
+    redraw(): void;
+    _createShadowTransform(map: any): void;
+    _updateSize(nextProps: MapboxProps<StyleT>): boolean;
+    _updateViewState(nextProps: MapboxProps<StyleT>, triggerEvents: boolean): boolean;
+    _updateSettings(nextProps: MapboxProps<StyleT>, currProps: MapboxProps<StyleT>): boolean;
+    _updateStyle(nextProps: MapboxProps<StyleT>, currProps: MapboxProps<StyleT>): boolean;
+    _updateStyleComponents(nextProps: MapboxProps<StyleT>, currProps: MapboxProps<StyleT>): boolean;
+    _updateHandlers(nextProps: MapboxProps<StyleT>, currProps: MapboxProps<StyleT>): boolean;
+    _onEvent: (e: MapEvent<MapT>) => void;
+    private _queryRenderedFeatures;
+    _updateHover(e: MapMouseEvent<MapT>): void;
+    _onPointerEvent: (e: MapMouseEvent<MapT> | MapMouseEvent<MapT>) => void;
+    _onCameraEvent: (e: ViewStateChangeEvent<MapT>) => void;
+    _fireEvent(baseFire: Function, event: string | MapEvent<MapT>, properties?: object): MapInstanceInternal<MapT>;
+    _onBeforeRepaint(): void;
+    _onAfterRepaint: () => void;
+}

package/dist/mapbox/mapbox.js

@@ -0,0 +1,477 @@
+import { transformToViewState, applyViewStateToTransform, cloneTransform, syncProjection } from "../utils/transform.js";
+import { normalizeStyle } from "../utils/style-utils.js";
+import { deepEqual } from "../utils/deep-equal.js";
+const DEFAULT_STYLE = {
+  version: 8,
+  sources: {},
+  layers: []
+};
+const pointerEvents = {
+  mousedown: 'onMouseDown',
+  mouseup: 'onMouseUp',
+  mouseover: 'onMouseOver',
+  mousemove: 'onMouseMove',
+  click: 'onClick',
+  dblclick: 'onDblClick',
+  mouseenter: 'onMouseEnter',
+  mouseleave: 'onMouseLeave',
+  mouseout: 'onMouseOut',
+  contextmenu: 'onContextMenu',
+  touchstart: 'onTouchStart',
+  touchend: 'onTouchEnd',
+  touchmove: 'onTouchMove',
+  touchcancel: 'onTouchCancel'
+};
+const cameraEvents = {
+  movestart: 'onMoveStart',
+  move: 'onMove',
+  moveend: 'onMoveEnd',
+  dragstart: 'onDragStart',
+  drag: 'onDrag',
+  dragend: 'onDragEnd',
+  zoomstart: 'onZoomStart',
+  zoom: 'onZoom',
+  zoomend: 'onZoomEnd',
+  rotatestart: 'onRotateStart',
+  rotate: 'onRotate',
+  rotateend: 'onRotateEnd',
+  pitchstart: 'onPitchStart',
+  pitch: 'onPitch',
+  pitchend: 'onPitchEnd'
+};
+const otherEvents = {
+  wheel: 'onWheel',
+  boxzoomstart: 'onBoxZoomStart',
+  boxzoomend: 'onBoxZoomEnd',
+  boxzoomcancel: 'onBoxZoomCancel',
+  resize: 'onResize',
+  load: 'onLoad',
+  render: 'onRender',
+  idle: 'onIdle',
+  remove: 'onRemove',
+  data: 'onData',
+  styledata: 'onStyleData',
+  sourcedata: 'onSourceData',
+  error: 'onError'
+};
+const settingNames = ['minZoom', 'maxZoom', 'minPitch', 'maxPitch', 'maxBounds', 'projection', 'renderWorldCopies'];
+const handlerNames = ['scrollZoom', 'boxZoom', 'dragRotate', 'dragPan', 'keyboard', 'doubleClickZoom', 'touchZoomRotate', 'touchPitch'];
+export default class Mapbox {
+  _map = null;
+  _internalUpdate = false;
+  _inRender = false;
+  _hoveredFeatures = null;
+  _deferredEvents = {
+    move: false,
+    zoom: false,
+    pitch: false,
+    rotate: false
+  };
+  static savedMaps = [];
+  constructor(MapClass, props, container) {
+    this._MapClass = MapClass;
+    this.props = props;
+    this._initialize(container);
+  }
+  get map() {
+    return this._map;
+  }
+  get transform() {
+    return this._renderTransform;
+  }
+  setProps(props) {
+    const oldProps = this.props;
+    this.props = props;
+    const settingsChanged = this._updateSettings(props, oldProps);
+    if (settingsChanged) {
+      this._createShadowTransform(this._map);
+    }
+    const sizeChanged = this._updateSize(props);
+    const viewStateChanged = this._updateViewState(props, true);
+    this._updateStyle(props, oldProps);
+    this._updateStyleComponents(props, oldProps);
+    this._updateHandlers(props, oldProps);
+    if (settingsChanged || sizeChanged || viewStateChanged && !this._map.isMoving()) {
+      this.redraw();
+    }
+  }
+  static reuse(props, container) {
+    const that = Mapbox.savedMaps.pop();
+    if (!that) {
+      return null;
+    }
+    const map = that.map;
+    const oldContainer = map.getContainer();
+    container.className = oldContainer.className;
+    while (oldContainer.childNodes.length > 0) {
+      container.appendChild(oldContainer.childNodes[0]);
+    }
+    map._container = container;
+    const resizeObserver = map._resizeObserver;
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+      resizeObserver.observe(container);
+    }
+    that.setProps({
+      ...props,
+      styleDiffing: false
+    });
+    map.resize();
+    const {
+      initialViewState
+    } = props;
+    if (initialViewState) {
+      if (initialViewState.bounds) {
+        map.fitBounds(initialViewState.bounds, {
+          ...initialViewState.fitBoundsOptions,
+          duration: 0
+        });
+      } else {
+        that._updateViewState(initialViewState, false);
+      }
+    }
+    if (map.isStyleLoaded()) {
+      map.fire('load');
+    } else {
+      map.once('styledata', () => map.fire('load'));
+    }
+    map._update();
+    return that;
+  }
+  _initialize(container) {
+    const {
+      props
+    } = this;
+    const {
+      mapStyle = DEFAULT_STYLE
+    } = props;
+    const mapOptions = {
+      ...props,
+      ...props.initialViewState,
+      accessToken: props.mapboxAccessToken || getAccessTokenFromEnv() || null,
+      container,
+      style: normalizeStyle(mapStyle)
+    };
+    const viewState = mapOptions.initialViewState || mapOptions.viewState || mapOptions;
+    Object.assign(mapOptions, {
+      center: [viewState.longitude || 0, viewState.latitude || 0],
+      zoom: viewState.zoom || 0,
+      pitch: viewState.pitch || 0,
+      bearing: viewState.bearing || 0
+    });
+    if (props.gl) {
+      const getContext = HTMLCanvasElement.prototype.getContext;
+      HTMLCanvasElement.prototype.getContext = () => {
+        HTMLCanvasElement.prototype.getContext = getContext;
+        return props.gl;
+      };
+    }
+    const map = new this._MapClass(mapOptions);
+    if (viewState.padding) {
+      map.setPadding(viewState.padding);
+    }
+    if (props.cursor) {
+      map.getCanvas().style.cursor = props.cursor;
+    }
+    this._createShadowTransform(map);
+    const renderMap = map._render;
+    map._render = arg => {
+      this._inRender = true;
+      renderMap.call(map, arg);
+      this._inRender = false;
+    };
+    const runRenderTaskQueue = map._renderTaskQueue.run;
+    map._renderTaskQueue.run = arg => {
+      runRenderTaskQueue.call(map._renderTaskQueue, arg);
+      this._onBeforeRepaint();
+    };
+    map.on('render', () => this._onAfterRepaint());
+    const fireEvent = map.fire;
+    map.fire = this._fireEvent.bind(this, fireEvent);
+    map.on('resize', () => {
+      this._renderTransform.resize(map.transform.width, map.transform.height);
+    });
+    map.on('styledata', () => {
+      this._updateStyleComponents(this.props, {});
+      syncProjection(map.transform, this._renderTransform);
+    });
+    map.on('sourcedata', () => this._updateStyleComponents(this.props, {}));
+    for (const eventName in pointerEvents) {
+      map.on(eventName, this._onPointerEvent);
+    }
+    for (const eventName in cameraEvents) {
+      map.on(eventName, this._onCameraEvent);
+    }
+    for (const eventName in otherEvents) {
+      map.on(eventName, this._onEvent);
+    }
+    this._map = map;
+  }
+  recycle() {
+    const container = this.map.getContainer();
+    const children = container.querySelector('[mapboxgl-children]');
+    children === null || children === void 0 ? void 0 : children.remove();
+    Mapbox.savedMaps.push(this);
+  }
+  destroy() {
+    this._map.remove();
+  }
+  redraw() {
+    const map = this._map;
+    if (!this._inRender && map.style) {
+      if (map._frame) {
+        map._frame.cancel();
+        map._frame = null;
+      }
+      map._render();
+    }
+  }
+  _createShadowTransform(map) {
+    const renderTransform = cloneTransform(map.transform);
+    map.painter.transform = renderTransform;
+    this._renderTransform = renderTransform;
+  }
+  _updateSize(nextProps) {
+    const {
+      viewState
+    } = nextProps;
+    if (viewState) {
+      const map = this._map;
+      if (viewState.width !== map.transform.width || viewState.height !== map.transform.height) {
+        map.resize();
+        return true;
+      }
+    }
+    return false;
+  }
+  _updateViewState(nextProps, triggerEvents) {
+    if (this._internalUpdate) {
+      return false;
+    }
+    const map = this._map;
+    const tr = this._renderTransform;
+    const {
+      zoom,
+      pitch,
+      bearing
+    } = tr;
+    const isMoving = map.isMoving();
+    if (isMoving) {
+      tr.cameraElevationReference = 'sea';
+    }
+    const changed = applyViewStateToTransform(tr, {
+      ...transformToViewState(map.transform),
+      ...nextProps
+    });
+    if (isMoving) {
+      tr.cameraElevationReference = 'ground';
+    }
+    if (changed && triggerEvents) {
+      const deferredEvents = this._deferredEvents;
+      deferredEvents.move = true;
+      deferredEvents.zoom ||= zoom !== tr.zoom;
+      deferredEvents.rotate ||= bearing !== tr.bearing;
+      deferredEvents.pitch ||= pitch !== tr.pitch;
+    }
+    if (!isMoving) {
+      applyViewStateToTransform(map.transform, nextProps);
+    }
+    return changed;
+  }
+  _updateSettings(nextProps, currProps) {
+    const map = this._map;
+    let changed = false;
+    for (const propName of settingNames) {
+      if (propName in nextProps && !deepEqual(nextProps[propName], currProps[propName])) {
+        changed = true;
+        const setter = map[`set${propName[0].toUpperCase()}${propName.slice(1)}`];
+        setter === null || setter === void 0 ? void 0 : setter.call(map, nextProps[propName]);
+      }
+    }
+    return changed;
+  }
+  _updateStyle(nextProps, currProps) {
+    if (nextProps.cursor !== currProps.cursor) {
+      this._map.getCanvas().style.cursor = nextProps.cursor || '';
+    }
+    if (nextProps.mapStyle !== currProps.mapStyle) {
+      const {
+        mapStyle = DEFAULT_STYLE,
+        styleDiffing = true
+      } = nextProps;
+      const options = {
+        diff: styleDiffing
+      };
+      if ('localIdeographFontFamily' in nextProps) {
+        options.localIdeographFontFamily = nextProps.localIdeographFontFamily;
+      }
+      this._map.setStyle(normalizeStyle(mapStyle), options);
+      return true;
+    }
+    return false;
+  }
+  _updateStyleComponents(nextProps, currProps) {
+    const map = this._map;
+    let changed = false;
+    if (map.isStyleLoaded()) {
+      if ('light' in nextProps && map.setLight && !deepEqual(nextProps.light, currProps.light)) {
+        changed = true;
+        map.setLight(nextProps.light);
+      }
+      if ('fog' in nextProps && map.setFog && !deepEqual(nextProps.fog, currProps.fog)) {
+        changed = true;
+        map.setFog(nextProps.fog);
+      }
+      if ('terrain' in nextProps && map.setTerrain && !deepEqual(nextProps.terrain, currProps.terrain)) {
+        if (!nextProps.terrain || map.getSource(nextProps.terrain.source)) {
+          changed = true;
+          map.setTerrain(nextProps.terrain);
+        }
+      }
+    }
+    return changed;
+  }
+  _updateHandlers(nextProps, currProps) {
+    const map = this._map;
+    let changed = false;
+    for (const propName of handlerNames) {
+      const newValue = nextProps[propName] ?? true;
+      const oldValue = currProps[propName] ?? true;
+      if (!deepEqual(newValue, oldValue)) {
+        changed = true;
+        if (newValue) {
+          map[propName].enable(newValue);
+        } else {
+          map[propName].disable();
+        }
+      }
+    }
+    return changed;
+  }
+  _onEvent = e => {
+    const cb = this.props[otherEvents[e.type]];
+    if (cb) {
+      cb(e);
+    } else if (e.type === 'error') {
+      console.error(e.error);
+    }
+  };
+  _queryRenderedFeatures(point) {
+    const map = this._map;
+    const tr = map.transform;
+    const {
+      interactiveLayerIds = []
+    } = this.props;
+    try {
+      map.transform = this._renderTransform;
+      return map.queryRenderedFeatures(point, {
+        layers: interactiveLayerIds.filter(map.getLayer.bind(map))
+      });
+    } catch {
+      return [];
+    } finally {
+      map.transform = tr;
+    }
+  }
+  _updateHover(e) {
+    const {
+      props
+    } = this;
+    const shouldTrackHoveredFeatures = props.interactiveLayerIds && (props.onMouseMove || props.onMouseEnter || props.onMouseLeave);
+    if (shouldTrackHoveredFeatures) {
+      var _this$_hoveredFeature;
+      const eventType = e.type;
+      const wasHovering = ((_this$_hoveredFeature = this._hoveredFeatures) === null || _this$_hoveredFeature === void 0 ? void 0 : _this$_hoveredFeature.length) > 0;
+      const features = this._queryRenderedFeatures(e.point);
+      const isHovering = features.length > 0;
+      if (!isHovering && wasHovering) {
+        e.type = 'mouseleave';
+        this._onPointerEvent(e);
+      }
+      this._hoveredFeatures = features;
+      if (isHovering && !wasHovering) {
+        e.type = 'mouseenter';
+        this._onPointerEvent(e);
+      }
+      e.type = eventType;
+    } else {
+      this._hoveredFeatures = null;
+    }
+  }
+  _onPointerEvent = e => {
+    if (e.type === 'mousemove' || e.type === 'mouseout') {
+      this._updateHover(e);
+    }
+    const cb = this.props[pointerEvents[e.type]];
+    if (cb) {
+      if (this.props.interactiveLayerIds && e.type !== 'mouseover' && e.type !== 'mouseout') {
+        e.features = this._hoveredFeatures || this._queryRenderedFeatures(e.point);
+      }
+      cb(e);
+      delete e.features;
+    }
+  };
+  _onCameraEvent = e => {
+    if (!this._internalUpdate) {
+      const cb = this.props[cameraEvents[e.type]];
+      if (cb) {
+        cb(e);
+      }
+    }
+    if (e.type in this._deferredEvents) {
+      this._deferredEvents[e.type] = false;
+    }
+  };
+  _fireEvent(baseFire, event, properties) {
+    const map = this._map;
+    const tr = map.transform;
+    const eventType = typeof event === 'string' ? event : event.type;
+    if (eventType === 'move') {
+      this._updateViewState(this.props, false);
+    }
+    if (eventType in cameraEvents) {
+      if (typeof event === 'object') {
+        event.viewState = transformToViewState(tr);
+      }
+      if (this._map.isMoving()) {
+        map.transform = this._renderTransform;
+        baseFire.call(map, event, properties);
+        map.transform = tr;
+        return map;
+      }
+    }
+    baseFire.call(map, event, properties);
+    return map;
+  }
+  _onBeforeRepaint() {
+    const map = this._map;
+    this._internalUpdate = true;
+    for (const eventType in this._deferredEvents) {
+      if (this._deferredEvents[eventType]) {
+        map.fire(eventType);
+      }
+    }
+    this._internalUpdate = false;
+    const tr = this._map.transform;
+    map.transform = this._renderTransform;
+    this._onAfterRepaint = () => {
+      syncProjection(this._renderTransform, tr);
+      map.transform = tr;
+    };
+  }
+}
+function getAccessTokenFromEnv() {
+  let accessToken = null;
+  if (typeof location !== 'undefined') {
+    const match = /access_token=([^&\/]*)/.exec(location.search);
+    accessToken = match && match[1];
+  }
+  try {
+    accessToken = accessToken || process.env.MapboxAccessToken;
+  } catch {}
+  try {
+    accessToken = accessToken || process.env.REACT_APP_MAPBOX_ACCESS_TOKEN;
+  } catch {}
+  return accessToken;
+}
+//# sourceMappingURL=mapbox.js.map