@deck.gl/mapbox 9.0.0-beta.2 → 9.0.0-beta.3

package/dist/index.cjs

@@ -0,0 +1,545 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  MapboxLayer: () => MapboxLayer,
+  MapboxOverlay: () => MapboxOverlay
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/deck-utils.js
+var import_core = require("@deck.gl/core");
+var import_web_mercator = require("@math.gl/web-mercator");
+var import_constants = require("@luma.gl/constants");
+var TILE_SIZE = 512;
+var DEGREES_TO_RADIANS = Math.PI / 180;
+function getDeckInstance({ map, gl, deck }) {
+  if (map.__deck) {
+    return map.__deck;
+  }
+  const customRender = deck == null ? void 0 : deck.props._customRender;
+  const onLoad = deck == null ? void 0 : deck.props.onLoad;
+  const deckProps = getInterleavedProps({
+    ...deck == null ? void 0 : deck.props,
+    _customRender: () => {
+      map.triggerRepaint();
+      customRender == null ? void 0 : customRender("");
+    }
+  });
+  let deckInstance;
+  if (!deck || deck.props.gl === gl) {
+    Object.assign(deckProps, {
+      gl,
+      width: null,
+      height: null,
+      touchAction: "unset",
+      viewState: getViewState(map)
+    });
+    if (deck == null ? void 0 : deck.isInitialized) {
+      watchMapMove(deck, map);
+    } else {
+      deckProps.onLoad = () => {
+        onLoad == null ? void 0 : onLoad();
+        watchMapMove(deckInstance, map);
+      };
+    }
+  }
+  if (deck) {
+    deckInstance = deck;
+    deck.setProps(deckProps);
+    deck.userData.isExternal = true;
+  } else {
+    deckInstance = new import_core.Deck(deckProps);
+    map.on("remove", () => {
+      removeDeckInstance(map);
+    });
+  }
+  deckInstance.userData.mapboxLayers = /* @__PURE__ */ new Set();
+  map.__deck = deckInstance;
+  map.on("render", () => {
+    if (deckInstance.isInitialized)
+      afterRender(deckInstance, map);
+  });
+  return deckInstance;
+}
+function watchMapMove(deck, map) {
+  const _handleMapMove = () => {
+    if (deck.isInitialized) {
+      onMapMove(deck, map);
+    } else {
+      map.off("move", _handleMapMove);
+    }
+  };
+  map.on("move", _handleMapMove);
+}
+function removeDeckInstance(map) {
+  var _a;
+  (_a = map.__deck) == null ? void 0 : _a.finalize();
+  map.__deck = null;
+}
+function getInterleavedProps(currProps) {
+  const nextProps = {
+    ...currProps,
+    parameters: {
+      depthMask: true,
+      depthTest: true,
+      blend: true,
+      blendFunc: [import_constants.GL.SRC_ALPHA, import_constants.GL.ONE_MINUS_SRC_ALPHA, import_constants.GL.ONE, import_constants.GL.ONE_MINUS_SRC_ALPHA],
+      polygonOffsetFill: true,
+      depthFunc: import_constants.GL.LEQUAL,
+      blendEquation: import_constants.GL.FUNC_ADD,
+      ...currProps.parameters
+    },
+    views: currProps.views || [new import_core.MapView({ id: "mapbox" })]
+  };
+  return nextProps;
+}
+function addLayer(deck, layer) {
+  deck.userData.mapboxLayers.add(layer);
+  updateLayers(deck);
+}
+function removeLayer(deck, layer) {
+  deck.userData.mapboxLayers.delete(layer);
+  updateLayers(deck);
+}
+function updateLayer(deck, layer) {
+  updateLayers(deck);
+}
+function drawLayer(deck, map, layer) {
+  let { currentViewport } = deck.userData;
+  let clearStack = false;
+  if (!currentViewport) {
+    currentViewport = getViewport(deck, map, true);
+    deck.userData.currentViewport = currentViewport;
+    clearStack = true;
+  }
+  if (!deck.isInitialized) {
+    return;
+  }
+  deck._drawLayers("mapbox-repaint", {
+    viewports: [currentViewport],
+    layerFilter: ({ layer: deckLayer }) => layer.id === deckLayer.id || deckLayer.props.operation.includes("terrain"),
+    clearStack,
+    clearCanvas: false
+  });
+}
+function getViewState(map) {
+  var _a;
+  const { lng, lat } = map.getCenter();
+  const viewState = {
+    longitude: (lng + 540) % 360 - 180,
+    latitude: lat,
+    zoom: map.getZoom(),
+    bearing: map.getBearing(),
+    pitch: map.getPitch(),
+    padding: map.getPadding(),
+    repeat: map.getRenderWorldCopies()
+  };
+  if ((_a = map.getTerrain) == null ? void 0 : _a.call(map)) {
+    centerCameraOnTerrain(map, viewState);
+  }
+  return viewState;
+}
+function centerCameraOnTerrain(map, viewState) {
+  if (map.getFreeCameraOptions) {
+    const { position } = map.getFreeCameraOptions();
+    if (!position || position.z === void 0) {
+      return;
+    }
+    const height = map.transform.height;
+    const { longitude, latitude, pitch } = viewState;
+    const cameraX = position.x * TILE_SIZE;
+    const cameraY = (1 - position.y) * TILE_SIZE;
+    const cameraZ = position.z * TILE_SIZE;
+    const center = (0, import_web_mercator.lngLatToWorld)([longitude, latitude]);
+    const dx = cameraX - center[0];
+    const dy = cameraY - center[1];
+    const cameraToCenterDistanceGround = Math.sqrt(dx * dx + dy * dy);
+    const pitchRadians = pitch * DEGREES_TO_RADIANS;
+    const altitudePixels = 1.5 * height;
+    const scale = pitchRadians < 1e-3 ? altitudePixels * Math.cos(pitchRadians) / cameraZ : altitudePixels * Math.sin(pitchRadians) / cameraToCenterDistanceGround;
+    viewState.zoom = Math.log2(scale);
+    const cameraZFromSurface = altitudePixels * Math.cos(pitchRadians) / scale;
+    const surfaceElevation = cameraZ - cameraZFromSurface;
+    viewState.position = [0, 0, surfaceElevation / (0, import_web_mercator.unitsPerMeter)(latitude)];
+  } else if (typeof map.transform.elevation === "number") {
+    viewState.position = [0, 0, map.transform.elevation];
+  }
+}
+function getViewport(deck, map, useMapboxProjection = true) {
+  return new import_core.WebMercatorViewport({
+    id: "mapbox",
+    x: 0,
+    y: 0,
+    width: deck.width,
+    height: deck.height,
+    ...getViewState(map),
+    nearZMultiplier: useMapboxProjection ? 0.02 : 0.1,
+    nearZ: map.transform._nearZ / map.transform.height,
+    farZ: map.transform._farZ / map.transform.height
+  });
+}
+function afterRender(deck, map) {
+  const { mapboxLayers, isExternal } = deck.userData;
+  if (isExternal) {
+    const mapboxLayerIds = Array.from(mapboxLayers, (layer) => layer.id);
+    const deckLayers = (0, import_core._flatten)(deck.props.layers, Boolean);
+    const hasNonMapboxLayers = deckLayers.some((layer) => layer && !mapboxLayerIds.includes(layer.id));
+    let viewports = deck.getViewports();
+    const mapboxViewportIdx = viewports.findIndex((vp) => vp.id === "mapbox");
+    const hasNonMapboxViews = viewports.length > 1 || mapboxViewportIdx < 0;
+    if (hasNonMapboxLayers || hasNonMapboxViews) {
+      if (mapboxViewportIdx >= 0) {
+        viewports = viewports.slice();
+        viewports[mapboxViewportIdx] = getViewport(deck, map, false);
+      }
+      deck._drawLayers("mapbox-repaint", {
+        viewports,
+        layerFilter: (params) => (!deck.props.layerFilter || deck.props.layerFilter(params)) && (params.viewport.id !== "mapbox" || !mapboxLayerIds.includes(params.layer.id)),
+        clearCanvas: false
+      });
+    }
+  }
+  deck.userData.currentViewport = null;
+}
+function onMapMove(deck, map) {
+  deck.setProps({
+    viewState: getViewState(map)
+  });
+  deck.needsRedraw({ clearRedrawFlags: true });
+}
+function updateLayers(deck) {
+  if (deck.userData.isExternal) {
+    return;
+  }
+  const layers = [];
+  deck.userData.mapboxLayers.forEach((deckLayer) => {
+    const LayerType = deckLayer.props.type;
+    const layer = new LayerType(deckLayer.props);
+    layers.push(layer);
+  });
+  deck.setProps({ layers });
+}
+
+// dist/mapbox-layer.js
+var import_core2 = require("@deck.gl/core");
+var MapboxLayer = class {
+  constructor(props) {
+    if (!props.id) {
+      throw new Error("Layer must have an unique id");
+    }
+    this.id = props.id;
+    this.type = "custom";
+    this.renderingMode = props.renderingMode || "3d";
+    this.map = null;
+    this.deck = null;
+    this.props = props;
+  }
+  onAdd(map, gl) {
+    if (gl instanceof WebGLRenderingContext) {
+      import_core2.log.warn("Use useWebGL2:true in mapboxgl.Map()")();
+      return;
+    }
+    this.map = map;
+    this.deck = getDeckInstance({ map, gl, deck: this.props.deck });
+    addLayer(this.deck, this);
+  }
+  onRemove() {
+    if (this.deck) {
+      removeLayer(this.deck, this);
+    }
+  }
+  setProps(props) {
+    Object.assign(this.props, props, { id: this.id });
+    if (this.deck) {
+      updateLayer(this.deck, this);
+    }
+  }
+  render() {
+    drawLayer(this.deck, this.map, this);
+  }
+};
+
+// dist/mapbox-overlay.js
+var import_core4 = require("@deck.gl/core");
+
+// dist/resolve-layers.js
+var import_core3 = require("@deck.gl/core");
+var UNDEFINED_BEFORE_ID = "__UNDEFINED__";
+function resolveLayers(map, deck, oldLayers, newLayers) {
+  if (!map || !deck || !map.style || !map.style._loaded) {
+    return;
+  }
+  const layers = (0, import_core3._flatten)(newLayers, Boolean);
+  if (oldLayers !== newLayers) {
+    const prevLayers = (0, import_core3._flatten)(oldLayers, Boolean);
+    const prevLayerIds = new Set(prevLayers.map((l) => l.id));
+    for (const layer of layers) {
+      prevLayerIds.delete(layer.id);
+    }
+    for (const id of prevLayerIds) {
+      if (map.getLayer(id)) {
+        map.removeLayer(id);
+      }
+    }
+  }
+  for (const layer of layers) {
+    const mapboxLayer = map.getLayer(layer.id);
+    if (mapboxLayer) {
+      mapboxLayer.implementation.setProps(layer.props);
+    } else {
+      map.addLayer(
+        new MapboxLayer({ id: layer.id, deck }),
+        layer.props.beforeId
+      );
+    }
+  }
+  const mapLayers = map.style._order;
+  const layerGroups = {};
+  for (const layer of layers) {
+    let { beforeId } = layer.props;
+    if (!beforeId || !mapLayers.includes(beforeId)) {
+      beforeId = UNDEFINED_BEFORE_ID;
+    }
+    layerGroups[beforeId] = layerGroups[beforeId] || [];
+    layerGroups[beforeId].push(layer.id);
+  }
+  for (const beforeId in layerGroups) {
+    const layerGroup = layerGroups[beforeId];
+    let lastLayerIndex = beforeId === UNDEFINED_BEFORE_ID ? mapLayers.length : mapLayers.indexOf(beforeId);
+    let lastLayerId = beforeId === UNDEFINED_BEFORE_ID ? void 0 : beforeId;
+    for (let i = layerGroup.length - 1; i >= 0; i--) {
+      const layerId = layerGroup[i];
+      const layerIndex = mapLayers.indexOf(layerId);
+      if (layerIndex !== lastLayerIndex - 1) {
+        map.moveLayer(layerId, lastLayerId);
+        if (layerIndex > lastLayerIndex) {
+          lastLayerIndex++;
+        }
+      }
+      lastLayerIndex--;
+      lastLayerId = layerId;
+    }
+  }
+}
+
+// dist/mapbox-overlay.js
+var MapboxOverlay = class {
+  constructor(props) {
+    this._handleStyleChange = () => {
+      resolveLayers(this._map, this._deck, this._props.layers, this._props.layers);
+    };
+    this._updateContainerSize = () => {
+      if (this._map && this._container) {
+        const { clientWidth, clientHeight } = this._map.getContainer();
+        Object.assign(this._container.style, {
+          width: `${clientWidth}px`,
+          height: `${clientHeight}px`
+        });
+      }
+    };
+    this._updateViewState = () => {
+      const deck = this._deck;
+      if (deck) {
+        deck.setProps({ viewState: getViewState(this._map) });
+        if (deck.isInitialized) {
+          deck.redraw();
+        }
+      }
+    };
+    this._handleMouseEvent = (event) => {
+      const deck = this._deck;
+      if (!deck || !deck.isInitialized) {
+        return;
+      }
+      const mockEvent = {
+        type: event.type,
+        offsetCenter: event.point,
+        srcEvent: event
+      };
+      const lastDown = this._lastMouseDownPoint;
+      if (!event.point && lastDown) {
+        mockEvent.deltaX = event.originalEvent.clientX - lastDown.clientX;
+        mockEvent.deltaY = event.originalEvent.clientY - lastDown.clientY;
+        mockEvent.offsetCenter = {
+          x: lastDown.x + mockEvent.deltaX,
+          y: lastDown.y + mockEvent.deltaY
+        };
+      }
+      switch (mockEvent.type) {
+        case "mousedown":
+          deck._onPointerDown(mockEvent);
+          this._lastMouseDownPoint = {
+            ...event.point,
+            clientX: event.originalEvent.clientX,
+            clientY: event.originalEvent.clientY
+          };
+          break;
+        case "dragstart":
+          mockEvent.type = "panstart";
+          deck._onEvent(mockEvent);
+          break;
+        case "drag":
+          mockEvent.type = "panmove";
+          deck._onEvent(mockEvent);
+          break;
+        case "dragend":
+          mockEvent.type = "panend";
+          deck._onEvent(mockEvent);
+          break;
+        case "click":
+          mockEvent.tapCount = 1;
+          deck._onEvent(mockEvent);
+          break;
+        case "dblclick":
+          mockEvent.type = "click";
+          mockEvent.tapCount = 2;
+          deck._onEvent(mockEvent);
+          break;
+        case "mousemove":
+          mockEvent.type = "pointermove";
+          deck._onPointerMove(mockEvent);
+          break;
+        case "mouseout":
+          mockEvent.type = "pointerleave";
+          deck._onPointerMove(mockEvent);
+          break;
+        default:
+          return;
+      }
+    };
+    const { interleaved = false, ...otherProps } = props;
+    this._interleaved = interleaved;
+    this._props = otherProps;
+  }
+  setProps(props) {
+    if (this._interleaved && props.layers) {
+      resolveLayers(this._map, this._deck, this._props.layers, props.layers);
+    }
+    Object.assign(this._props, props);
+    if (this._deck) {
+      this._deck.setProps(this._interleaved ? getInterleavedProps(this._props) : this._props);
+    }
+  }
+  onAdd(map) {
+    this._map = map;
+    return this._interleaved ? this._onAddInterleaved(map) : this._onAddOverlaid(map);
+  }
+  _onAddOverlaid(map) {
+    const container = document.createElement("div");
+    Object.assign(container.style, {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      pointerEvents: "none"
+    });
+    this._container = container;
+    this._deck = new import_core4.Deck({
+      ...this._props,
+      parent: container,
+      viewState: getViewState(map)
+    });
+    map.on("resize", this._updateContainerSize);
+    map.on("render", this._updateViewState);
+    map.on("mousedown", this._handleMouseEvent);
+    map.on("dragstart", this._handleMouseEvent);
+    map.on("drag", this._handleMouseEvent);
+    map.on("dragend", this._handleMouseEvent);
+    map.on("mousemove", this._handleMouseEvent);
+    map.on("mouseout", this._handleMouseEvent);
+    map.on("click", this._handleMouseEvent);
+    map.on("dblclick", this._handleMouseEvent);
+    this._updateContainerSize();
+    return container;
+  }
+  _onAddInterleaved(map) {
+    this._deck = getDeckInstance({
+      map,
+      gl: map.painter.context.gl,
+      deck: new import_core4.Deck({
+        ...this._props,
+        gl: map.painter.context.gl
+      })
+    });
+    map.on("styledata", this._handleStyleChange);
+    resolveLayers(map, this._deck, [], this._props.layers);
+    return document.createElement("div");
+  }
+  onRemove() {
+    const map = this._map;
+    if (map) {
+      if (this._interleaved) {
+        this._onRemoveInterleaved(map);
+      } else {
+        this._onRemoveOverlaid(map);
+      }
+    }
+    this._deck = void 0;
+    this._map = void 0;
+    this._container = void 0;
+  }
+  _onRemoveOverlaid(map) {
+    var _a;
+    map.off("resize", this._updateContainerSize);
+    map.off("render", this._updateViewState);
+    map.off("mousedown", this._handleMouseEvent);
+    map.off("dragstart", this._handleMouseEvent);
+    map.off("drag", this._handleMouseEvent);
+    map.off("dragend", this._handleMouseEvent);
+    map.off("mousemove", this._handleMouseEvent);
+    map.off("mouseout", this._handleMouseEvent);
+    map.off("click", this._handleMouseEvent);
+    map.off("dblclick", this._handleMouseEvent);
+    (_a = this._deck) == null ? void 0 : _a.finalize();
+  }
+  _onRemoveInterleaved(map) {
+    map.off("styledata", this._handleStyleChange);
+    resolveLayers(map, this._deck, this._props.layers, []);
+    removeDeckInstance(map);
+  }
+  getDefaultPosition() {
+    return "top-left";
+  }
+  pickObject(params) {
+    (0, import_core4.assert)(this._deck);
+    return this._deck.pickObject(params);
+  }
+  pickMultipleObjects(params) {
+    (0, import_core4.assert)(this._deck);
+    return this._deck.pickMultipleObjects(params);
+  }
+  pickObjects(params) {
+    (0, import_core4.assert)(this._deck);
+    return this._deck.pickObjects(params);
+  }
+  finalize() {
+    if (this._map) {
+      this._map.removeControl(this);
+    }
+  }
+  getCanvas() {
+    if (!this._map) {
+      return null;
+    }
+    return this._interleaved ? this._map.getCanvas() : this._deck.getCanvas();
+  }
+};
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.js", "deck-utils.js", "mapbox-layer.js", "mapbox-overlay.js", "resolve-layers.js"],
+  "sourcesContent": ["export { default as MapboxLayer } from \"./mapbox-layer.js\";\nexport { default as MapboxOverlay } from \"./mapbox-overlay.js\";\n", "import { Deck, WebMercatorViewport, MapView, _flatten as flatten } from '@deck.gl/core';\nimport { lngLatToWorld, unitsPerMeter } from '@math.gl/web-mercator';\nimport { GL } from '@luma.gl/constants';\n// Mercator constants\nconst TILE_SIZE = 512;\nconst DEGREES_TO_RADIANS = Math.PI / 180;\n// Create an interleaved deck instance.\nexport function getDeckInstance({ map, gl, deck }) {\n    // Only create one deck instance per context\n    if (map.__deck) {\n        return map.__deck;\n    }\n    // Only initialize certain props once per context\n    const customRender = deck?.props._customRender;\n    const onLoad = deck?.props.onLoad;\n    const deckProps = getInterleavedProps({\n        ...deck?.props,\n        _customRender: () => {\n            map.triggerRepaint();\n            // customRender may be subscribed by DeckGL React component to update child props\n            // make sure it is still called\n            // Hack - do not pass a redraw reason here to prevent the React component from clearing the context\n            // Rerender will be triggered by MapboxLayer's render()\n            customRender?.('');\n        }\n    });\n    let deckInstance;\n    if (!deck || deck.props.gl === gl) {\n        // If deck isn't defined (Internal MapboxLayer use case),\n        // or if deck is defined and is using the WebGLContext created by mapbox (MapboxOverlay and External MapboxLayer use case),\n        // block deck from setting the canvas size, and use the map's viewState to drive deck.\n        // Otherwise, we use deck's viewState to drive the map.\n        Object.assign(deckProps, {\n            gl,\n            width: null,\n            height: null,\n            touchAction: 'unset',\n            viewState: getViewState(map)\n        });\n        if (deck?.isInitialized) {\n            watchMapMove(deck, map);\n        }\n        else {\n            deckProps.onLoad = () => {\n                onLoad?.();\n                watchMapMove(deckInstance, map);\n            };\n        }\n    }\n    if (deck) {\n        deckInstance = deck;\n        deck.setProps(deckProps);\n        deck.userData.isExternal = true;\n    }\n    else {\n        deckInstance = new Deck(deckProps);\n        map.on('remove', () => {\n            removeDeckInstance(map);\n        });\n    }\n    deckInstance.userData.mapboxLayers = new Set();\n    // (deckInstance.userData as UserData).mapboxVersion = getMapboxVersion(map);\n    map.__deck = deckInstance;\n    map.on('render', () => {\n        if (deckInstance.isInitialized)\n            afterRender(deckInstance, map);\n    });\n    return deckInstance;\n}\nfunction watchMapMove(deck, map) {\n    const _handleMapMove = () => {\n        if (deck.isInitialized) {\n            // call view state methods\n            onMapMove(deck, map);\n        }\n        else {\n            // deregister itself when deck is finalized\n            map.off('move', _handleMapMove);\n        }\n    };\n    map.on('move', _handleMapMove);\n}\nexport function removeDeckInstance(map) {\n    map.__deck?.finalize();\n    map.__deck = null;\n}\nexport function getInterleavedProps(currProps) {\n    const nextProps = {\n        ...currProps,\n        // TODO: import these defaults from a single source of truth\n        parameters: {\n            depthMask: true,\n            depthTest: true,\n            blend: true,\n            blendFunc: [GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.ONE, GL.ONE_MINUS_SRC_ALPHA],\n            polygonOffsetFill: true,\n            depthFunc: GL.LEQUAL,\n            blendEquation: GL.FUNC_ADD,\n            ...currProps.parameters\n        },\n        views: currProps.views || [new MapView({ id: 'mapbox' })]\n    };\n    return nextProps;\n}\nexport function addLayer(deck, layer) {\n    deck.userData.mapboxLayers.add(layer);\n    updateLayers(deck);\n}\nexport function removeLayer(deck, layer) {\n    deck.userData.mapboxLayers.delete(layer);\n    updateLayers(deck);\n}\nexport function updateLayer(deck, layer) {\n    updateLayers(deck);\n}\nexport function drawLayer(deck, map, layer) {\n    let { currentViewport } = deck.userData;\n    let clearStack = false;\n    if (!currentViewport) {\n        // This is the first layer drawn in this render cycle.\n        // Generate viewport from the current map state.\n        currentViewport = getViewport(deck, map, true);\n        deck.userData.currentViewport = currentViewport;\n        clearStack = true;\n    }\n    if (!deck.isInitialized) {\n        return;\n    }\n    deck._drawLayers('mapbox-repaint', {\n        viewports: [currentViewport],\n        layerFilter: ({ layer: deckLayer }) => layer.id === deckLayer.id || deckLayer.props.operation.includes('terrain'),\n        clearStack,\n        clearCanvas: false\n    });\n}\nexport function getViewState(map) {\n    const { lng, lat } = map.getCenter();\n    const viewState = {\n        // Longitude returned by getCenter can be outside of [-180, 180] when zooming near the anti meridian\n        // https://github.com/visgl/deck.gl/issues/6894\n        longitude: ((lng + 540) % 360) - 180,\n        latitude: lat,\n        zoom: map.getZoom(),\n        bearing: map.getBearing(),\n        pitch: map.getPitch(),\n        padding: map.getPadding(),\n        repeat: map.getRenderWorldCopies()\n    };\n    if (map.getTerrain?.()) {\n        // When the base map has terrain, we need to target the camera at the terrain surface\n        centerCameraOnTerrain(map, viewState);\n    }\n    return viewState;\n}\nfunction centerCameraOnTerrain(map, viewState) {\n    if (map.getFreeCameraOptions) {\n        // mapbox-gl v2\n        const { position } = map.getFreeCameraOptions();\n        if (!position || position.z === undefined) {\n            return;\n        }\n        // @ts-ignore transform is not typed\n        const height = map.transform.height;\n        const { longitude, latitude, pitch } = viewState;\n        // Convert mapbox mercator coordinate to deck common space\n        const cameraX = position.x * TILE_SIZE;\n        const cameraY = (1 - position.y) * TILE_SIZE;\n        const cameraZ = position.z * TILE_SIZE;\n        // Mapbox manipulates zoom in terrain mode, see discussion here: https://github.com/mapbox/mapbox-gl-js/issues/12040\n        const center = lngLatToWorld([longitude, latitude]);\n        const dx = cameraX - center[0];\n        const dy = cameraY - center[1];\n        const cameraToCenterDistanceGround = Math.sqrt(dx * dx + dy * dy);\n        const pitchRadians = pitch * DEGREES_TO_RADIANS;\n        const altitudePixels = 1.5 * height;\n        const scale = pitchRadians < 0.001\n            ? // Pitch angle too small to deduce the look at point, assume elevation is 0\n                (altitudePixels * Math.cos(pitchRadians)) / cameraZ\n            : (altitudePixels * Math.sin(pitchRadians)) / cameraToCenterDistanceGround;\n        viewState.zoom = Math.log2(scale);\n        const cameraZFromSurface = (altitudePixels * Math.cos(pitchRadians)) / scale;\n        const surfaceElevation = cameraZ - cameraZFromSurface;\n        viewState.position = [0, 0, surfaceElevation / unitsPerMeter(latitude)];\n    }\n    // @ts-ignore transform is not typed\n    else if (typeof map.transform.elevation === 'number') {\n        // maplibre-gl\n        // @ts-ignore transform is not typed\n        viewState.position = [0, 0, map.transform.elevation];\n    }\n}\n// function getMapboxVersion(map: Map): {minor: number; major: number} {\n//   // parse mapbox version string\n//   let major = 0;\n//   let minor = 0;\n//   // @ts-ignore (2339) undefined property\n//   const version: string = map.version;\n//   if (version) {\n//     [major, minor] = version.split('.').slice(0, 2).map(Number);\n//   }\n//   return {major, minor};\n// }\nfunction getViewport(deck, map, useMapboxProjection = true) {\n    return new WebMercatorViewport({\n        id: 'mapbox',\n        x: 0,\n        y: 0,\n        width: deck.width,\n        height: deck.height,\n        ...getViewState(map),\n        nearZMultiplier: useMapboxProjection\n            ? // match mapbox-gl@>=1.3.0's projection matrix\n                0.02\n            : // use deck.gl's own default\n                0.1,\n        nearZ: map.transform._nearZ / map.transform.height,\n        farZ: map.transform._farZ / map.transform.height\n    });\n}\nfunction afterRender(deck, map) {\n    const { mapboxLayers, isExternal } = deck.userData;\n    if (isExternal) {\n        // Draw non-Mapbox layers\n        const mapboxLayerIds = Array.from(mapboxLayers, layer => layer.id);\n        const deckLayers = flatten(deck.props.layers, Boolean);\n        const hasNonMapboxLayers = deckLayers.some(layer => layer && !mapboxLayerIds.includes(layer.id));\n        let viewports = deck.getViewports();\n        const mapboxViewportIdx = viewports.findIndex(vp => vp.id === 'mapbox');\n        const hasNonMapboxViews = viewports.length > 1 || mapboxViewportIdx < 0;\n        if (hasNonMapboxLayers || hasNonMapboxViews) {\n            if (mapboxViewportIdx >= 0) {\n                viewports = viewports.slice();\n                viewports[mapboxViewportIdx] = getViewport(deck, map, false);\n            }\n            deck._drawLayers('mapbox-repaint', {\n                viewports,\n                layerFilter: params => (!deck.props.layerFilter || deck.props.layerFilter(params)) &&\n                    (params.viewport.id !== 'mapbox' || !mapboxLayerIds.includes(params.layer.id)),\n                clearCanvas: false\n            });\n        }\n    }\n    // End of render cycle, clear generated viewport\n    deck.userData.currentViewport = null;\n}\nfunction onMapMove(deck, map) {\n    deck.setProps({\n        viewState: getViewState(map)\n    });\n    // Camera changed, will trigger a map repaint right after this\n    // Clear any change flag triggered by setting viewState so that deck does not request\n    // a second repaint\n    deck.needsRedraw({ clearRedrawFlags: true });\n}\nfunction updateLayers(deck) {\n    if (deck.userData.isExternal) {\n        return;\n    }\n    const layers = [];\n    deck.userData.mapboxLayers.forEach(deckLayer => {\n        const LayerType = deckLayer.props.type;\n        const layer = new LayerType(deckLayer.props);\n        layers.push(layer);\n    });\n    deck.setProps({ layers });\n}\n", "import { getDeckInstance, addLayer, removeLayer, updateLayer, drawLayer } from \"./deck-utils.js\";\nimport { log } from '@deck.gl/core';\nexport default class MapboxLayer {\n    /* eslint-disable no-this-before-super */\n    constructor(props) {\n        if (!props.id) {\n            throw new Error('Layer must have an unique id');\n        }\n        this.id = props.id;\n        this.type = 'custom';\n        this.renderingMode = props.renderingMode || '3d';\n        this.map = null;\n        this.deck = null;\n        this.props = props;\n    }\n    /* Mapbox custom layer methods */\n    onAdd(map, gl) {\n        if (gl instanceof WebGLRenderingContext) {\n            log.warn('Use useWebGL2:true in mapboxgl.Map()')();\n            return;\n        }\n        this.map = map;\n        this.deck = getDeckInstance({ map, gl, deck: this.props.deck });\n        addLayer(this.deck, this);\n    }\n    onRemove() {\n        if (this.deck) {\n            removeLayer(this.deck, this);\n        }\n    }\n    setProps(props) {\n        // id cannot be changed\n        Object.assign(this.props, props, { id: this.id });\n        // safe guard in case setProps is called before onAdd\n        if (this.deck) {\n            updateLayer(this.deck, this);\n        }\n    }\n    render() {\n        drawLayer(this.deck, this.map, this);\n    }\n}\n", "import { Deck, assert } from '@deck.gl/core';\nimport { getViewState, getDeckInstance, removeDeckInstance, getInterleavedProps } from \"./deck-utils.js\";\nimport { resolveLayers } from \"./resolve-layers.js\";\n/**\n * Implements Mapbox [IControl](https://docs.mapbox.com/mapbox-gl-js/api/markers/#icontrol) interface\n * Renders deck.gl layers over the base map and automatically synchronizes with the map's camera\n */\nexport default class MapboxOverlay {\n    constructor(props) {\n        this._handleStyleChange = () => {\n            resolveLayers(this._map, this._deck, this._props.layers, this._props.layers);\n        };\n        this._updateContainerSize = () => {\n            if (this._map && this._container) {\n                const { clientWidth, clientHeight } = this._map.getContainer();\n                Object.assign(this._container.style, {\n                    width: `${clientWidth}px`,\n                    height: `${clientHeight}px`\n                });\n            }\n        };\n        this._updateViewState = () => {\n            const deck = this._deck;\n            if (deck) {\n                // @ts-ignore (2345) map is always defined if deck is\n                deck.setProps({ viewState: getViewState(this._map) });\n                // Redraw immediately if view state has changed\n                if (deck.isInitialized) {\n                    deck.redraw();\n                }\n            }\n        };\n        // eslint-disable-next-line complexity\n        this._handleMouseEvent = (event) => {\n            const deck = this._deck;\n            if (!deck || !deck.isInitialized) {\n                return;\n            }\n            const mockEvent = {\n                type: event.type,\n                offsetCenter: event.point,\n                srcEvent: event\n            };\n            const lastDown = this._lastMouseDownPoint;\n            if (!event.point && lastDown) {\n                // drag* events do not contain a `point` field\n                mockEvent.deltaX = event.originalEvent.clientX - lastDown.clientX;\n                mockEvent.deltaY = event.originalEvent.clientY - lastDown.clientY;\n                mockEvent.offsetCenter = {\n                    x: lastDown.x + mockEvent.deltaX,\n                    y: lastDown.y + mockEvent.deltaY\n                };\n            }\n            switch (mockEvent.type) {\n                case 'mousedown':\n                    deck._onPointerDown(mockEvent);\n                    this._lastMouseDownPoint = {\n                        ...event.point,\n                        clientX: event.originalEvent.clientX,\n                        clientY: event.originalEvent.clientY\n                    };\n                    break;\n                case 'dragstart':\n                    mockEvent.type = 'panstart';\n                    deck._onEvent(mockEvent);\n                    break;\n                case 'drag':\n                    mockEvent.type = 'panmove';\n                    deck._onEvent(mockEvent);\n                    break;\n                case 'dragend':\n                    mockEvent.type = 'panend';\n                    deck._onEvent(mockEvent);\n                    break;\n                case 'click':\n                    mockEvent.tapCount = 1;\n                    deck._onEvent(mockEvent);\n                    break;\n                case 'dblclick':\n                    mockEvent.type = 'click';\n                    mockEvent.tapCount = 2;\n                    deck._onEvent(mockEvent);\n                    break;\n                case 'mousemove':\n                    mockEvent.type = 'pointermove';\n                    deck._onPointerMove(mockEvent);\n                    break;\n                case 'mouseout':\n                    mockEvent.type = 'pointerleave';\n                    deck._onPointerMove(mockEvent);\n                    break;\n                default:\n                    return;\n            }\n        };\n        const { interleaved = false, ...otherProps } = props;\n        this._interleaved = interleaved;\n        this._props = otherProps;\n    }\n    /** Update (partial) props of the underlying Deck instance. */\n    setProps(props) {\n        if (this._interleaved && props.layers) {\n            resolveLayers(this._map, this._deck, this._props.layers, props.layers);\n        }\n        Object.assign(this._props, props);\n        if (this._deck) {\n            this._deck.setProps(this._interleaved ? getInterleavedProps(this._props) : this._props);\n        }\n    }\n    /** Called when the control is added to a map */\n    onAdd(map) {\n        this._map = map;\n        return this._interleaved ? this._onAddInterleaved(map) : this._onAddOverlaid(map);\n    }\n    _onAddOverlaid(map) {\n        /* global document */\n        const container = document.createElement('div');\n        Object.assign(container.style, {\n            position: 'absolute',\n            left: 0,\n            top: 0,\n            pointerEvents: 'none'\n        });\n        this._container = container;\n        this._deck = new Deck({\n            ...this._props,\n            parent: container,\n            viewState: getViewState(map)\n        });\n        map.on('resize', this._updateContainerSize);\n        map.on('render', this._updateViewState);\n        map.on('mousedown', this._handleMouseEvent);\n        map.on('dragstart', this._handleMouseEvent);\n        map.on('drag', this._handleMouseEvent);\n        map.on('dragend', this._handleMouseEvent);\n        map.on('mousemove', this._handleMouseEvent);\n        map.on('mouseout', this._handleMouseEvent);\n        map.on('click', this._handleMouseEvent);\n        map.on('dblclick', this._handleMouseEvent);\n        this._updateContainerSize();\n        return container;\n    }\n    _onAddInterleaved(map) {\n        this._deck = getDeckInstance({\n            map,\n            // @ts-ignore non-public map property\n            gl: map.painter.context.gl,\n            deck: new Deck({\n                ...this._props,\n                // @ts-ignore non-public map property\n                gl: map.painter.context.gl\n            })\n        });\n        map.on('styledata', this._handleStyleChange);\n        resolveLayers(map, this._deck, [], this._props.layers);\n        return document.createElement('div');\n    }\n    /** Called when the control is removed from a map */\n    onRemove() {\n        const map = this._map;\n        if (map) {\n            if (this._interleaved) {\n                this._onRemoveInterleaved(map);\n            }\n            else {\n                this._onRemoveOverlaid(map);\n            }\n        }\n        this._deck = undefined;\n        this._map = undefined;\n        this._container = undefined;\n    }\n    _onRemoveOverlaid(map) {\n        map.off('resize', this._updateContainerSize);\n        map.off('render', this._updateViewState);\n        map.off('mousedown', this._handleMouseEvent);\n        map.off('dragstart', this._handleMouseEvent);\n        map.off('drag', this._handleMouseEvent);\n        map.off('dragend', this._handleMouseEvent);\n        map.off('mousemove', this._handleMouseEvent);\n        map.off('mouseout', this._handleMouseEvent);\n        map.off('click', this._handleMouseEvent);\n        map.off('dblclick', this._handleMouseEvent);\n        this._deck?.finalize();\n    }\n    _onRemoveInterleaved(map) {\n        map.off('styledata', this._handleStyleChange);\n        resolveLayers(map, this._deck, this._props.layers, []);\n        removeDeckInstance(map);\n    }\n    getDefaultPosition() {\n        return 'top-left';\n    }\n    /** Forwards the Deck.pickObject method */\n    pickObject(params) {\n        assert(this._deck);\n        return this._deck.pickObject(params);\n    }\n    /** Forwards the Deck.pickMultipleObjects method */\n    pickMultipleObjects(params) {\n        assert(this._deck);\n        return this._deck.pickMultipleObjects(params);\n    }\n    /** Forwards the Deck.pickObjects method */\n    pickObjects(params) {\n        assert(this._deck);\n        return this._deck.pickObjects(params);\n    }\n    /** Remove from map and releases all resources */\n    finalize() {\n        if (this._map) {\n            this._map.removeControl(this);\n        }\n    }\n    /** If interleaved: true, returns base map's canvas, otherwise forwards the Deck.getCanvas method. */\n    getCanvas() {\n        if (!this._map) {\n            return null;\n        }\n        return this._interleaved ? this._map.getCanvas() : this._deck.getCanvas();\n    }\n}\n", "import { _flatten as flatten } from '@deck.gl/core';\nimport MapboxLayer from \"./mapbox-layer.js\";\nconst UNDEFINED_BEFORE_ID = '__UNDEFINED__';\n/** Insert Deck layers into the mapbox Map according to the user-defined order */\n// eslint-disable-next-line complexity, max-statements\nexport function resolveLayers(map, deck, oldLayers, newLayers) {\n    // Wait until map style is loaded\n    // @ts-ignore non-public map property\n    if (!map || !deck || !map.style || !map.style._loaded) {\n        return;\n    }\n    const layers = flatten(newLayers, Boolean);\n    if (oldLayers !== newLayers) {\n        // Step 1: remove layers that no longer exist\n        const prevLayers = flatten(oldLayers, Boolean);\n        const prevLayerIds = new Set(prevLayers.map(l => l.id));\n        for (const layer of layers) {\n            prevLayerIds.delete(layer.id);\n        }\n        for (const id of prevLayerIds) {\n            if (map.getLayer(id)) {\n                map.removeLayer(id);\n            }\n        }\n    }\n    // Step 2: add missing layers\n    for (const layer of layers) {\n        const mapboxLayer = map.getLayer(layer.id);\n        if (mapboxLayer) {\n            // @ts-expect-error not typed\n            mapboxLayer.implementation.setProps(layer.props);\n        }\n        else {\n            map.addLayer(new MapboxLayer({ id: layer.id, deck }), \n            // @ts-expect-error beforeId is not defined in LayerProps\n            layer.props.beforeId);\n        }\n    }\n    // Step 3: check the order of layers\n    // If beforeId is defined, the deck layer should always render before the mapbox layer [beforeId]\n    // If beforeId is not defined, the deck layer should appear after all mapbox layers\n    // When two deck layers share the same beforeId, they are rendered in the order that is passed into Deck props.layers\n    // @ts-ignore non-public map property\n    const mapLayers = map.style._order;\n    // Group deck layers by beforeId\n    const layerGroups = {};\n    for (const layer of layers) {\n        // @ts-expect-error beforeId is not defined in LayerProps\n        let { beforeId } = layer.props;\n        if (!beforeId || !mapLayers.includes(beforeId)) {\n            beforeId = UNDEFINED_BEFORE_ID;\n        }\n        layerGroups[beforeId] = layerGroups[beforeId] || [];\n        layerGroups[beforeId].push(layer.id);\n    }\n    for (const beforeId in layerGroups) {\n        const layerGroup = layerGroups[beforeId];\n        let lastLayerIndex = beforeId === UNDEFINED_BEFORE_ID ? mapLayers.length : mapLayers.indexOf(beforeId);\n        let lastLayerId = beforeId === UNDEFINED_BEFORE_ID ? undefined : beforeId;\n        for (let i = layerGroup.length - 1; i >= 0; i--) {\n            const layerId = layerGroup[i];\n            const layerIndex = mapLayers.indexOf(layerId);\n            if (layerIndex !== lastLayerIndex - 1) {\n                map.moveLayer(layerId, lastLayerId);\n                if (layerIndex > lastLayerIndex) {\n                    // The last layer's index have changed\n                    lastLayerIndex++;\n                }\n            }\n            lastLayerIndex--;\n            lastLayerId = layerId;\n        }\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["flatten", "import_core", "import_core", "import_core", "flatten"]
+}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { default as MapboxLayer } from "./mapbox-layer.js";
+export { default as MapboxOverlay } from "./mapbox-overlay.js";

