@deck.gl/arcgis 9.4.0-beta.1 → 9.4.0-beta.3

package/dist/dist.dev.js

@@ -11463,8 +11463,8 @@ void main(void) {
       }
       return PROJECTION_MODE.IDENTITY;
     }
-    // Two viewports are equal if width and height are identical, and if
-    // their view and projection matrices are (approximately) equal.
+    // Two viewports are equal if their dimensions, common-space scale, and
+    // view and projection matrices are (approximately) equal.
     equals(viewport) {
       if (!(viewport instanceof _Viewport)) {
         return false;
@@ -11472,7 +11472,7 @@ void main(void) {
       if (this === viewport) {
         return true;
       }
-      return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix);
+      return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && viewport.projectionMode === this.projectionMode && viewport.resolution === this.resolution && equals(viewport.distanceScales.unitsPerMeter, this.distanceScales.unitsPerMeter) && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix);
     }
     /**
      * Projects xyz (possibly latitude and longitude) to pixel coordinates in window
@@ -11807,6 +11807,10 @@ void main(void) {
       }
       return this._subViewports;
     }
+    /** Returns whether two Web Mercator viewports use the same projection settings. */
+    equals(viewport) {
+      return viewport instanceof _WebMercatorViewport && viewport._pseudoMeters === this._pseudoMeters && super.equals(viewport);
+    }
     projectPosition(xyz) {
       if (this._pseudoMeters) {
         return super.projectPosition(xyz);
@@ -12177,178 +12181,6 @@ void main(void) {
     }
   };
 
-  // ../core/src/viewports/globe-viewport.ts
-  var DEGREES_TO_RADIANS5 = Math.PI / 180;
-  var RADIANS_TO_DEGREES3 = 180 / Math.PI;
-  var EARTH_RADIUS = 6370972;
-  var GLOBE_RADIUS = 256;
-  function getDistanceScales2() {
-    const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS;
-    const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS;
-    return {
-      unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2],
-      unitsPerMeter2: [0, 0, 0],
-      metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2],
-      unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2],
-      unitsPerDegree2: [0, 0, 0],
-      degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2]
-    };
-  }
-  var GlobeViewport = class extends Viewport {
-    constructor(opts = {}) {
-      const {
-        longitude = 0,
-        bearing = 0,
-        pitch = 0,
-        zoom = 0,
-        // Matches Maplibre defaults
-        // https://github.com/maplibre/maplibre-gl-js/blob/f8ab4b48d59ab8fe7b068b102538793bbdd4c848/src/geo/projection/globe_transform.ts#L632-L633
-        nearZMultiplier = 0.5,
-        farZMultiplier = 1,
-        resolution = 10
-      } = opts;
-      let { latitude = 0, height, altitude = 1.5, fovy } = opts;
-      latitude = Math.max(Math.min(latitude, 90), -90);
-      height = height || 1;
-      if (fovy) {
-        altitude = fovyToAltitude(fovy);
-      } else {
-        fovy = altitudeToFovy(altitude);
-      }
-      const scaleLatitude = Math.max(Math.min(latitude, MAX_LATITUDE), -MAX_LATITUDE);
-      const scale5 = Math.pow(2, zoom - zoomAdjust(scaleLatitude));
-      const pitchRadians = pitch * DEGREES_TO_RADIANS5;
-      const nearZ = opts.nearZ ?? nearZMultiplier;
-      const farZ = opts.farZ ?? (altitude + GLOBE_RADIUS * 2 * scale5 / height / Math.max(Math.cos(pitchRadians), 0.1)) * farZMultiplier;
-      const viewMatrix = new Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }).rotateX(-pitchRadians).rotateY(-bearing * DEGREES_TO_RADIANS5).rotateX(latitude * DEGREES_TO_RADIANS5).rotateZ(-longitude * DEGREES_TO_RADIANS5).scale(scale5 / height);
-      super({
-        ...opts,
-        // x, y, width,
-        height,
-        // view matrix
-        viewMatrix,
-        longitude,
-        latitude,
-        zoom,
-        // projection matrix parameters
-        distanceScales: getDistanceScales2(),
-        fovy,
-        focalDistance: altitude,
-        near: nearZ,
-        far: farZ
-      });
-      this.scale = scale5;
-      this.latitude = latitude;
-      this.longitude = longitude;
-      this.bearing = bearing;
-      this.pitch = pitch;
-      this.fovy = fovy;
-      this.resolution = resolution;
-    }
-    get projectionMode() {
-      return PROJECTION_MODE.GLOBE;
-    }
-    getDistanceScales() {
-      return this.distanceScales;
-    }
-    getBounds(options = {}) {
-      const unprojectOption = { targetZ: options.z || 0 };
-      const left = this.unproject([0, this.height / 2], unprojectOption);
-      const top = this.unproject([this.width / 2, 0], unprojectOption);
-      const right = this.unproject([this.width, this.height / 2], unprojectOption);
-      const bottom = this.unproject([this.width / 2, this.height], unprojectOption);
-      if (right[0] < this.longitude) right[0] += 360;
-      if (left[0] > this.longitude) left[0] -= 360;
-      return [
-        Math.min(left[0], right[0], top[0], bottom[0]),
-        Math.min(left[1], right[1], top[1], bottom[1]),
-        Math.max(left[0], right[0], top[0], bottom[0]),
-        Math.max(left[1], right[1], top[1], bottom[1])
-      ];
-    }
-    unproject(xyz, { topLeft = true, targetZ } = {}) {
-      const [x, y, z] = xyz;
-      const y2 = topLeft ? y : this.height - y;
-      const { pixelUnprojectionMatrix } = this;
-      let coord;
-      if (Number.isFinite(z)) {
-        coord = transformVector2(pixelUnprojectionMatrix, [x, y2, z, 1]);
-      } else {
-        const coord0 = transformVector2(pixelUnprojectionMatrix, [x, y2, -1, 1]);
-        const coord1 = transformVector2(pixelUnprojectionMatrix, [x, y2, 1, 1]);
-        const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-        const lSqr = vec3_exports.sqrLen(vec3_exports.sub([], coord0, coord1));
-        const l0Sqr = vec3_exports.sqrLen(coord0);
-        const l1Sqr = vec3_exports.sqrLen(coord1);
-        const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16;
-        const dSqr = 4 * sSqr / lSqr;
-        const r0 = Math.sqrt(l0Sqr - dSqr);
-        const dr = Math.sqrt(Math.max(0, lt * lt - dSqr));
-        const t = (r0 - dr) / Math.sqrt(lSqr);
-        coord = vec3_exports.lerp([], coord0, coord1, t);
-      }
-      const [X, Y, Z] = this.unprojectPosition(coord);
-      if (Number.isFinite(z)) {
-        return [X, Y, Z];
-      }
-      return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];
-    }
-    projectPosition(xyz) {
-      const [lng, lat, Z = 0] = xyz;
-      const lambda = lng * DEGREES_TO_RADIANS5;
-      const phi = lat * DEGREES_TO_RADIANS5;
-      const cosPhi = Math.cos(phi);
-      const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-      return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D];
-    }
-    unprojectPosition(xyz) {
-      const [x, y, z] = xyz;
-      const D = vec3_exports.len(xyz);
-      const phi = Math.asin(z / D);
-      const lambda = Math.atan2(x, -y);
-      const lng = lambda * RADIANS_TO_DEGREES3;
-      const lat = phi * RADIANS_TO_DEGREES3;
-      const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS;
-      return [lng, lat, Z];
-    }
-    projectFlat(xyz) {
-      return xyz;
-    }
-    unprojectFlat(xyz) {
-      return xyz;
-    }
-    /**
-     * Pan the globe using delta-based movement
-     * @param coords - the geographic coordinates where the pan started
-     * @param pixel - the current screen position
-     * @param startPixel - the screen position where the pan started
-     * @returns updated viewport options with new longitude/latitude
-     */
-    panByPosition([startLng, startLat, startZoom], pixel, startPixel) {
-      const scale5 = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
-      const rotationSpeed = 0.25 / scale5;
-      const longitude = startLng + rotationSpeed * (startPixel[0] - pixel[0]);
-      let latitude = startLat - rotationSpeed * (startPixel[1] - pixel[1]);
-      latitude = Math.max(Math.min(latitude, 90), -90);
-      const out = { longitude, latitude, zoom: startZoom - zoomAdjust(startLat) };
-      out.zoom += zoomAdjust(out.latitude);
-      return out;
-    }
-  };
-  GlobeViewport.displayName = "GlobeViewport";
-  function zoomAdjust(latitude, clampToPoles) {
-    if (clampToPoles) {
-      latitude = Math.max(Math.min(latitude, MAX_LATITUDE), -MAX_LATITUDE);
-    }
-    const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
-    return Math.log2(scaleAdjust);
-  }
-  function transformVector2(matrix, vector) {
-    const result = vec4_exports.transformMat4([], vector, matrix);
-    vec4_exports.scale(result, result, 1 / result[3]);
-    return result;
-  }
-
   // ../core/src/transitions/linear-interpolator.ts
   var DEFAULT_PROPS = ["longitude", "latitude", "zoom", "bearing", "pitch"];
   var DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"];
