@mapvx/web-js 3.5.1 → 3.6.0-dev.1

package/dist/umd/index.js

@@ -11181,7 +11181,7 @@ const extractSafariExtensionDetails = (func, filename) => {
 // exists only for the type-checker, so in the ES/CJS builds the identifier is
 // genuinely absent and a direct comparison throws ReferenceError at module load.
 // `typeof` is the only safe way to probe a possibly-undeclared global.
-var sentry_SDK_VERSION =  false ? 0 : "3.5.1";
+var sentry_SDK_VERSION =  false ? 0 : "3.6.0-dev.1";
 var DSN =  false ? 0 : "https://872f598f020e3cd73a0933b562d24c81@sentry.mapvx.app/5";
 
 /**
@@ -21864,10 +21864,13 @@ function fitCamera_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a =
  */
 
 /**
- * Minimal structural view of a maplibre transform clone (`map.transform.clone()`).
+ * Minimal camera simulator: the projection surface {@link refineCameraForPitch} needs to try a
+ * candidate camera without the map being in that state.
  *
- * We depend on the shape rather than the (non-exported) `ITransform` interface so
- * the coupling stays explicit and version changes surface as type errors here.
+ * Structural on purpose. It began as the shape of `map.transform.clone()`, and depending on the
+ * shape rather than maplibre's non-exported `ITransform` is what made the v6 removal of
+ * `map.transform` a local change: see `LiveMapFitTransform`, which satisfies this interface
+ * through the map's public API instead.
  */
 
 /** maplibre world size (px) at zoom 0: tileSize (512) * 2^0. */
@@ -21961,7 +21964,7 @@ function computeOrientedCamera(coordinates, params) {
  * If any point falls behind the horizon during refinement, it bails out and
  * returns the best camera computed so far (never worse than the flat input).
  *
- * @param transform A `map.transform.clone()` used purely for projection.
+ * @param transform Camera simulator used purely for projection; the caller owns its lifecycle.
  * @param coordinates Points to fit.
  * @param initial The orthographic camera to refine.
  * @param params Bearing, pitch, padding and viewport constraints.
@@ -22036,6 +22039,203 @@ function refineCameraForPitch(transform, coordinates, initial, params) {
   }
   return best;
 }
+;// ./src/map/liveMapFitTransform.ts
+function liveMapFitTransform_typeof(o) { "@babel/helpers - typeof"; return liveMapFitTransform_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, liveMapFitTransform_typeof(o); }
+function liveMapFitTransform_ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function liveMapFitTransform_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? liveMapFitTransform_ownKeys(Object(t), !0).forEach(function (r) { liveMapFitTransform_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : liveMapFitTransform_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function liveMapFitTransform_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function liveMapFitTransform_defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, liveMapFitTransform_toPropertyKey(o.key), o); } }
+function liveMapFitTransform_createClass(e, r, t) { return r && liveMapFitTransform_defineProperties(e.prototype, r), t && liveMapFitTransform_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function liveMapFitTransform_defineProperty(e, r, t) { return (r = liveMapFitTransform_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function liveMapFitTransform_toPropertyKey(t) { var i = liveMapFitTransform_toPrimitive(t, "string"); return "symbol" == liveMapFitTransform_typeof(i) ? i : i + ""; }
+function liveMapFitTransform_toPrimitive(t, r) { if ("object" != liveMapFitTransform_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != liveMapFitTransform_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Screen-space tolerance, in pixels, for the horizon round-trip test.
+ *
+ * `project` and `unproject` are not exact inverses — they run through a 4x4 matrix and its
+ * inverse, so a well-behaved point still drifts by a fraction of a pixel. Half a pixel is far
+ * below that drift's ceiling and far above the millions-of-pixels divergence a point behind the
+ * horizon produces, so the threshold is not sensitive to its exact value.
+ */
+var SURFACE_ROUND_TRIP_EPSILON_PX = 0.5;
+
+/**
+ * A {@link FitTransform} backed by a live MapLibre map and its public API.
+ *
+ * ## Why this exists
+ *
+ * {@link refineCameraForPitch} needs to project points through MapLibre's real perspective
+ * projection for camera states the map is not actually in — it tries a candidate camera, measures
+ * where the geometry lands, adjusts, and repeats. Until MapLibre v6 that was done on
+ * `map.transform.clone()`, a detached copy of the internal transform.
+ *
+ * v6 removed `map.transform` and exposes no replacement: there is no exported `Camera`,
+ * `Transform` or `MercatorTransform`, and the migration guide says only "use `Map`'s public API
+ * instead". So the simulation moves onto the map itself.
+ *
+ * ## How it stays invisible
+ *
+ * The map is genuinely moved, but never painted mid-simulation: MapLibre renders on
+ * `requestAnimationFrame`, and every mutation here happens inside one synchronous block that ends
+ * with {@link restore}. No intermediate frame exists to be seen.
+ *
+ * Camera writes are also batched. Setters only record intent; the map is moved at most once per
+ * refinement iteration, lazily, the first time a projection actually needs the new camera.
+ *
+ * ## What it costs
+ *
+ * `jumpTo` fires camera events, so listeners observe movement that no user caused. At the only
+ * call site this is bounded — the refinement is immediately followed by a real `easeTo`, so the
+ * map was going to move regardless, and the `moveend` handler that reports completion is attached
+ * *after* refinement and so cannot see the simulation's events.
+ *
+ * @example
+ * ```typescript
+ * const transform = new LiveMapFitTransform(map)
+ * try {
+ *   camera = refineCameraForPitch(transform, coordinates, camera, params)
+ * } finally {
+ *   transform.restore()
+ * }
+ * ```
+ *
+ * @group Map
+ */
+var LiveMapFitTransform = /*#__PURE__*/function () {
+  /**
+   * Capture the map's current camera so it can be restored, and seed the simulation with it.
+   *
+   * @param map The live map to simulate on.
+   */
+  function LiveMapFitTransform(map) {
+    var _this = this,
+      _padding$top,
+      _padding$bottom,
+      _padding$left,
+      _padding$right;
+    liveMapFitTransform_classCallCheck(this, LiveMapFitTransform);
+    /** Camera state to put back in {@link restore}. */
+    /** Pending camera state; written by the setters, flushed by {@link sync}. */
+    /** Whether {@link pending} has diverged from what the map is currently showing. */
+    liveMapFitTransform_defineProperty(this, "dirty", false);
+    /**
+     * Whether the map was ever actually moved.
+     *
+     * Tracked separately from {@link dirty}, which {@link sync} clears the moment it flushes: keying
+     * {@link restore} off `dirty` alone would make it a no-op right after a flush and strand the map
+     * on a candidate camera.
+     */
+    liveMapFitTransform_defineProperty(this, "moved", false);
+    liveMapFitTransform_defineProperty(this, "setCenter", function (center) {
+      _this.pending.center = center;
+      _this.dirty = true;
+    });
+    liveMapFitTransform_defineProperty(this, "setZoom", function (zoom) {
+      _this.pending.zoom = zoom;
+      _this.dirty = true;
+    });
+    liveMapFitTransform_defineProperty(this, "setBearing", function (bearing) {
+      _this.pending.bearing = bearing;
+      _this.dirty = true;
+    });
+    liveMapFitTransform_defineProperty(this, "setPitch", function (pitch) {
+      _this.pending.pitch = pitch;
+      _this.dirty = true;
+    });
+    liveMapFitTransform_defineProperty(this, "setPadding", function (padding) {
+      _this.pending.padding = padding;
+      _this.dirty = true;
+    });
+    liveMapFitTransform_defineProperty(this, "locationToScreenPoint", function (lnglat) {
+      _this.sync();
+      return _this.map.project(lnglat);
+    });
+    liveMapFitTransform_defineProperty(this, "screenPointToLocation", function (p) {
+      _this.sync();
+      return _this.map.unproject(p);
+    });
+    /**
+     * Whether a projected point lies on the visible map surface rather than beyond the horizon.
+     *
+     * MapLibre exposes no public horizon test, so this uses a round-trip: unprojecting a screen
+     * point casts a ray onto the map plane, and re-projecting that location lands back where it
+     * started only if the ray actually met the plane in front of the camera. Past the horizon the
+     * ray diverges and the round-trip misses by an enormous margin.
+     *
+     * @param p Screen point, as returned by {@link locationToScreenPoint}.
+     * @returns `true` when the point is on the map surface.
+     */
+    liveMapFitTransform_defineProperty(this, "isPointOnMapSurface", function (p) {
+      _this.sync();
+      var roundTripped = _this.map.project(_this.map.unproject(p));
+      return Number.isFinite(roundTripped.x) && Number.isFinite(roundTripped.y) && Math.abs(roundTripped.x - p.x) < SURFACE_ROUND_TRIP_EPSILON_PX && Math.abs(roundTripped.y - p.y) < SURFACE_ROUND_TRIP_EPSILON_PX;
+    });
+    /**
+     * Put the camera back exactly as it was when this instance was constructed.
+     *
+     * Safe to call more than once, and safe to call when nothing was ever changed. Always call it
+     * from a `finally` block so a throw mid-refinement cannot strand the map on a candidate camera.
+     */
+    liveMapFitTransform_defineProperty(this, "restore", function () {
+      if (!_this.moved) {
+        return;
+      }
+      _this.map.jumpTo({
+        center: _this.snapshot.center,
+        zoom: _this.snapshot.zoom,
+        bearing: _this.snapshot.bearing,
+        pitch: _this.snapshot.pitch,
+        padding: _this.snapshot.padding
+      });
+      _this.pending = liveMapFitTransform_objectSpread({}, _this.snapshot);
+      _this.dirty = false;
+      _this.moved = false;
+    });
+    this.map = map;
+    var _padding = map.getPadding();
+    this.snapshot = {
+      center: map.getCenter(),
+      zoom: map.getZoom(),
+      bearing: map.getBearing(),
+      pitch: map.getPitch(),
+      padding: {
+        top: (_padding$top = _padding.top) !== null && _padding$top !== void 0 ? _padding$top : 0,
+        bottom: (_padding$bottom = _padding.bottom) !== null && _padding$bottom !== void 0 ? _padding$bottom : 0,
+        left: (_padding$left = _padding.left) !== null && _padding$left !== void 0 ? _padding$left : 0,
+        right: (_padding$right = _padding.right) !== null && _padding$right !== void 0 ? _padding$right : 0
+      }
+    };
+    this.pending = liveMapFitTransform_objectSpread({}, this.snapshot);
+  }
+  return liveMapFitTransform_createClass(LiveMapFitTransform, [{
+    key: "center",
+    get: function get() {
+      return this.pending.center;
+    }
+  }, {
+    key: "zoom",
+    get: function get() {
+      return this.pending.zoom;
+    }
+  }, {
+    key: "sync",
+    value: /** Flush {@link pending} onto the map, but only when a projection actually needs it. */
+    function sync() {
+      if (!this.dirty) {
+        return;
+      }
+      this.map.jumpTo({
+        center: this.pending.center,
+        zoom: this.pending.zoom,
+        bearing: this.pending.bearing,
+        pitch: this.pending.pitch,
+        padding: this.pending.padding
+      });
+      this.dirty = false;
+      this.moved = true;
+    }
+  }]);
+}();
 ;// ./src/map/mapInteractionOptions.ts
 /**
  * Highest pitch MapLibre accepts for `minPitch`/`maxPitch` (it rejects anything
@@ -22350,6 +22550,7 @@ function convertPaddingToPixels(padding, containerWidth, containerHeight) {
 
 
 
+
 /**
  * @group Map
  */
@@ -24357,9 +24558,18 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       // With a tilted camera the orthographic zoom is off due to perspective, so
       // refine it against maplibre's real projection on a cloned transform.
       if (pitch > 0) {
-        camera = refineCameraForPitch(this.map.transform.clone(), coordinates, camera, map_objectSpread(map_objectSpread({}, cameraParams), {}, {
-          pitch: pitch
-        }));
+        // Simulated on the live map through its public API rather than on `map.transform.clone()`:
+        // MapLibre v6 removes the internal transform and exposes no replacement. The whole loop is
+        // synchronous and ends in `restore()`, so no intermediate frame is ever painted.
+        // See DEVELOPER_DOCS/MAPLIBRE_V6_MIGRATION.md.
+        var fitTransform = new LiveMapFitTransform(this.map);
+        try {
+          camera = refineCameraForPitch(fitTransform, coordinates, camera, map_objectSpread(map_objectSpread({}, cameraParams), {}, {
+            pitch: pitch
+          }));
+        } finally {
+          fitTransform.restore();
+        }
       }
       if (onComplete) {
         void this.map.once("moveend", onComplete);