@trackunit/geo-json-utils 1.15.41 → 1.15.45

package/index.cjs.js

@@ -1079,6 +1079,76 @@ const distributeInteriorRingsForAntimeridianSplit = (holeRings, eastHoles, westH
     }
     return true;
 };
+const isSeamJumpDelta = (delta) => {
+    const absDelta = Math.abs(delta);
+    return absDelta > 180 && absDelta < 360;
+};
+const ringCrossesAntimeridian = (ring) => ring.some((position, index) => {
+    const next = ring[index + 1];
+    return next !== undefined && isSeamJumpDelta(next[0] - position[0]);
+});
+const shiftPositionLongitude = (position, offset) => {
+    const longitude = position[0] + offset;
+    if (position.length === 3) {
+        return [longitude, position[1], position[2]];
+    }
+    return [longitude, position[1]];
+};
+/**
+ * Rewrite a ring's longitudes to be continuous across the antimeridian.
+ *
+ * Backend polygons store every longitude in `[-180, 180]`, so a shape spanning
+ * the dateline appears as a single ring with a ±360° jump between two adjacent
+ * vertices (e.g. `170 → -170`). Walking the ring and accumulating a ±360° offset
+ * whenever a jump is detected unwraps those vertices into continuous coordinates
+ * (`170 → 190`), which is the form the unwrapped split path expects.
+ *
+ * `initialOffset` anchors the ring's first vertex to a specific longitude world.
+ * Interior rings pass the offset computed from the exterior so both rings end up
+ * in the same world.
+ */
+const unwrapRingLongitudes = (ring, initialOffset = 0) => {
+    let offset = initialOffset;
+    let prevLng;
+    return ring.map(position => {
+        const lng = position[0];
+        if (prevLng !== undefined) {
+            const delta = lng - prevLng;
+            if (delta > 180 && delta < 360) {
+                offset -= 360;
+            }
+            else if (delta < -180 && delta > -360) {
+                offset += 360;
+            }
+        }
+        prevLng = lng;
+        return shiftPositionLongitude(position, offset);
+    });
+};
+const HOLE_UNWRAP_OFFSETS = [0, 360, -360];
+const unwrapSeamJumpingPolygon = (polygon) => {
+    const rings = polygon.coordinates;
+    const exterior = rings[0];
+    if (exterior === undefined) {
+        return polygon;
+    }
+    const unwrappedExterior = unwrapRingLongitudes(exterior);
+    const refLng = unwrappedExterior[0]?.[0] ?? 0;
+    const unwrappedHoles = rings.slice(1).map(hole => {
+        const firstLng = hole[0]?.[0];
+        if (firstLng === undefined) {
+            return unwrapRingLongitudes(hole, 0);
+        }
+        const useOffset = HOLE_UNWRAP_OFFSETS.reduce((best, offset) => {
+            return Math.abs(firstLng + offset - refLng) < Math.abs(firstLng + best - refLng) ? offset : best;
+        }, 0);
+        return unwrapRingLongitudes(hole, useOffset);
+    });
+    return {
+        type: "Polygon",
+        coordinates: [unwrappedExterior, ...unwrappedHoles],
+    };
+};
 /**
  * @description Splits a polygon (exterior + holes) at the antimeridian (±180°)
  * into a two-member MultiPolygon per RFC 7946 Section 3.1.9, preserving
@@ -1086,6 +1156,9 @@ const distributeInteriorRingsForAntimeridianSplit = (holeRings, eastHoles, westH
  * If the exterior does not cross the antimeridian, the input is returned unchanged
  * (including any hole coordinates).
  *
+ * Exterior rings that stay in `[-180, 180]` but contain a longitude jump wider
+ * than 180° (the form site geofence APIs return) are unwrapped first, then split.
+ *
  * Interior rings that lie entirely in [-180, 180] are assigned to exactly one
  * shell using longitude midpoint (see `oneSidedHoleGoesToFirstMultiPolygonMember`).
  * If splitting the exterior or any crossing hole would produce a fragment with
@@ -1100,7 +1173,12 @@ const splitPolygonWithHolesAtAntimeridian = (polygon) => {
     const holeRings = polygon.coordinates.slice(1);
     const { maxLng, minLng } = ringLongitudeBounds(outerRing);
     if (maxLng <= 180 && minLng >= -180) {
-        return polygon;
+        if (!ringCrossesAntimeridian(outerRing)) {
+            return polygon;
+        }
+        const unwrapped = unwrapSeamJumpingPolygon(polygon);
+        const result = splitPolygonWithHolesAtAntimeridian(unwrapped);
+        return result === unwrapped ? polygon : result;
     }
     const eastHoles = [];
     const westHoles = [];
@@ -1162,17 +1240,89 @@ const splitPolygonWithHolesAtAntimeridian = (polygon) => {
  * MultiPolygon per RFC 7946 Section 3.1.9. If the polygon does not cross the
  * antimeridian, it is returned unchanged.
  *
- * Accepts unwrapped longitudes (outside [-180, 180]) as input — for example,
- * coordinates from a map SDK where the user panned past the antimeridian.
- * The output is always RFC 7946 compliant (all longitudes in [-180, 180]).
- *
- * For use in a future polygon draw mode: the user draws a polygon on the map
- * with coordinates that may wrap past ±180, and this function produces the
- * RFC 7946-compliant split representation.
+ * Accepts both unwrapped longitudes (outside [-180, 180], e.g. from a map SDK
+ * after panning past the dateline) and seam-jumping rings that stay in
+ * [-180, 180] (e.g. `170 → -170` from a site geofence API). The output is
+ * always RFC 7946 compliant (all longitudes in [-180, 180]).
  *
  * Delegates to {@link splitPolygonWithHolesAtAntimeridian} (holes are preserved).
  */
 const splitPolygonAtAntimeridian = (polygon) => splitPolygonWithHolesAtAntimeridian(polygon);