package/dist/mapbox-layer.js

@@ -0,0 +1,42 @@
+import { getDeckInstance, addLayer, removeLayer, updateLayer, drawLayer } from "./deck-utils.js";
+import { log } from '@deck.gl/core';
+export default class MapboxLayer {
+    /* eslint-disable no-this-before-super */
+    constructor(props) {
+        if (!props.id) {
+            throw new Error('Layer must have an unique id');
+        }
+        this.id = props.id;
+        this.type = 'custom';
+        this.renderingMode = props.renderingMode || '3d';
+        this.map = null;
+        this.deck = null;
+        this.props = props;
+    }
+    /* Mapbox custom layer methods */
+    onAdd(map, gl) {
+        if (gl instanceof WebGLRenderingContext) {
+            log.warn('Use useWebGL2:true in mapboxgl.Map()')();
+            return;
+        }
+        this.map = map;
+        this.deck = getDeckInstance({ map, gl, deck: this.props.deck });
+        addLayer(this.deck, this);
+    }
+    onRemove() {
+        if (this.deck) {
+            removeLayer(this.deck, this);
+        }
+    }
+    setProps(props) {
+        // id cannot be changed
+        Object.assign(this.props, props, { id: this.id });
+        // safe guard in case setProps is called before onAdd
+        if (this.deck) {
+            updateLayer(this.deck, this);
+        }
+    }
+    render() {
+        drawLayer(this.deck, this.map, this);
+    }
+}