@trackunit/react-map-adapter-shared 0.0.119 → 0.0.121

package/README.md

@@ -36,8 +36,10 @@ The canonical example is geodesic arcs. Google Maps draws great-circle edges nat
 | Export | Source | Role |
 | --- | --- | --- |
 | `densifyGeodesicFeatures` | `geodesicDensify.ts` | Inserts intermediate coordinates along polygon/line edges so a non-geodesic renderer draws great-circle arcs |
-| `intermediatePoint` | `sphericalMath.ts` | Spherical interpolation (slerp) between two coordinates on the WGS-84 sphere |
+| `intermediatePoint` | `sphericalMath.ts` | Spherical interpolation (slerp) between two coordinates on the WGS-84 sphere. The returned longitude is continuous with the segment start, so it may fall outside `[-180, 180]` and will not pass `geoJsonPositionSchema` — treat it as render-only, like the antimeridian helpers below |
 | `angularDistance` | `sphericalMath.ts` | Great-circle (haversine) distance between two coordinates |
+| `unwrapLongitudeNear` | `sphericalMath.ts` | Picks the 360°-periodic longitude branch closest to a reference, so coordinate sequences stay continuous across the antimeridian |
+| `mergeAntimeridianFeatures` | `antimeridianMerge.ts` | Rejoins RFC 7946 split halves and unwraps unsplit dateline crossings, so a Mercator renderer draws the seam edge across ±180° instead of around the world |
 
 If you build a new adapter and hit a provider gap, prefer adding the cross-provider patch here over working around it at the call site.
 

package/index.cjs.js

@@ -37,6 +37,83 @@ const defineAdapter = (factory) => {
     return wrappedFactory;
 };
 
+// ============================================================================
+// Unit conversion
+// ============================================================================
+const toRad = (deg) => (deg * Math.PI) / 180;
+const toDeg = (rad) => (rad * 180) / Math.PI;
+// ============================================================================
+// Longitude branch selection
+// ============================================================================
+/**
+ * Re-express `longitude` in the 360°-periodic branch nearest `reference`, so the two
+ * never differ by more than 180°.
+ *
+ * The result may fall outside `[-180, 180]` — it describes a position continuously
+ * rather than canonically, which is what Mapbox and Google Maps need to draw an edge
+ * across the antimeridian instead of back around the world. Do not persist it or feed
+ * it to a GeoJSON validator.
+ */
+const unwrapLongitudeNear = (longitude, reference) => {
+    const candidate = longitude + 360 * Math.round((reference - longitude) / 360);
+    // Exactly 180° apart both branches sit the same distance from the reference and there is
+    // no shorter path to pick, so leave the longitude where it is instead of flipping it.
+    return Math.abs(candidate - reference) === Math.abs(longitude - reference) ? longitude : candidate;
+};
+// ============================================================================
+// Great-circle math  (sphere model — WGS-84 mean radius)
+// ============================================================================
+/**
+ * Haversine angular distance in radians between two lng/lat points.
+ * Returns a value in [0, π].
+ */
+const angularDistance = (lng1, lat1, lng2, lat2) => {
+    const φ1 = toRad(lat1);
+    const φ2 = toRad(lat2);
+    const Δφ = toRad(lat2 - lat1);
+    const Δλ = toRad(lng2 - lng1);
+    const a = Math.sin(Δφ / 2) ** 2 + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) ** 2;
+    const clampedA = Math.max(0, Math.min(1, a));
+    return 2 * Math.atan2(Math.sqrt(clampedA), Math.sqrt(1 - clampedA));
+};
+/**
+ * Spherical-interpolation intermediate point at fraction `f` (0 = start, 1 = end)
+ * along the great-circle arc defined by `delta` (pre-computed angular distance).
+ *
+ * Formula: http://www.movable-type.co.uk/scripts/latlong.html#intermediate-point
+ *
+ * If `start` carries an altitude the result linearly interpolates it; otherwise
+ * the result is 2-D.
+ *
+ * The returned longitude is continuous with `start[0]` rather than canonical, so
+ * interpolating across the antimeridian yields 175° → 180° → 185° instead of
+ * 175° → 180° → −175°. That keeps consecutive samples monotonic for callers that
+ * difference them (densification, tangent angles) and makes this safe to call on
+ * already-unwrapped input. See {@link unwrapLongitudeNear}.
+ */
+const intermediatePoint = (start, end, f, delta) => {
+    const sinDelta = Math.sin(delta);
+    // Degenerate edge (co-located points) — return start unchanged.
+    if (sinDelta === 0)
+        return start;
+    const A = Math.sin((1 - f) * delta) / sinDelta;
+    const B = Math.sin(f * delta) / sinDelta;
+    const φ1 = toRad(start[1]);
+    const λ1 = toRad(start[0]);
+    const φ2 = toRad(end[1]);
+    const λ2 = toRad(end[0]);
+    const x = A * Math.cos(φ1) * Math.cos(λ1) + B * Math.cos(φ2) * Math.cos(λ2);
+    const y = A * Math.cos(φ1) * Math.sin(λ1) + B * Math.cos(φ2) * Math.sin(λ2);
+    const z = A * Math.sin(φ1) + B * Math.sin(φ2);
+    const lat = toDeg(Math.atan2(z, Math.sqrt(x * x + y * y)));
+    const lng = unwrapLongitudeNear(toDeg(Math.atan2(y, x)), start[0]);
+    if (start.length === 3 && end.length === 3) {
+        const alt = start[2] * (1 - f) + end[2] * f;
+        return [lng, lat, alt];
+    }
+    return [lng, lat];
+};
+
 // ============================================================================
 // Constants
 // ============================================================================
@@ -471,6 +548,130 @@ const mergeMultiLineStringGeometry = (geometry) => {
     };
 };
 // ============================================================================