+const splitAntimeridianCrossingPolygonMembers = (members) => {
+    let modified = false;
+    const splitMembers = [];
+    for (const coordinates of members) {
+        const polygon = { type: "Polygon", coordinates };
+        const result = splitPolygonAtAntimeridian(polygon);
+        if (result !== polygon) {
+            modified = true;
+        }
+        if (result.type === "Polygon") {
+            splitMembers.push(result.coordinates);
+        }
+        else {
+            splitMembers.push(...result.coordinates);
+        }
+    }
+    return modified ? splitMembers : null;
+};
+/**
+ * Split Polygon / MultiPolygon geometry that crosses the antimeridian into RFC
+ * 7946 MultiPolygon halves. GeometryCollection children are split recursively.
+ * Other geometry types are returned unchanged.
+ *
+ * Seam-jumping rings in `[-180, 180]` and already-unwrapped rings are both
+ * handled. Already-split halves that do not themselves jump the seam are
+ * returned by reference.
+ */
+const splitAntimeridianCrossingGeometry = (geometry) => {
+    if (geometry.type === "Polygon") {
+        return splitPolygonAtAntimeridian(geometry);
+    }
+    if (geometry.type === "MultiPolygon") {
+        const splitMembers = splitAntimeridianCrossingPolygonMembers(geometry.coordinates);
+        if (splitMembers === null) {
+            return geometry;
+        }
+        return { type: "MultiPolygon", coordinates: splitMembers };
+    }
+    if (geometry.type === "GeometryCollection") {
+        let modified = false;
+        const geometries = [];
+        for (const child of geometry.geometries) {
+            const split = splitAntimeridianCrossingGeometry(child);
+            if (split !== child) {
+                modified = true;
+            }
+            geometries.push(split);
+        }
+        return modified ? { ...geometry, geometries } : geometry;
+    }
+    return geometry;
+};
+/**
+ * RFC-canonicalize every polygonal feature that crosses the antimeridian.
+ * Returns the input collection when nothing changed.
+ */
+const splitAntimeridianCrossingFeatures = (collection) => {
+    let modified = false;
+    const features = [];
+    for (const feature of collection.features) {
+        const sourceGeometry = feature.geometry;
+        if (sourceGeometry === null) {
+            features.push(feature);
+            continue;
+        }
+        const geometry = splitAntimeridianCrossingGeometry(sourceGeometry);
+        if (geometry === sourceGeometry) {
+            features.push(feature);
+            continue;
+        }
+        modified = true;
+        features.push({ ...feature, geometry });
+    }
+    return modified ? { ...collection, features } : collection;
+};
 /**
  * @description Gets the extreme point of a polygon in a given direction.
  * @param {object} params - The parameters object
@@ -1397,6 +1547,48 @@ const padGeoJsonBbox = (bbox, padding) => {
     const [west, east] = getBboxLongitudesFromUnwrappedRange({ west: paddedWest, east: paddedEast });
     return [west, clampedSouth, east, clampedNorth];
 };
+/**
+ * Expands any bbox axis narrower than `minSpanDegrees` to that span around the axis midpoint.
+ * A single point (or a set of co-located points) produces a zero-area bbox, which
+ * `geoJsonBboxSchema` rejects — north must be *strictly* greater than south (RFC 7946 §5.2) —
+ * so map `fitBounds` calls silently no-op on it. Latitudes are clamped to ±90 after padding,
+ * shifting the window back inside the valid range so the span is preserved even at the poles.
+ * Longitudes use the unwrapped span (so a narrow antimeridian-crossing strip is padded too)
+ * and are wrapped into `[-180, 180]` the same way as {@link padGeoJsonBbox}.
+ *
+ * Wide bboxes are returned as-is (same reference).
+ */
+const ensureMinimumGeoJsonBboxSpan = (bbox, minSpanDegrees) => {
+    const [, minLat, , maxLat] = bbox;
+    const { west: unwrappedWest, east: unwrappedEast, span: lngSpan } = getUnwrappedBboxLongitudeRange(bbox);
+    const lngSpanTooSmall = lngSpan < minSpanDegrees;
+    const latSpanTooSmall = maxLat - minLat < minSpanDegrees;
+    if (!lngSpanTooSmall && !latSpanTooSmall) {
+        return bbox;
+    }
+    const half = minSpanDegrees / 2;
+    let [south, north] = [minLat, maxLat];
+    if (latSpanTooSmall) {
+        const midLat = (minLat + maxLat) / 2;
+        south = midLat - half;
+        north = midLat + half;
+        if (north > MAX_LAT) {
+            south -= north - MAX_LAT;
+            north = MAX_LAT;
+        }
+        if (south < MIN_LAT) {
+            north += MIN_LAT - south;
+            south = MIN_LAT;
+            north = Math.min(north, MAX_LAT);
+        }
+    }
+    if (!lngSpanTooSmall) {
+        return [bbox[0], south, bbox[2], north];
+    }
+    const midLng = (unwrappedWest + unwrappedEast) / 2;
+    const [west, east] = getBboxLongitudesFromUnwrappedRange({ west: midLng - half, east: midLng + half });
+    return [west, south, east, north];
+};
 /**
  * Computes the difference of subject minus the union of all clips.
  * Returns null when the subject is fully covered (zero remaining area).
@@ -1917,6 +2109,7 @@ exports.coordinatesToStandardFormat = coordinatesToStandardFormat;
 exports.denormalizeLongitude = denormalizeLongitude;
 exports.distanceToGeoJsonPolygonBoundary = distanceToGeoJsonPolygonBoundary;
 exports.edgePixelLength = edgePixelLength;
+exports.ensureMinimumGeoJsonBboxSpan = ensureMinimumGeoJsonBboxSpan;
 exports.extractEdges = extractEdges;
 exports.extractFirstPointCoordinate = extractFirstPointCoordinate;
 exports.extractPositionsFromGeometry = extractPositionsFromGeometry;
@@ -1964,6 +2157,8 @@ exports.pixelsToLatDegrees = pixelsToLatDegrees;
 exports.projectLngLatToWebMercator = projectLngLatToWebMercator;
 exports.projectPolygonalToWebMercator = projectPolygonalToWebMercator;
 exports.scaleGeoJsonBbox = scaleGeoJsonBbox;
+exports.splitAntimeridianCrossingFeatures = splitAntimeridianCrossingFeatures;
+exports.splitAntimeridianCrossingGeometry = splitAntimeridianCrossingGeometry;
 exports.splitPolygonAtAntimeridian = splitPolygonAtAntimeridian;
 exports.splitPolygonWithHolesAtAntimeridian = splitPolygonWithHolesAtAntimeridian;
 exports.toFeatureCollection = toFeatureCollection;

package/index.esm.js

@@ -1077,6 +1077,76 @@ const distributeInteriorRingsForAntimeridianSplit = (holeRings, eastHoles, westH
     }
     return true;
 };
+const isSeamJumpDelta = (delta) => {
+    const absDelta = Math.abs(delta);
+    return absDelta > 180 && absDelta < 360;
+};
+const ringCrossesAntimeridian = (ring) => ring.some((position, index) => {
+    const next = ring[index + 1];
+    return next !== undefined && isSeamJumpDelta(next[0] - position[0]);
+});
+const shiftPositionLongitude = (position, offset) => {
+    const longitude = position[0] + offset;
+    if (position.length === 3) {
+        return [longitude, position[1], position[2]];
+    }
+    return [longitude, position[1]];
+};
+/**
+ * Rewrite a ring's longitudes to be continuous across the antimeridian.
+ *
+ * Backend polygons store every longitude in `[-180, 180]`, so a shape spanning
+ * the dateline appears as a single ring with a ±360° jump between two adjacent
+ * vertices (e.g. `170 → -170`). Walking the ring and accumulating a ±360° offset
+ * whenever a jump is detected unwraps those vertices into continuous coordinates
+ * (`170 → 190`), which is the form the unwrapped split path expects.
+ *
+ * `initialOffset` anchors the ring's first vertex to a specific longitude world.
+ * Interior rings pass the offset computed from the exterior so both rings end up
+ * in the same world.
+ */
+const unwrapRingLongitudes = (ring, initialOffset = 0) => {
+    let offset = initialOffset;
+    let prevLng;
+    return ring.map(position => {
+        const lng = position[0];
+        if (prevLng !== undefined) {
+            const delta = lng - prevLng;
+            if (delta > 180 && delta < 360) {
+                offset -= 360;
+            }
+            else if (delta < -180 && delta > -360) {
+                offset += 360;
+            }
+        }
+        prevLng = lng;
+        return shiftPositionLongitude(position, offset);
+    });
+};
+const HOLE_UNWRAP_OFFSETS = [0, 360, -360];
+const unwrapSeamJumpingPolygon = (polygon) => {
+    const rings = polygon.coordinates;
+    const exterior = rings[0];
+    if (exterior === undefined) {
+        return polygon;
+    }
+    const unwrappedExterior = unwrapRingLongitudes(exterior);
+    const refLng = unwrappedExterior[0]?.[0] ?? 0;
+    const unwrappedHoles = rings.slice(1).map(hole => {
+        const firstLng = hole[0]?.[0];
+        if (firstLng === undefined) {
+            return unwrapRingLongitudes(hole, 0);
+        }
+        const useOffset = HOLE_UNWRAP_OFFSETS.reduce((best, offset) => {
+            return Math.abs(firstLng + offset - refLng) < Math.abs(firstLng + best - refLng) ? offset : best;
+        }, 0);
+        return unwrapRingLongitudes(hole, useOffset);
+    });
+    return {
+        type: "Polygon",
+        coordinates: [unwrappedExterior, ...unwrappedHoles],
+    };
+};
 /**
  * @description Splits a polygon (exterior + holes) at the antimeridian (±180°)
  * into a two-member MultiPolygon per RFC 7946 Section 3.1.9, preserving
@@ -1084,6 +1154,9 @@ const distributeInteriorRingsForAntimeridianSplit = (holeRings, eastHoles, westH
  * If the exterior does not cross the antimeridian, the input is returned unchanged
  * (including any hole coordinates).
  *
+ * Exterior rings that stay in `[-180, 180]` but contain a longitude jump wider
+ * than 180° (the form site geofence APIs return) are unwrapped first, then split.
+ *
  * Interior rings that lie entirely in [-180, 180] are assigned to exactly one
  * shell using longitude midpoint (see `oneSidedHoleGoesToFirstMultiPolygonMember`).
  * If splitting the exterior or any crossing hole would produce a fragment with
@@ -1098,7 +1171,12 @@ const splitPolygonWithHolesAtAntimeridian = (polygon) => {
     const holeRings = polygon.coordinates.slice(1);
     const { maxLng, minLng } = ringLongitudeBounds(outerRing);
     if (maxLng <= 180 && minLng >= -180) {
-        return polygon;
+        if (!ringCrossesAntimeridian(outerRing)) {
+            return polygon;
+        }
+        const unwrapped = unwrapSeamJumpingPolygon(polygon);
+        const result = splitPolygonWithHolesAtAntimeridian(unwrapped);
+        return result === unwrapped ? polygon : result;
     }
     const eastHoles = [];
     const westHoles = [];
@@ -1160,17 +1238,89 @@ const splitPolygonWithHolesAtAntimeridian = (polygon) => {
  * MultiPolygon per RFC 7946 Section 3.1.9. If the polygon does not cross the
  * antimeridian, it is returned unchanged.
  *
- * Accepts unwrapped longitudes (outside [-180, 180]) as input — for example,
- * coordinates from a map SDK where the user panned past the antimeridian.
- * The output is always RFC 7946 compliant (all longitudes in [-180, 180]).
- *
- * For use in a future polygon draw mode: the user draws a polygon on the map
- * with coordinates that may wrap past ±180, and this function produces the
- * RFC 7946-compliant split representation.
+ * Accepts both unwrapped longitudes (outside [-180, 180], e.g. from a map SDK
+ * after panning past the dateline) and seam-jumping rings that stay in
+ * [-180, 180] (e.g. `170 → -170` from a site geofence API). The output is
+ * always RFC 7946 compliant (all longitudes in [-180, 180]).
  *
  * Delegates to {@link splitPolygonWithHolesAtAntimeridian} (holes are preserved).
  */
 const splitPolygonAtAntimeridian = (polygon) => splitPolygonWithHolesAtAntimeridian(polygon);