@@ -12376,21 +12208,16 @@ void main(void) {
       const result = super.initializeProps(startProps, endProps);
       const { makeViewport, around } = this.opts;
       if (makeViewport && around) {
-        const TestViewport = makeViewport(startProps);
-        if (TestViewport instanceof GlobeViewport) {
-          log_default.warn("around not supported in GlobeView")();
-        } else {
-          const startViewport = makeViewport(startProps);
-          const endViewport = makeViewport(endProps);
-          const aroundPosition = startViewport.unproject(around);
-          result.start.around = around;
-          Object.assign(result.end, {
-            around: endViewport.project(aroundPosition),
-            aroundPosition,
-            width: endProps.width,
-            height: endProps.height
-          });
-        }
+        const startViewport = makeViewport(startProps);
+        const endViewport = makeViewport(endProps);
+        const aroundPosition = startViewport.unproject(around);
+        result.start.around = around;
+        Object.assign(result.end, {
+          around: endViewport.project(aroundPosition),
+          aroundPosition,
+          width: endProps.width,
+          height: endProps.height
+        });
       }
       return result;
     }
@@ -12463,6 +12290,7 @@ void main(void) {
       this.touchRotate = false;
       this.multiTouchDrag = null;
       this.trackpadGesture = false;
+      this.zoomAround = "pointer";
       this.keyboard = true;
       this.transitionManager = new TransitionManager({
         ...opts,
@@ -12556,6 +12384,15 @@ void main(void) {
       const { offsetCenter } = event;
       return [offsetCenter.x - x, offsetCenter.y - y];
     }
+    /** Resolves the zoom anchor for pointer-based controls. */
+    getZoomPosition(position) {
+      if (this.zoomAround === "pointer") {
+        return position;
+      }
+      const viewport = this.makeViewport(this.controllerState.getViewportProps());
+      const [centerX, centerY] = worldToPixels(viewport.center, viewport.pixelProjectionMatrix);
+      return [centerX, centerY];
+    }
     isPointInBounds(pos, event) {
       const { width, height } = this.props;
       if (event && event.handled) {
@@ -12613,6 +12450,7 @@ void main(void) {
         touchRotate = false,
         multiTouchDrag = touchRotate ? "rotate" : null,
         trackpadGesture = false,
+        zoomAround = "pointer",
         keyboard = true
       } = props;
       const isInteractive = Boolean(this.onViewStateChange);
@@ -12635,6 +12473,7 @@ void main(void) {
       this.touchRotate = multiTouchDrag === "rotate";
       this.multiTouchDrag = multiTouchDrag;
       this.trackpadGesture = trackpadGesture;
+      this.zoomAround = zoomAround;
       this.keyboard = keyboard;
       const constraintChanged = !oldProps || oldProps.height !== props.height || oldProps.width !== props.width || oldProps.maxBounds !== props.maxBounds || oldProps.maxBoundsPadding !== props.maxBoundsPadding;
       if (constraintChanged && props.maxBounds) {
@@ -12868,8 +12707,9 @@ void main(void) {
       if (delta < 0 && scale5 !== 0) {
         scale5 = 1 / scale5;
       }
-      const transitionProps = smooth ? { ...this._getTransitionProps({ around: pos }), transitionDuration: 250 } : NO_TRANSITION_PROPS;
-      const newControllerState = this.controllerState.zoom({ pos, scale: scale5 });
+      const zoomPosition = this.getZoomPosition(pos);
+      const transitionProps = smooth ? { ...this._getTransitionProps({ around: zoomPosition }), transitionDuration: 250 } : NO_TRANSITION_PROPS;
+      const newControllerState = this.controllerState.zoom({ pos: zoomPosition, scale: scale5 });
       this.updateViewport(newControllerState, transitionProps, {
         isZooming: true,
         isPanning: true
@@ -12955,7 +12795,7 @@ void main(void) {
       if (!this.isPointInBounds(pos, event)) {
         return false;
       }
-      const newControllerState = this.controllerState.zoomStart({ pos }, this._getConstraintContext("zoom", "start")).rotateStart({ pos }, this._getConstraintContext("rotate", "start"));
+      const newControllerState = this.controllerState.zoomStart({ pos: this.getZoomPosition(pos) }, this._getConstraintContext("zoom", "start")).rotateStart({ pos }, this._getConstraintContext("rotate", "start"));
       pinchEventWorkaround._startPinchRotation = event.rotation;
       pinchEventWorkaround._lastPinchEvent = event;
       this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true });
@@ -12974,7 +12814,7 @@ void main(void) {
         const { scale: scale5 } = event;
         const pos = this.getCenter(event);
         newControllerState = newControllerState.zoom(
-          { pos, scale: scale5 },
+          { pos: this.getZoomPosition(pos), scale: scale5 },
           this._getConstraintContext("zoom", "update")
         );
       }
@@ -13002,15 +12842,16 @@ void main(void) {
       const { _lastPinchEvent } = pinchEventWorkaround;
       if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) {
         const pos = this.getCenter(event);
+        const zoomPosition = this.getZoomPosition(pos);
         let newControllerState = this.controllerState.rotateEnd();
         const z = Math.log2(event.scale);
         const velocityZ = (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime);
         const endScale = Math.pow(2, z + velocityZ * inertia / 2);
-        newControllerState = newControllerState.zoom({ pos, scale: endScale }).zoomEnd();
+        newControllerState = newControllerState.zoom({ pos: zoomPosition, scale: endScale }).zoomEnd();
         this.updateViewport(
           newControllerState,
           {
-            ...this._getTransitionProps({ around: pos }),
+            ...this._getTransitionProps({ around: zoomPosition }),
             transitionDuration: inertia,
             transitionEasing: INERTIA_EASING
           },
@@ -13055,8 +12896,12 @@ void main(void) {
         return false;
       }
       const isZoomOut = this.isFunctionKeyPressed(event);
-      const newControllerState = this.controllerState.zoom({ pos, scale: isZoomOut ? 0.5 : 2 });
-      this.updateViewport(newControllerState, this._getTransitionProps({ around: pos }), {
+      const zoomPosition = this.getZoomPosition(pos);
+      const newControllerState = this.controllerState.zoom({
+        pos: zoomPosition,
+        scale: isZoomOut ? 0.5 : 2
+      });
+      this.updateViewport(newControllerState, this._getTransitionProps({ around: zoomPosition }), {
         isZooming: true,
         isPanning: true
       });
@@ -13073,14 +12918,14 @@ void main(void) {
         this._doubleClickDragAnchor = null;
         return false;
       }
-      this._doubleClickDragAnchor = pos;
+      this._doubleClickDragAnchor = this.getZoomPosition(pos);
       let newControllerState = this.controllerState.zoomStart(
-        { pos },
+        { pos: this._doubleClickDragAnchor },
         this._getConstraintContext("zoom", "start")
       );
       if (event.scale !== 1) {
         newControllerState = newControllerState.zoom(
-          { pos, scale: event.scale },
+          { pos: this._doubleClickDragAnchor, scale: event.scale },
           this._getConstraintContext("zoom", "update")
         );
       }