+// Unsplit crossing geometry
+// ============================================================================
+/** Tolerance for deciding an unwrapped ring still closes on its start longitude. */
+const RING_CLOSURE_LONGITUDE_TOLERANCE = 1e-9;
+/**
+ * Rewrite a coordinate sequence so each consecutive longitude pair differs by at most
+ * 180°, continuing past ±180° instead of snapping back.
+ *
+ * RFC 7946 Section 3.1.9 defines a segment as the *shorter* of the two paths between its
+ * endpoints, so an adjacent jump wider than 180° always means the edge crosses the seam.
+ * Geometry that reaches us unsplit (a single Polygon with vertices on both sides of the
+ * dateline) carries exactly that jump, and Mapbox would otherwise paint the edge straight
+ * across the whole Mercator world.
+ *
+ * `firstLongitudeReference` anchors the *first* position too, for sequences that have to land in
+ * the same branch as something else (see {@link unwrapPolygonRings}). Without it the first
+ * position is taken as given and only the rest follow from it.
+ *
+ * Returns null when every longitude was already continuous, so callers can skip the copy.
+ */
+const unwrapPositionSequence = (positions, firstLongitudeReference) => {
+    const first = positions[0];
+    if (first === undefined)
+        return null;
+    let modified = false;
+    let anchor = first;
+    if (firstLongitudeReference !== undefined) {
+        const longitude = unwrapLongitudeNear(first[0], firstLongitudeReference);
+        if (longitude !== first[0]) {
+            anchor = shiftPosition(first, longitude - first[0]);
+            modified = true;
+        }
+    }
+    const result = [anchor];
+    let previousLongitude = anchor[0];
+    for (let i = 1; i < positions.length; i++) {
+        const position = positions[i];
+        if (position === undefined)
+            return null;
+        const longitude = unwrapLongitudeNear(position[0], previousLongitude);
+        if (longitude === position[0]) {
+            result.push(position);
+        }
+        else {
+            result.push(shiftPosition(position, longitude - position[0]));
+            modified = true;
+        }
+        previousLongitude = longitude;
+    }
+    return modified ? result : null;
+};
+/**
+ * Unwrap a closed ring, or null when it was already continuous or cannot be unwrapped.
+ *
+ * A ring whose unwrapped end no longer meets its start winds all the way around the globe
+ * and has no continuous representation, so it is left for the renderer to handle as-is.
+ *
+ * Note that null covers both "already continuous" and "cannot be unwrapped"; callers treat them
+ * the same, keeping the original ring either way.
+ */
+const unwrapLinearRing = (ring, firstLongitudeReference) => {
+    const unwrapped = unwrapPositionSequence(ring, firstLongitudeReference);
+    if (unwrapped === null)
+        return null;
+    const first = unwrapped[0];
+    const last = unwrapped[unwrapped.length - 1];
+    if (first === undefined || last === undefined)
+        return null;
+    if (Math.abs(last[0] - first[0]) > RING_CLOSURE_LONGITUDE_TOLERANCE)
+        return null;
+    return unwrapped;
+};
+/**
+ * Unwrap every ring of one polygon, or null when none of them moved.
+ *
+ * Interior rings are anchored on the exterior's branch instead of on their own first vertex. A
+ * hole lying wholly on the far side of the seam carries no >180° jump itself, so left to its own
+ * devices it stays put while the exterior moves — ending up 360° away and no longer inside the
+ * ring it is meant to cut, which neither renderer accepts.
+ */
+const unwrapPolygonRings = (rings) => {
+    const exterior = rings[0];
+    if (exterior === undefined)
+        return null;
+    const unwrappedExterior = unwrapLinearRing(exterior);
+    const resolvedExterior = unwrappedExterior ?? exterior;
+    const exteriorAnchor = resolvedExterior[0];
+    if (exteriorAnchor === undefined)
+        return null;
+    const result = [resolvedExterior];
+    let modified = unwrappedExterior !== null;
+    for (let i = 1; i < rings.length; i++) {
+        const interior = rings[i];
+        if (interior === undefined)
+            continue;
+        const unwrapped = unwrapLinearRing(interior, exteriorAnchor[0]);
+        if (unwrapped === null) {
+            result.push(interior);
+            continue;
+        }
+        result.push(unwrapped);
+        modified = true;
+    }
+    return modified ? result : null;
+};
+const unwrapLineStringGeometry = (geometry) => {
+    const coordinates = unwrapPositionSequence(geometry.coordinates);
+    return coordinates === null ? geometry : { ...geometry, coordinates };
+};
+const unwrapMultiLineStringGeometry = (geometry) => {
+    const coordinates = [];
+    let modified = false;
+    for (const line of geometry.coordinates) {
+        const unwrapped = unwrapPositionSequence(line);
+        if (unwrapped === null) {
+            coordinates.push(line);
+            continue;
+        }
+        coordinates.push(unwrapped);
+        modified = true;
+    }
+    return modified ? { ...geometry, coordinates } : geometry;
+};
+// ============================================================================
 // Feature-level transformation
 // ============================================================================
 const mergeFeature = (feature) => {
@@ -478,8 +679,23 @@ const mergeFeature = (feature) => {
         return feature;
     }
     switch (feature.geometry.type) {
+        case "Polygon": {
+            const coordinates = unwrapPolygonRings(feature.geometry.coordinates);
+            if (coordinates === null)
+                return feature;
+            return { ...feature, geometry: { ...feature.geometry, coordinates } };
+        }
+        case "LineString": {
+            const unwrappedGeometry = unwrapLineStringGeometry(feature.geometry);
+            if (unwrappedGeometry === feature.geometry)
+                return feature;
+            return { ...feature, geometry: unwrappedGeometry };
+        }
         case "MultiPolygon": {
-            const mergedCoordinates = mergeMultiPolygonGeometry(feature.geometry);
+            const merged = mergeMultiPolygonGeometry(feature.geometry);
+            // Stitched sub-polygons are already continuous, so unwrapping them is a no-op;
+            // this catches the parts that arrived unsplit and crossing on their own.
+            const mergedCoordinates = merged.map(rings => unwrapPolygonRings(rings) ?? rings);
             const firstMerged = mergedCoordinates[0];
             if (mergedCoordinates.length === 1 && firstMerged !== undefined) {
                 return {
@@ -511,12 +727,15 @@ const mergeFeature = (feature) => {
         }
         case "MultiLineString": {
             const mergedGeometry = mergeMultiLineStringGeometry(feature.geometry);
-            if (mergedGeometry === feature.geometry) {
+            const unwrappedGeometry = mergedGeometry.type === "LineString"
+                ? unwrapLineStringGeometry(mergedGeometry)
+                : unwrapMultiLineStringGeometry(mergedGeometry);
+            if (unwrappedGeometry === feature.geometry) {
                 return feature;
             }
             return {
                 ...feature,
-                geometry: mergedGeometry,
+                geometry: unwrappedGeometry,
             };
         }
         default:
@@ -529,16 +748,23 @@ const mergeFeature = (feature) => {
 /**
  * Pre-process a GeoJSON FeatureCollection for antimeridian-aware rendering.
  *
- * - MultiPolygon features that represent a single polygon split at the antimeridian
- * (per RFC 7946 Section 3.1.9) are merged back into single Polygons with
- * unwrapped coordinates (lng values may exceed 180). Interior rings that are also
- * split at ±180° with matching seam latitudes are stitched the same way as exteriors.
+ * Two independent problems are fixed here, both producing continuous (unwrapped)
+ * longitudes:
+ *
+ * - **Split geometry is rejoined.** MultiPolygon features that represent a single polygon
+ * split at the antimeridian (per RFC 7946 Section 3.1.9) are merged back into single
+ * Polygons. Interior rings that are also split at ±180° with matching seam latitudes are
+ * stitched the same way as exteriors. MultiLineString features that represent one route
+ * split at ±180° are merged into a single LineString. This eliminates visible strokes at
+ * the antimeridian and ensures hover/selection treats each shape as one entity.
  *
- * - MultiLineString features that represent one route split at ±180° are merged
- * into a single LineString with the same unwrapping. This eliminates visible strokes
- * at the antimeridian and ensures hover/selection treats each shape as one entity.
+ * - **Unsplit crossing geometry is unwrapped.** A Polygon or LineString whose coordinates
+ * simply straddle the dateline — which is what the site geofence API returns, rather than
+ * the RFC's split form — has its longitudes continued past ±180° instead of snapping back.
+ * Without this, Mapbox paints the seam edge as a straight Mercator line spanning the whole
+ * world; Google Maps is unaffected because `geodesic: true` already takes the shorter path.
  *
- * The input collection is never mutated. Features that don't need merging
+ * The input collection is never mutated. Features that don't need changing
  * are returned by reference.
  *
  * **Important:** The output contains coordinates outside [-180, 180] and is
@@ -629,59 +855,6 @@ const mercatorCenterFromBounds = (bounds) => {
     return [centerLon, centerLat];
 };
 
-// ============================================================================
-// Unit conversion
-// ============================================================================
-const toRad = (deg) => (deg * Math.PI) / 180;
-const toDeg = (rad) => (rad * 180) / Math.PI;
-// ============================================================================
-// Great-circle math  (sphere model — WGS-84 mean radius)
-// ============================================================================
-/**
- * Haversine angular distance in radians between two lng/lat points.
- * Returns a value in [0, π].
- */
-const angularDistance = (lng1, lat1, lng2, lat2) => {
-    const φ1 = toRad(lat1);
-    const φ2 = toRad(lat2);
-    const Δφ = toRad(lat2 - lat1);
-    const Δλ = toRad(lng2 - lng1);
-    const a = Math.sin(Δφ / 2) ** 2 + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) ** 2;
-    const clampedA = Math.max(0, Math.min(1, a));
-    return 2 * Math.atan2(Math.sqrt(clampedA), Math.sqrt(1 - clampedA));
-};
-/**
- * Spherical-interpolation intermediate point at fraction `f` (0 = start, 1 = end)
- * along the great-circle arc defined by `delta` (pre-computed angular distance).
- *
- * Formula: http://www.movable-type.co.uk/scripts/latlong.html#intermediate-point
- *
- * If `start` carries an altitude the result linearly interpolates it; otherwise
- * the result is 2-D.
- */
-const intermediatePoint = (start, end, f, delta) => {
-    const sinDelta = Math.sin(delta);
-    // Degenerate edge (co-located points) — return start unchanged.
-    if (sinDelta === 0)
-        return start;
-    const A = Math.sin((1 - f) * delta) / sinDelta;
-    const B = Math.sin(f * delta) / sinDelta;
-    const φ1 = toRad(start[1]);
-    const λ1 = toRad(start[0]);
-    const φ2 = toRad(end[1]);
-    const λ2 = toRad(end[0]);
-    const x = A * Math.cos(φ1) * Math.cos(λ1) + B * Math.cos(φ2) * Math.cos(λ2);
-    const y = A * Math.cos(φ1) * Math.sin(λ1) + B * Math.cos(φ2) * Math.sin(λ2);
-    const z = A * Math.sin(φ1) + B * Math.sin(φ2);
-    const lat = toDeg(Math.atan2(z, Math.sqrt(x * x + y * y)));
-    const lng = toDeg(Math.atan2(y, x));
-    if (start.length === 3 && end.length === 3) {
-        const alt = start[2] * (1 - f) + end[2] * f;
-        return [lng, lat, alt];
-    }
-    return [lng, lat];
-};
-
 // ============================================================================
 // Constants
 // ============================================================================
@@ -808,9 +981,11 @@ const densifyFeature = (feature, maxSegmentKm) => {
  * The function returns the original collection reference when no feature is
  * modified, avoiding unnecessary downstream work.
  *
- * Run this **before** `mergeAntimeridianFeatures` — antimeridian-merged
- * polygons may carry longitudes outside `[-180, 180]`, which would corrupt
- * the `atan2` result inside {@link intermediatePoint}.
+ * Order relative to `mergeAntimeridianFeatures` is no longer a correctness
+ * constraint: {@link intermediatePoint} returns longitudes continuous with the
+ * segment start, so densifying already-unwrapped geometry (longitudes outside
+ * `[-180, 180]`) is safe, and densifying a still-wrapped dateline crossing
+ * leaves a seam that the merge step unwraps afterwards.
  *
  * @param features - Source GeoJSON feature collection (RFC 7946, unmodified).
  * @param layerGeodesic - Layer-level geodesic flag (default `true`).
@@ -2526,5 +2701,6 @@ exports.resolveSymbolDescriptor = resolveSymbolDescriptor;
 exports.safePolygon = safePolygon;
 exports.toDeg = toDeg;
 exports.toRad = toRad;
+exports.unwrapLongitudeNear = unwrapLongitudeNear;
 exports.validateInitialViewport = validateInitialViewport;
 exports.watchSafeAreaLeave = watchSafeAreaLeave;

package/index.esm.js

@@ -35,6 +35,83 @@ const defineAdapter = (factory) => {
     return wrappedFactory;
 };
 
+// ============================================================================
+// Unit conversion
+// ============================================================================
+const toRad = (deg) => (deg * Math.PI) / 180;
+const toDeg = (rad) => (rad * 180) / Math.PI;
+// ============================================================================
+// Longitude branch selection
+// ============================================================================
+/**
+ * Re-express `longitude` in the 360°-periodic branch nearest `reference`, so the two
+ * never differ by more than 180°.
+ *
+ * The result may fall outside `[-180, 180]` — it describes a position continuously
+ * rather than canonically, which is what Mapbox and Google Maps need to draw an edge
+ * across the antimeridian instead of back around the world. Do not persist it or feed
+ * it to a GeoJSON validator.
+ */
+const unwrapLongitudeNear = (longitude, reference) => {
+    const candidate = longitude + 360 * Math.round((reference - longitude) / 360);
+    // Exactly 180° apart both branches sit the same distance from the reference and there is
+    // no shorter path to pick, so leave the longitude where it is instead of flipping it.
+    return Math.abs(candidate - reference) === Math.abs(longitude - reference) ? longitude : candidate;
+};
+// ============================================================================
+// Great-circle math  (sphere model — WGS-84 mean radius)
+// ============================================================================
+/**
+ * Haversine angular distance in radians between two lng/lat points.
+ * Returns a value in [0, π].
+ */
+const angularDistance = (lng1, lat1, lng2, lat2) => {
+    const φ1 = toRad(lat1);
+    const φ2 = toRad(lat2);
+    const Δφ = toRad(lat2 - lat1);
+    const Δλ = toRad(lng2 - lng1);
+    const a = Math.sin(Δφ / 2) ** 2 + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) ** 2;
+    const clampedA = Math.max(0, Math.min(1, a));
+    return 2 * Math.atan2(Math.sqrt(clampedA), Math.sqrt(1 - clampedA));
+};
+/**
+ * Spherical-interpolation intermediate point at fraction `f` (0 = start, 1 = end)
+ * along the great-circle arc defined by `delta` (pre-computed angular distance).
+ *
+ * Formula: http://www.movable-type.co.uk/scripts/latlong.html#intermediate-point
+ *
+ * If `start` carries an altitude the result linearly interpolates it; otherwise
+ * the result is 2-D.
+ *
+ * The returned longitude is continuous with `start[0]` rather than canonical, so
+ * interpolating across the antimeridian yields 175° → 180° → 185° instead of
+ * 175° → 180° → −175°. That keeps consecutive samples monotonic for callers that
+ * difference them (densification, tangent angles) and makes this safe to call on
+ * already-unwrapped input. See {@link unwrapLongitudeNear}.
+ */
+const intermediatePoint = (start, end, f, delta) => {
+    const sinDelta = Math.sin(delta);
+    // Degenerate edge (co-located points) — return start unchanged.
+    if (sinDelta === 0)
+        return start;
+    const A = Math.sin((1 - f) * delta) / sinDelta;
+    const B = Math.sin(f * delta) / sinDelta;
+    const φ1 = toRad(start[1]);
+    const λ1 = toRad(start[0]);
+    const φ2 = toRad(end[1]);
+    const λ2 = toRad(end[0]);
+    const x = A * Math.cos(φ1) * Math.cos(λ1) + B * Math.cos(φ2) * Math.cos(λ2);
+    const y = A * Math.cos(φ1) * Math.sin(λ1) + B * Math.cos(φ2) * Math.sin(λ2);
+    const z = A * Math.sin(φ1) + B * Math.sin(φ2);
+    const lat = toDeg(Math.atan2(z, Math.sqrt(x * x + y * y)));
+    const lng = unwrapLongitudeNear(toDeg(Math.atan2(y, x)), start[0]);
+    if (start.length === 3 && end.length === 3) {
+        const alt = start[2] * (1 - f) + end[2] * f;
+        return [lng, lat, alt];
+    }
+    return [lng, lat];
+};
+
 // ============================================================================
 // Constants
 // ============================================================================
@@ -469,6 +546,130 @@ const mergeMultiLineStringGeometry = (geometry) => {
     };
 };
 // ============================================================================
+// Unsplit crossing geometry
+// ============================================================================
+/** Tolerance for deciding an unwrapped ring still closes on its start longitude. */
+const RING_CLOSURE_LONGITUDE_TOLERANCE = 1e-9;
+/**
+ * Rewrite a coordinate sequence so each consecutive longitude pair differs by at most
+ * 180°, continuing past ±180° instead of snapping back.
+ *
+ * RFC 7946 Section 3.1.9 defines a segment as the *shorter* of the two paths between its
+ * endpoints, so an adjacent jump wider than 180° always means the edge crosses the seam.
+ * Geometry that reaches us unsplit (a single Polygon with vertices on both sides of the
+ * dateline) carries exactly that jump, and Mapbox would otherwise paint the edge straight
+ * across the whole Mercator world.
+ *
+ * `firstLongitudeReference` anchors the *first* position too, for sequences that have to land in
+ * the same branch as something else (see {@link unwrapPolygonRings}). Without it the first
+ * position is taken as given and only the rest follow from it.
+ *
+ * Returns null when every longitude was already continuous, so callers can skip the copy.
+ */
+const unwrapPositionSequence = (positions, firstLongitudeReference) => {
+    const first = positions[0];
+    if (first === undefined)
+        return null;
+    let modified = false;
+    let anchor = first;
+    if (firstLongitudeReference !== undefined) {
+        const longitude = unwrapLongitudeNear(first[0], firstLongitudeReference);
+        if (longitude !== first[0]) {
+            anchor = shiftPosition(first, longitude - first[0]);
+            modified = true;
+        }
+    }
+    const result = [anchor];
+    let previousLongitude = anchor[0];
+    for (let i = 1; i < positions.length; i++) {
+        const position = positions[i];
+        if (position === undefined)
+            return null;
+        const longitude = unwrapLongitudeNear(position[0], previousLongitude);
+        if (longitude === position[0]) {
+            result.push(position);
+        }
+        else {
+            result.push(shiftPosition(position, longitude - position[0]));
+            modified = true;
+        }
+        previousLongitude = longitude;
+    }
+    return modified ? result : null;
+};
+/**
+ * Unwrap a closed ring, or null when it was already continuous or cannot be unwrapped.
+ *
+ * A ring whose unwrapped end no longer meets its start winds all the way around the globe
+ * and has no continuous representation, so it is left for the renderer to handle as-is.
+ *
+ * Note that null covers both "already continuous" and "cannot be unwrapped"; callers treat them
+ * the same, keeping the original ring either way.
+ */
+const unwrapLinearRing = (ring, firstLongitudeReference) => {
+    const unwrapped = unwrapPositionSequence(ring, firstLongitudeReference);
+    if (unwrapped === null)
+        return null;
+    const first = unwrapped[0];
+    const last = unwrapped[unwrapped.length - 1];
+    if (first === undefined || last === undefined)
+        return null;
+    if (Math.abs(last[0] - first[0]) > RING_CLOSURE_LONGITUDE_TOLERANCE)
+        return null;
+    return unwrapped;
+};
+/**
+ * Unwrap every ring of one polygon, or null when none of them moved.
+ *
+ * Interior rings are anchored on the exterior's branch instead of on their own first vertex. A
+ * hole lying wholly on the far side of the seam carries no >180° jump itself, so left to its own
+ * devices it stays put while the exterior moves — ending up 360° away and no longer inside the
+ * ring it is meant to cut, which neither renderer accepts.
+ */
+const unwrapPolygonRings = (rings) => {
+    const exterior = rings[0];
+    if (exterior === undefined)
+        return null;
+    const unwrappedExterior = unwrapLinearRing(exterior);
+    const resolvedExterior = unwrappedExterior ?? exterior;
+    const exteriorAnchor = resolvedExterior[0];
+    if (exteriorAnchor === undefined)
+        return null;
+    const result = [resolvedExterior];
+    let modified = unwrappedExterior !== null;
+    for (let i = 1; i < rings.length; i++) {
+        const interior = rings[i];
+        if (interior === undefined)
+            continue;
+        const unwrapped = unwrapLinearRing(interior, exteriorAnchor[0]);
+        if (unwrapped === null) {
+            result.push(interior);
+            continue;
+        }
+        result.push(unwrapped);
+        modified = true;
+    }
+    return modified ? result : null;
+};
+const unwrapLineStringGeometry = (geometry) => {
+    const coordinates = unwrapPositionSequence(geometry.coordinates);
+    return coordinates === null ? geometry : { ...geometry, coordinates };
+};
+const unwrapMultiLineStringGeometry = (geometry) => {
+    const coordinates = [];
+    let modified = false;
+    for (const line of geometry.coordinates) {
+        const unwrapped = unwrapPositionSequence(line);
+        if (unwrapped === null) {
+            coordinates.push(line);
+            continue;
+        }
+        coordinates.push(unwrapped);
+        modified = true;
+    }
+    return modified ? { ...geometry, coordinates } : geometry;
+};
+// ============================================================================
 // Feature-level transformation
 // ============================================================================
 const mergeFeature = (feature) => {
@@ -476,8 +677,23 @@ const mergeFeature = (feature) => {
         return feature;
     }
     switch (feature.geometry.type) {
+        case "Polygon": {
+            const coordinates = unwrapPolygonRings(feature.geometry.coordinates);
+            if (coordinates === null)
+                return feature;
+            return { ...feature, geometry: { ...feature.geometry, coordinates } };
+        }
+        case "LineString": {
+            const unwrappedGeometry = unwrapLineStringGeometry(feature.geometry);
+            if (unwrappedGeometry === feature.geometry)
+                return feature;
+            return { ...feature, geometry: unwrappedGeometry };
+        }
         case "MultiPolygon": {
-            const mergedCoordinates = mergeMultiPolygonGeometry(feature.geometry);
+            const merged = mergeMultiPolygonGeometry(feature.geometry);
+            // Stitched sub-polygons are already continuous, so unwrapping them is a no-op;
+            // this catches the parts that arrived unsplit and crossing on their own.
+            const mergedCoordinates = merged.map(rings => unwrapPolygonRings(rings) ?? rings);
             const firstMerged = mergedCoordinates[0];
             if (mergedCoordinates.length === 1 && firstMerged !== undefined) {
                 return {
@@ -509,12 +725,15 @@ const mergeFeature = (feature) => {
         }
         case "MultiLineString": {
             const mergedGeometry = mergeMultiLineStringGeometry(feature.geometry);
-            if (mergedGeometry === feature.geometry) {
+            const unwrappedGeometry = mergedGeometry.type === "LineString"
+                ? unwrapLineStringGeometry(mergedGeometry)
+                : unwrapMultiLineStringGeometry(mergedGeometry);
+            if (unwrappedGeometry === feature.geometry) {
                 return feature;
             }
             return {
                 ...feature,
-                geometry: mergedGeometry,
+                geometry: unwrappedGeometry,
             };
         }
         default:
@@ -527,16 +746,23 @@ const mergeFeature = (feature) => {
 /**
  * Pre-process a GeoJSON FeatureCollection for antimeridian-aware rendering.
  *
- * - MultiPolygon features that represent a single polygon split at the antimeridian
- * (per RFC 7946 Section 3.1.9) are merged back into single Polygons with
- * unwrapped coordinates (lng values may exceed 180). Interior rings that are also
- * split at ±180° with matching seam latitudes are stitched the same way as exteriors.
+ * Two independent problems are fixed here, both producing continuous (unwrapped)
+ * longitudes:
+ *
+ * - **Split geometry is rejoined.** MultiPolygon features that represent a single polygon
+ * split at the antimeridian (per RFC 7946 Section 3.1.9) are merged back into single
+ * Polygons. Interior rings that are also split at ±180° with matching seam latitudes are
+ * stitched the same way as exteriors. MultiLineString features that represent one route
+ * split at ±180° are merged into a single LineString. This eliminates visible strokes at
+ * the antimeridian and ensures hover/selection treats each shape as one entity.
  *
- * - MultiLineString features that represent one route split at ±180° are merged
- * into a single LineString with the same unwrapping. This eliminates visible strokes
- * at the antimeridian and ensures hover/selection treats each shape as one entity.
+ * - **Unsplit crossing geometry is unwrapped.** A Polygon or LineString whose coordinates
+ * simply straddle the dateline — which is what the site geofence API returns, rather than
+ * the RFC's split form — has its longitudes continued past ±180° instead of snapping back.
+ * Without this, Mapbox paints the seam edge as a straight Mercator line spanning the whole
+ * world; Google Maps is unaffected because `geodesic: true` already takes the shorter path.
  *
- * The input collection is never mutated. Features that don't need merging
+ * The input collection is never mutated. Features that don't need changing
  * are returned by reference.
  *
  * **Important:** The output contains coordinates outside [-180, 180] and is
@@ -627,59 +853,6 @@ const mercatorCenterFromBounds = (bounds) => {
     return [centerLon, centerLat];
 };
 
-// ============================================================================
-// Unit conversion
-// ============================================================================
-const toRad = (deg) => (deg * Math.PI) / 180;
-const toDeg = (rad) => (rad * 180) / Math.PI;
-// ============================================================================
-// Great-circle math  (sphere model — WGS-84 mean radius)
-// ============================================================================
-/**
- * Haversine angular distance in radians between two lng/lat points.
- * Returns a value in [0, π].
- */
-const angularDistance = (lng1, lat1, lng2, lat2) => {
-    const φ1 = toRad(lat1);
-    const φ2 = toRad(lat2);
-    const Δφ = toRad(lat2 - lat1);
-    const Δλ = toRad(lng2 - lng1);
-    const a = Math.sin(Δφ / 2) ** 2 + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) ** 2;
-    const clampedA = Math.max(0, Math.min(1, a));
-    return 2 * Math.atan2(Math.sqrt(clampedA), Math.sqrt(1 - clampedA));
-};
-/**
- * Spherical-interpolation intermediate point at fraction `f` (0 = start, 1 = end)
- * along the great-circle arc defined by `delta` (pre-computed angular distance).
- *
- * Formula: http://www.movable-type.co.uk/scripts/latlong.html#intermediate-point
- *
- * If `start` carries an altitude the result linearly interpolates it; otherwise
- * the result is 2-D.
- */
-const intermediatePoint = (start, end, f, delta) => {
-    const sinDelta = Math.sin(delta);
-    // Degenerate edge (co-located points) — return start unchanged.
-    if (sinDelta === 0)
-        return start;
-    const A = Math.sin((1 - f) * delta) / sinDelta;
-    const B = Math.sin(f * delta) / sinDelta;
-    const φ1 = toRad(start[1]);
-    const λ1 = toRad(start[0]);
-    const φ2 = toRad(end[1]);
-    const λ2 = toRad(end[0]);
-    const x = A * Math.cos(φ1) * Math.cos(λ1) + B * Math.cos(φ2) * Math.cos(λ2);
-    const y = A * Math.cos(φ1) * Math.sin(λ1) + B * Math.cos(φ2) * Math.sin(λ2);
-    const z = A * Math.sin(φ1) + B * Math.sin(φ2);
-    const lat = toDeg(Math.atan2(z, Math.sqrt(x * x + y * y)));
-    const lng = toDeg(Math.atan2(y, x));
-    if (start.length === 3 && end.length === 3) {
-        const alt = start[2] * (1 - f) + end[2] * f;
-        return [lng, lat, alt];
-    }
-    return [lng, lat];
-};
-
 // ============================================================================
 // Constants
 // ============================================================================
@@ -806,9 +979,11 @@ const densifyFeature = (feature, maxSegmentKm) => {
  * The function returns the original collection reference when no feature is
  * modified, avoiding unnecessary downstream work.
  *
- * Run this **before** `mergeAntimeridianFeatures` — antimeridian-merged
- * polygons may carry longitudes outside `[-180, 180]`, which would corrupt
- * the `atan2` result inside {@link intermediatePoint}.
+ * Order relative to `mergeAntimeridianFeatures` is no longer a correctness
+ * constraint: {@link intermediatePoint} returns longitudes continuous with the
+ * segment start, so densifying already-unwrapped geometry (longitudes outside
+ * `[-180, 180]`) is safe, and densifying a still-wrapped dateline crossing
+ * leaves a seam that the merge step unwraps afterwards.
  *
  * @param features - Source GeoJSON feature collection (RFC 7946, unmodified).
  * @param layerGeodesic - Layer-level geodesic flag (default `true`).
@@ -2443,4 +2618,4 @@ const resolveStrokeColors = (style, shapeType, theme) => {
     };
 };
 
-export { ANCHOR_SELECTOR, CIRCLE_SYMBOL_DEFAULT_DIAMETER_PX, CIRCLE_SYMBOL_DEFAULT_OPACITY, DEFAULT_CENTER, DEFAULT_MAP_APPEARANCE, DEFAULT_ZOOM, GEODESIC_MAX_SEGMENT_KM, HIT_SURFACE_SELECTOR, INITIAL_CAMERA_STATE, INITIAL_INTERACTION_STATE, INITIAL_MAP_STATE, INITIAL_MAP_STATUS, KEYBOARD_PAN_AMOUNT, KEYBOARD_ZOOM_AMOUNT, LAYER_FADE_DURATION_MS, MAP_CURSORS, MAX_ZOOM, MIN_ZOOM, SAFE_AREA_DEFAULT_BUFFER_PX, WORLD_BBOX, allocSafeAreaDebugId, anchorFromBottomCenter, angularDistance, attachSafeAreaHoverListeners, bboxEquals, bufferRectCorners, buildAdaptiveDomEntries, buildAdaptiveDomRenderFn, buildAdaptiveSymbolStyleFn, cameraStateEquals, canPatchAdaptiveMarker, canPatchAdaptiveViewport, canPatchMarkerInPlace, clearSafeArea, collectFeatureIdSet, computeInitialState, computeMarkerDomPortalZIndex, convexHull, createClusterPinElement, createDefaultClusterElement, createSymbolDotElement, defineAdapter, densifyGeodesicFeatures, disableSafeAreaDebug, discriminateRenderResult, enableSafeAreaDebug, estimateZoomFromBounds, extractLineCoordinates, extractPointCoordinates, extractPolygonPaths, extractSourceData, fadeInElement, filterRectsByCursorDirection, geometryTypeToShapeType, getAdaptiveDomFeatureIds, getAnchorRect, getEffectiveRestrictBounds, getHitSurfaceRect, hasSameFeatureIds, intermediatePoint, isCanvasMarkerMode, isEventOfType, isSafeAreaDebugEnabled, mapAppearanceSchema, mapStateEquals, mapThemeSchema, mapTypeSchema, mercatorCenterFromBounds, mergeAntimeridianFeatures, patchPortalDescriptors, pointInPolygon, removeGoneIndexedMarkers, renderSafeArea, resolveCircleSymbolDefaults, resolveHoveredStyle, resolveSelectedStyle, resolveStrokeColors, resolveSymbolDescriptor, safePolygon, toDeg, toRad, validateInitialViewport, watchSafeAreaLeave };
+export { ANCHOR_SELECTOR, CIRCLE_SYMBOL_DEFAULT_DIAMETER_PX, CIRCLE_SYMBOL_DEFAULT_OPACITY, DEFAULT_CENTER, DEFAULT_MAP_APPEARANCE, DEFAULT_ZOOM, GEODESIC_MAX_SEGMENT_KM, HIT_SURFACE_SELECTOR, INITIAL_CAMERA_STATE, INITIAL_INTERACTION_STATE, INITIAL_MAP_STATE, INITIAL_MAP_STATUS, KEYBOARD_PAN_AMOUNT, KEYBOARD_ZOOM_AMOUNT, LAYER_FADE_DURATION_MS, MAP_CURSORS, MAX_ZOOM, MIN_ZOOM, SAFE_AREA_DEFAULT_BUFFER_PX, WORLD_BBOX, allocSafeAreaDebugId, anchorFromBottomCenter, angularDistance, attachSafeAreaHoverListeners, bboxEquals, bufferRectCorners, buildAdaptiveDomEntries, buildAdaptiveDomRenderFn, buildAdaptiveSymbolStyleFn, cameraStateEquals, canPatchAdaptiveMarker, canPatchAdaptiveViewport, canPatchMarkerInPlace, clearSafeArea, collectFeatureIdSet, computeInitialState, computeMarkerDomPortalZIndex, convexHull, createClusterPinElement, createDefaultClusterElement, createSymbolDotElement, defineAdapter, densifyGeodesicFeatures, disableSafeAreaDebug, discriminateRenderResult, enableSafeAreaDebug, estimateZoomFromBounds, extractLineCoordinates, extractPointCoordinates, extractPolygonPaths, extractSourceData, fadeInElement, filterRectsByCursorDirection, geometryTypeToShapeType, getAdaptiveDomFeatureIds, getAnchorRect, getEffectiveRestrictBounds, getHitSurfaceRect, hasSameFeatureIds, intermediatePoint, isCanvasMarkerMode, isEventOfType, isSafeAreaDebugEnabled, mapAppearanceSchema, mapStateEquals, mapThemeSchema, mapTypeSchema, mercatorCenterFromBounds, mergeAntimeridianFeatures, patchPortalDescriptors, pointInPolygon, removeGoneIndexedMarkers, renderSafeArea, resolveCircleSymbolDefaults, resolveHoveredStyle, resolveSelectedStyle, resolveStrokeColors, resolveSymbolDescriptor, safePolygon, toDeg, toRad, unwrapLongitudeNear, validateInitialViewport, watchSafeAreaLeave };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@trackunit/react-map-adapter-shared",
-  "version": "0.0.119",
+  "version": "0.0.121",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {
     "node": ">=24.x"
   },
   "dependencies": {
-    "@trackunit/react-map-color-utils": "0.0.99",
-    "@trackunit/geo-json-utils": "1.15.38",
-    "@trackunit/ui-design-tokens": "1.15.25",
+    "@trackunit/react-map-color-utils": "0.0.100",
+    "@trackunit/geo-json-utils": "1.15.39",
+    "@trackunit/ui-design-tokens": "1.15.26",
     "es-toolkit": "^1.39.10",
     "zod": "^3.25.76"
   },

package/src/antimeridianMerge.d.ts

@@ -2,16 +2,23 @@ import type { GeoJsonFeatureCollection } from "@trackunit/geo-json-utils";
 /**
  * Pre-process a GeoJSON FeatureCollection for antimeridian-aware rendering.
  *
- * - MultiPolygon features that represent a single polygon split at the antimeridian
- * (per RFC 7946 Section 3.1.9) are merged back into single Polygons with
- * unwrapped coordinates (lng values may exceed 180). Interior rings that are also
- * split at ±180° with matching seam latitudes are stitched the same way as exteriors.
+ * Two independent problems are fixed here, both producing continuous (unwrapped)
+ * longitudes:
  *
- * - MultiLineString features that represent one route split at ±180° are merged
- * into a single LineString with the same unwrapping. This eliminates visible strokes
- * at the antimeridian and ensures hover/selection treats each shape as one entity.
+ * - **Split geometry is rejoined.** MultiPolygon features that represent a single polygon
+ * split at the antimeridian (per RFC 7946 Section 3.1.9) are merged back into single
+ * Polygons. Interior rings that are also split at ±180° with matching seam latitudes are
+ * stitched the same way as exteriors. MultiLineString features that represent one route
+ * split at ±180° are merged into a single LineString. This eliminates visible strokes at
+ * the antimeridian and ensures hover/selection treats each shape as one entity.
  *
- * The input collection is never mutated. Features that don't need merging
+ * - **Unsplit crossing geometry is unwrapped.** A Polygon or LineString whose coordinates
+ * simply straddle the dateline — which is what the site geofence API returns, rather than
+ * the RFC's split form — has its longitudes continued past ±180° instead of snapping back.
+ * Without this, Mapbox paints the seam edge as a straight Mercator line spanning the whole
+ * world; Google Maps is unaffected because `geodesic: true` already takes the shorter path.
+ *
+ * The input collection is never mutated. Features that don't need changing
  * are returned by reference.
  *
  * **Important:** The output contains coordinates outside [-180, 180] and is

package/src/geodesicDensify.d.ts

@@ -27,9 +27,11 @@ export declare const GEODESIC_MAX_SEGMENT_KM = 100;
  * The function returns the original collection reference when no feature is
  * modified, avoiding unnecessary downstream work.
  *
- * Run this **before** `mergeAntimeridianFeatures` — antimeridian-merged
- * polygons may carry longitudes outside `[-180, 180]`, which would corrupt
- * the `atan2` result inside {@link intermediatePoint}.
+ * Order relative to `mergeAntimeridianFeatures` is no longer a correctness
+ * constraint: {@link intermediatePoint} returns longitudes continuous with the
+ * segment start, so densifying already-unwrapped geometry (longitudes outside
+ * `[-180, 180]`) is safe, and densifying a still-wrapped dateline crossing
+ * leaves a seam that the merge step unwraps afterwards.
  *
  * @param features - Source GeoJSON feature collection (RFC 7946, unmodified).
  * @param layerGeodesic - Layer-level geodesic flag (default `true`).

package/src/sphericalMath.d.ts

@@ -1,6 +1,16 @@
 import type { GeoJsonPosition } from "@trackunit/geo-json-utils";
 export declare const toRad: (deg: number) => number;
 export declare const toDeg: (rad: number) => number;
+/**
+ * Re-express `longitude` in the 360°-periodic branch nearest `reference`, so the two
+ * never differ by more than 180°.
+ *
+ * The result may fall outside `[-180, 180]` — it describes a position continuously
+ * rather than canonically, which is what Mapbox and Google Maps need to draw an edge
+ * across the antimeridian instead of back around the world. Do not persist it or feed
+ * it to a GeoJSON validator.
+ */
+export declare const unwrapLongitudeNear: (longitude: number, reference: number) => number;
 /**
  * Haversine angular distance in radians between two lng/lat points.
  * Returns a value in [0, π].
@@ -14,5 +24,11 @@ export declare const angularDistance: (lng1: number, lat1: number, lng2: number,
  *
  * If `start` carries an altitude the result linearly interpolates it; otherwise
  * the result is 2-D.
+ *
+ * The returned longitude is continuous with `start[0]` rather than canonical, so
+ * interpolating across the antimeridian yields 175° → 180° → 185° instead of
+ * 175° → 180° → −175°. That keeps consecutive samples monotonic for callers that
+ * difference them (densification, tangent angles) and makes this safe to call on
+ * already-unwrapped input. See {@link unwrapLongitudeNear}.
  */
 export declare const intermediatePoint: (start: GeoJsonPosition, end: GeoJsonPosition, f: number, delta: number) => GeoJsonPosition;