+const splitAntimeridianCrossingPolygonMembers = (members) => {
+    let modified = false;
+    const splitMembers = [];
+    for (const coordinates of members) {
+        const polygon = { type: "Polygon", coordinates };
+        const result = splitPolygonAtAntimeridian(polygon);
+        if (result !== polygon) {
+            modified = true;
+        }
+        if (result.type === "Polygon") {
+            splitMembers.push(result.coordinates);
+        }
+        else {
+            splitMembers.push(...result.coordinates);
+        }
+    }
+    return modified ? splitMembers : null;
+};
+/**
+ * Split Polygon / MultiPolygon geometry that crosses the antimeridian into RFC
+ * 7946 MultiPolygon halves. GeometryCollection children are split recursively.
+ * Other geometry types are returned unchanged.
+ *
+ * Seam-jumping rings in `[-180, 180]` and already-unwrapped rings are both
+ * handled. Already-split halves that do not themselves jump the seam are
+ * returned by reference.
+ */
+const splitAntimeridianCrossingGeometry = (geometry) => {
+    if (geometry.type === "Polygon") {
+        return splitPolygonAtAntimeridian(geometry);
+    }
+    if (geometry.type === "MultiPolygon") {
+        const splitMembers = splitAntimeridianCrossingPolygonMembers(geometry.coordinates);
+        if (splitMembers === null) {
+            return geometry;
+        }
+        return { type: "MultiPolygon", coordinates: splitMembers };
+    }
+    if (geometry.type === "GeometryCollection") {
+        let modified = false;
+        const geometries = [];
+        for (const child of geometry.geometries) {
+            const split = splitAntimeridianCrossingGeometry(child);
+            if (split !== child) {
+                modified = true;
+            }
+            geometries.push(split);
+        }
+        return modified ? { ...geometry, geometries } : geometry;
+    }
+    return geometry;
+};
+/**
+ * RFC-canonicalize every polygonal feature that crosses the antimeridian.
+ * Returns the input collection when nothing changed.
+ */
+const splitAntimeridianCrossingFeatures = (collection) => {
+    let modified = false;
+    const features = [];
+    for (const feature of collection.features) {
+        const sourceGeometry = feature.geometry;
+        if (sourceGeometry === null) {
+            features.push(feature);
+            continue;
+        }
+        const geometry = splitAntimeridianCrossingGeometry(sourceGeometry);
+        if (geometry === sourceGeometry) {
+            features.push(feature);
+            continue;
+        }
+        modified = true;
+        features.push({ ...feature, geometry });
+    }
+    return modified ? { ...collection, features } : collection;
+};
 /**
  * @description Gets the extreme point of a polygon in a given direction.
  * @param {object} params - The parameters object
@@ -1395,6 +1545,48 @@ const padGeoJsonBbox = (bbox, padding) => {
     const [west, east] = getBboxLongitudesFromUnwrappedRange({ west: paddedWest, east: paddedEast });
     return [west, clampedSouth, east, clampedNorth];
 };
+/**
+ * Expands any bbox axis narrower than `minSpanDegrees` to that span around the axis midpoint.
+ * A single point (or a set of co-located points) produces a zero-area bbox, which
+ * `geoJsonBboxSchema` rejects — north must be *strictly* greater than south (RFC 7946 §5.2) —
+ * so map `fitBounds` calls silently no-op on it. Latitudes are clamped to ±90 after padding,
+ * shifting the window back inside the valid range so the span is preserved even at the poles.
+ * Longitudes use the unwrapped span (so a narrow antimeridian-crossing strip is padded too)
+ * and are wrapped into `[-180, 180]` the same way as {@link padGeoJsonBbox}.
+ *
+ * Wide bboxes are returned as-is (same reference).
+ */
+const ensureMinimumGeoJsonBboxSpan = (bbox, minSpanDegrees) => {
+    const [, minLat, , maxLat] = bbox;
+    const { west: unwrappedWest, east: unwrappedEast, span: lngSpan } = getUnwrappedBboxLongitudeRange(bbox);
+    const lngSpanTooSmall = lngSpan < minSpanDegrees;
+    const latSpanTooSmall = maxLat - minLat < minSpanDegrees;
+    if (!lngSpanTooSmall && !latSpanTooSmall) {
+        return bbox;
+    }
+    const half = minSpanDegrees / 2;
+    let [south, north] = [minLat, maxLat];
+    if (latSpanTooSmall) {
+        const midLat = (minLat + maxLat) / 2;
+        south = midLat - half;
+        north = midLat + half;
+        if (north > MAX_LAT) {
+            south -= north - MAX_LAT;
+            north = MAX_LAT;
+        }
+        if (south < MIN_LAT) {
+            north += MIN_LAT - south;
+            south = MIN_LAT;
+            north = Math.min(north, MAX_LAT);
+        }
+    }
+    if (!lngSpanTooSmall) {
+        return [bbox[0], south, bbox[2], north];
+    }
+    const midLng = (unwrappedWest + unwrappedEast) / 2;
+    const [west, east] = getBboxLongitudesFromUnwrappedRange({ west: midLng - half, east: midLng + half });
+    return [west, south, east, north];
+};
 /**
  * Computes the difference of subject minus the union of all clips.
  * Returns null when the subject is fully covered (zero remaining area).
@@ -1906,4 +2098,4 @@ const edgePixelLength = (x0, y0, x1, y1, zoom, midLatDeg, tileSize = 256) => {
     return Math.sqrt(dxPx * dxPx + dyPx * dyPx);
 };
 
-export { EARTH_RADIUS, EMPTY_FEATURE_COLLECTION, boundingBoxCrossesMeridian, checkCrossesMeridian, computeGeometryCentroid, coordinatesToStandardFormat, denormalizeLongitude, distanceToGeoJsonPolygonBoundary, edgePixelLength, extractEdges, extractFirstPointCoordinate, extractPositionsFromGeometry, geoJsonBboxSchema, geoJsonFeatureCollectionSchema, geoJsonFeatureSchema, geoJsonGeometryCollectionSchema, geoJsonGeometrySchema, geoJsonLineStringSchema, geoJsonLinearRingSchema, geoJsonMultiLineStringSchema, geoJsonMultiPointSchema, geoJsonMultiPolygonSchema, geoJsonPointSchema, geoJsonPolygonDifference, geoJsonPolygonSchema, geoJsonPosition2dSchema, geoJsonPositionSchema, getBboxFromGeoJsonPolygon, getBoundingBoxFromGeoJsonBbox, getBoundingBoxFromGeoJsonPolygon, getExtremeGeoJsonPointFromPolygon, getGeoJsonPolygonFromBoundingBox, getGeoJsonPolygonIntersection, getMinMaxLongitudes, getMultipleCoordinatesFromGeoJsonObject, getPointCoordinateFromGeoJsonObject, getPointCoordinateFromGeoJsonPoint, getPolygonFromBbox, getPolygonFromPointAndRadius, isBboxInsideFeatureCollection, isFullyContainedInGeoJsonGeometry, isFullyContainedInGeoJsonPolygon, isFullyContainedInGeometry, isGeoJsonPointInPolygon, isGeoJsonPositionInLinearRing, isPointInPolygon, isPositionInsideRing, lngLatToMercatorPxWS, lngLatToWebMercatorPx, mercatorPxToLngLatWS, normalizeLongitudes, padGeoJsonBbox, pixelsToLatDegrees, projectLngLatToWebMercator, projectPolygonalToWebMercator, scaleGeoJsonBbox, splitPolygonAtAntimeridian, splitPolygonWithHolesAtAntimeridian, toFeatureCollection, toPosition2d, tuGeoJsonPointRadiusSchema, tuGeoJsonPolygonNoHolesSchema, tuGeoJsonRectangularBoxPolygonSchema, unprojectPolygonalFromWebMercator, unprojectWebMercatorToLngLat, validateBbox, validateBboxWithFallback, validateFeatureCollection, validatePosition, webMercatorPxToLngLat };
+export { EARTH_RADIUS, EMPTY_FEATURE_COLLECTION, boundingBoxCrossesMeridian, checkCrossesMeridian, computeGeometryCentroid, coordinatesToStandardFormat, denormalizeLongitude, distanceToGeoJsonPolygonBoundary, edgePixelLength, ensureMinimumGeoJsonBboxSpan, extractEdges, extractFirstPointCoordinate, extractPositionsFromGeometry, geoJsonBboxSchema, geoJsonFeatureCollectionSchema, geoJsonFeatureSchema, geoJsonGeometryCollectionSchema, geoJsonGeometrySchema, geoJsonLineStringSchema, geoJsonLinearRingSchema, geoJsonMultiLineStringSchema, geoJsonMultiPointSchema, geoJsonMultiPolygonSchema, geoJsonPointSchema, geoJsonPolygonDifference, geoJsonPolygonSchema, geoJsonPosition2dSchema, geoJsonPositionSchema, getBboxFromGeoJsonPolygon, getBoundingBoxFromGeoJsonBbox, getBoundingBoxFromGeoJsonPolygon, getExtremeGeoJsonPointFromPolygon, getGeoJsonPolygonFromBoundingBox, getGeoJsonPolygonIntersection, getMinMaxLongitudes, getMultipleCoordinatesFromGeoJsonObject, getPointCoordinateFromGeoJsonObject, getPointCoordinateFromGeoJsonPoint, getPolygonFromBbox, getPolygonFromPointAndRadius, isBboxInsideFeatureCollection, isFullyContainedInGeoJsonGeometry, isFullyContainedInGeoJsonPolygon, isFullyContainedInGeometry, isGeoJsonPointInPolygon, isGeoJsonPositionInLinearRing, isPointInPolygon, isPositionInsideRing, lngLatToMercatorPxWS, lngLatToWebMercatorPx, mercatorPxToLngLatWS, normalizeLongitudes, padGeoJsonBbox, pixelsToLatDegrees, projectLngLatToWebMercator, projectPolygonalToWebMercator, scaleGeoJsonBbox, splitAntimeridianCrossingFeatures, splitAntimeridianCrossingGeometry, splitPolygonAtAntimeridian, splitPolygonWithHolesAtAntimeridian, toFeatureCollection, toPosition2d, tuGeoJsonPointRadiusSchema, tuGeoJsonPolygonNoHolesSchema, tuGeoJsonRectangularBoxPolygonSchema, unprojectPolygonalFromWebMercator, unprojectWebMercatorToLngLat, validateBbox, validateBboxWithFallback, validateFeatureCollection, validatePosition, webMercatorPxToLngLat };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/geo-json-utils",
-  "version": "1.15.41",
+  "version": "1.15.45",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {

package/src/GeoJsonUtils.d.ts

@@ -1,4 +1,4 @@
-import { GeoJsonBbox, GeoJsonLinearRing, GeoJsonMultiPolygon, GeoJsonPoint, GeoJsonPolygon, GeoJsonPosition } from "./GeoJsonSchemas";
+import { GeoJsonBbox, GeoJsonFeatureCollection, GeoJsonGeometry, GeoJsonLinearRing, GeoJsonMultiPolygon, GeoJsonPoint, GeoJsonPolygon, GeoJsonPosition } from "./GeoJsonSchemas";
 export declare const EARTH_RADIUS = 6378137;
 /**
  * @description Creates a polygon from a bounding box.
@@ -39,6 +39,9 @@ export declare const getPolygonFromPointAndRadius: (point: GeoJsonPoint, radius:
  * If the exterior does not cross the antimeridian, the input is returned unchanged
  * (including any hole coordinates).
  *
+ * Exterior rings that stay in `[-180, 180]` but contain a longitude jump wider
+ * than 180° (the form site geofence APIs return) are unwrapped first, then split.
+ *
  * Interior rings that lie entirely in [-180, 180] are assigned to exactly one
  * shell using longitude midpoint (see `oneSidedHoleGoesToFirstMultiPolygonMember`).
  * If splitting the exterior or any crossing hole would produce a fragment with
@@ -51,17 +54,29 @@ export declare const splitPolygonWithHolesAtAntimeridian: (polygon: GeoJsonPolyg
  * MultiPolygon per RFC 7946 Section 3.1.9. If the polygon does not cross the
  * antimeridian, it is returned unchanged.
  *
- * Accepts unwrapped longitudes (outside [-180, 180]) as input — for example,
- * coordinates from a map SDK where the user panned past the antimeridian.
- * The output is always RFC 7946 compliant (all longitudes in [-180, 180]).
- *
- * For use in a future polygon draw mode: the user draws a polygon on the map
- * with coordinates that may wrap past ±180, and this function produces the
- * RFC 7946-compliant split representation.
+ * Accepts both unwrapped longitudes (outside [-180, 180], e.g. from a map SDK
+ * after panning past the dateline) and seam-jumping rings that stay in
+ * [-180, 180] (e.g. `170 → -170` from a site geofence API). The output is
+ * always RFC 7946 compliant (all longitudes in [-180, 180]).
  *
  * Delegates to {@link splitPolygonWithHolesAtAntimeridian} (holes are preserved).
  */
 export declare const splitPolygonAtAntimeridian: (polygon: GeoJsonPolygon) => GeoJsonPolygon | GeoJsonMultiPolygon;
+/**
+ * Split Polygon / MultiPolygon geometry that crosses the antimeridian into RFC
+ * 7946 MultiPolygon halves. GeometryCollection children are split recursively.
+ * Other geometry types are returned unchanged.
+ *
+ * Seam-jumping rings in `[-180, 180]` and already-unwrapped rings are both
+ * handled. Already-split halves that do not themselves jump the seam are
+ * returned by reference.
+ */
+export declare const splitAntimeridianCrossingGeometry: (geometry: GeoJsonGeometry) => GeoJsonGeometry;
+/**
+ * RFC-canonicalize every polygonal feature that crosses the antimeridian.
+ * Returns the input collection when nothing changed.
+ */
+export declare const splitAntimeridianCrossingFeatures: (collection: GeoJsonFeatureCollection) => GeoJsonFeatureCollection;
 /**
  * @description Gets the extreme point of a polygon in a given direction.
  * @param {object} params - The parameters object
@@ -146,6 +161,18 @@ export type BboxPadding = number | {
  * Latitudes are clamped to `[-90, 90]`, longitudes to `[-180, 180]`.
  */
 export declare const padGeoJsonBbox: (bbox: GeoJsonBbox, padding: BboxPadding) => GeoJsonBbox;
+/**
+ * Expands any bbox axis narrower than `minSpanDegrees` to that span around the axis midpoint.
+ * A single point (or a set of co-located points) produces a zero-area bbox, which
+ * `geoJsonBboxSchema` rejects — north must be *strictly* greater than south (RFC 7946 §5.2) —
+ * so map `fitBounds` calls silently no-op on it. Latitudes are clamped to ±90 after padding,
+ * shifting the window back inside the valid range so the span is preserved even at the poles.
+ * Longitudes use the unwrapped span (so a narrow antimeridian-crossing strip is padded too)
+ * and are wrapped into `[-180, 180]` the same way as {@link padGeoJsonBbox}.
+ *
+ * Wide bboxes are returned as-is (same reference).
+ */
+export declare const ensureMinimumGeoJsonBboxSpan: (bbox: GeoJsonBbox, minSpanDegrees: number) => GeoJsonBbox;
 /**
  * Computes the difference of subject minus the union of all clips.
  * Returns null when the subject is fully covered (zero remaining area).