@trackunit/geo-json-utils 1.11.91 → 1.12.2

package/index.cjs.js

@@ -593,6 +593,7 @@ const getBboxFromGeoJsonPolygon = (polygon) => {
     const { minLon, maxLon } = getMinMaxLongitudes(longitudes);
     return [minLon, Math.min(...latitudes), maxLon, Math.max(...latitudes)];
 };
+/** Folds any longitude to the [-180, 180] range. */
 const normalizeLongitude = (lon) => ((lon + 540) % 360) - 180;
 const WESTERN_HEMISPHERE = [
     [
@@ -612,18 +613,148 @@ const EASTERN_HEMISPHERE = [
         [0, -90],
     ],
 ];
+/** Unwrapped longitudes in (180°, 360°] — western half of a shape that crossed +180°. */
+const EAST_OF_ANTIMERIDIAN_CLIP = [
+    [
+        [180, -90],
+        [360, -90],
+        [360, 90],
+        [180, 90],
+        [180, -90],
+    ],
+];
+/** Unwrapped longitudes in [-360°, -180°) — eastern half of a shape that crossed -180°. */
+const WEST_OF_ANTIMERIDIAN_CLIP = [
+    [
+        [-360, -90],
+        [-180, -90],
+        [-180, 90],
+        [-360, 90],
+        [-360, -90],
+    ],
+];
+const shiftClipPolygonLongitudes = (polygon, offset) => polygon.map(ring => ring.map(([x, y]) => [x + offset, y]));
+const signedAreaOfClosedClipRing = (ring) => {
+    let sum = 0;
+    for (let i = 0; i < ring.length - 1; i++) {
+        const a = ring[i];
+        const b = ring[i + 1];
+        if (a === undefined || b === undefined) {
+            continue;
+        }
+        sum += a[0] * b[1] - b[0] * a[1];
+    }
+    return sum / 2;
+};
+/**
+ * Intersection with [180°, 360°] often traces the dateline as thousands of
+ * near-180° samples instead of a straight ±180° seam. That breaks
+ * antimeridian stitching (no consecutive ±180 vertices). Collapse the long
+ * near-dateline detour and keep the true western bulk arc.
+ */
+const repairWesternDatelineOverflowExteriorRing = (ring) => {
+    const openLen = ring.length - 1;
+    if (openLen < 4) {
+        return ring;
+    }
+    const antimeridianTol = 1e-5;
+    const amIndices = [];
+    for (let i = 0; i < openLen; i++) {
+        const lng = ring[i]?.[0];
+        if (lng !== undefined && Math.abs(lng + 180) < antimeridianTol) {
+            amIndices.push(i);
+        }
+    }
+    if (amIndices.length < 2) {
+        return ring;
+    }
+    const firstAm = amIndices[0];
+    const lastAm = amIndices[amIndices.length - 1];
+    if (firstAm === undefined || lastAm === undefined) {
+        return ring;
+    }
+    const vFirst = ring[firstAm];
+    const vLast = ring[lastAm];
+    if (vFirst === undefined || vLast === undefined) {
+        return ring;
+    }
+    const southIdx = vFirst[1] <= vLast[1] ? firstAm : lastAm;
+    const northIdx = vFirst[1] <= vLast[1] ? lastAm : firstAm;
+    const mainLonThreshold = -179.5;
+    const mainIndices = [];
+    for (let i = 0; i < openLen; i++) {
+        if (i === southIdx || i === northIdx) {
+            continue;
+        }
+        const lng = ring[i]?.[0];
+        if (lng !== undefined && lng > mainLonThreshold) {
+            mainIndices.push(i);
+        }
+    }
+    if (mainIndices.length === 0) {
+        return ring;
+    }
+    const vertexCountBetweenSouthAndNorth = northIdx > southIdx ? northIdx - southIdx - 1 : openLen - southIdx + northIdx - 1;
+    if (vertexCountBetweenSouthAndNorth < 100) {
+        return ring;
+    }
+    const south = ring[southIdx];
+    const north = ring[northIdx];
+    if (south === undefined || north === undefined) {
+        return ring;
+    }
+    const orderedMain = mainIndices.toSorted((a, b) => a - b);
+    const middle = [];
+    for (const idx of orderedMain) {
+        const pt = ring[idx];
+        if (pt !== undefined) {
+            middle.push(pt);
+        }
+    }
+    const originalSign = Math.sign(signedAreaOfClosedClipRing(ring));
+    // Seam on the western piece must run north→south at lng=-180 so latitudes are the reverse of
+    // the eastern piece at +180; mergeAntimeridianFeatures matches east vs reversed-west runs.
+    let candidate = [north, south, ...middle, north];
+    if (originalSign !== 0 && Math.sign(signedAreaOfClosedClipRing(candidate)) !== originalSign) {
+        const open = candidate.slice(0, -1).toReversed();
+        const first = open[0];
+        if (first !== undefined) {
+            candidate = [...open, first];
+        }
+    }
+    return candidate;
+};
+const mapWestOverflowPolygon = (poly) => {
+    const shifted = shiftClipPolygonLongitudes(poly, -360);
+    const [ext, ...holes] = shifted;
+    if (ext === undefined) {
+        return shifted;
+    }
+    return [repairWesternDatelineOverflowExteriorRing(ext), ...holes];
+};
 /**
  * @description Creates a round polygon from a point and a radius.
- * Handles antimeridian crossing per RFC 7946 Section 3.1.9 by splitting
+ *
+ * - Handles **antimeridian crossing** per RFC 7946 Section 3.1.9 by splitting
  * into a MultiPolygon. Clamps polar latitudes to [-90, 90].
  *
- * Returns null when the polygon crosses the antimeridian but both hemisphere
+ * - **Center longitude:** Map inputs may be outside [-180, 180] (e.g. 540°). The center is folded once by
+ * whole 360° turns into that range—same meridian on the ground; only the number used for math changes.
+ * - **Sampling the ring:** Each vertex is `lonCenter + offset` along the loop. Vertices use **continuous**
+ * longitude (no per-point normalization to [-180, 180]) so the planar ring does not self-intersect at the
+ * dateline; each hemisphere is clipped separately. We do not normalize every vertex to [-180, 180] by
+ * itself; that would turn a short step across the dateline into a long wrong chord. The western overflow
+ * piece is repaired so the ±180° seam is a short edge, which allows consumers such as
+ * `mergeAntimeridianFeatures` to merge halves for rendering.
+ *
+ * Returns **null** when the polygon crosses the antimeridian but both hemisphere
  * intersections yield zero polygons (e.g. very small polygons near the
  * dateline). In that case, returning the original coordinates would produce
- * invalid geometry per RFC 7946.
+ * invalid geometry per RFC 7946 Section 3.1.9.
  */
 const getPolygonFromPointAndRadius = (point, radius) => {
     const [lon, lat] = point.coordinates;
+    const lonCenter = normalizeLongitude(lon);
     const pointsCount = Math.max(32, Math.floor(radius / 100));
     const angleStep = (2 * Math.PI) / pointsCount;
     const deltaLat = (radius / EARTH_RADIUS) * (180 / Math.PI);
@@ -632,14 +763,30 @@ const getPolygonFromPointAndRadius = (point, radius) => {
     for (let i = 0; i <= pointsCount; i++) {
         const angle = i * angleStep;
         const newLat = Math.max(-90, Math.min(90, lat + deltaLat * Math.sin(angle)));
-        const newLon = normalizeLongitude(lon + deltaLon * Math.cos(angle));
+        const newLon = lonCenter + deltaLon * Math.cos(angle);
         coordinates.push([newLon, newLat]);
     }
-    const longitudes = coordinates.map(c => c[0]);
-    if (checkCrossesMeridian(longitudes)) {
-        const rawPolygon = [coordinates.map(c => [c[0], c[1]])];
-        const westPart = polygonClipping.intersection(rawPolygon, WESTERN_HEMISPHERE);
+    const rawLngs = coordinates.map(c => c[0]);
+    const minRawLon = Math.min(...rawLngs);
+    const maxRawLon = Math.max(...rawLngs);
+    const rawPolygon = [coordinates.map(c => [c[0], c[1]])];
+    if (maxRawLon > 180) {
         const eastPart = polygonClipping.intersection(rawPolygon, EASTERN_HEMISPHERE);
+        const westOverflow = polygonClipping.intersection(rawPolygon, EAST_OF_ANTIMERIDIAN_CLIP);
+        const westPart = westOverflow.map(mapWestOverflowPolygon);
+        const allParts = [...westPart, ...eastPart];
+        if (allParts.length === 1 && allParts[0]) {
+            return { type: "Polygon", coordinates: allParts[0] };
+        }
+        if (allParts.length > 1) {
+            return { type: "MultiPolygon", coordinates: allParts };
+        }
+        return null;
+    }
+    if (minRawLon < -180) {
+        const westPart = polygonClipping.intersection(rawPolygon, WESTERN_HEMISPHERE);
+        const eastOverflow = polygonClipping.intersection(rawPolygon, WEST_OF_ANTIMERIDIAN_CLIP);
+        const eastPart = eastOverflow.map(poly => shiftClipPolygonLongitudes(poly, 360));
         const allParts = [...westPart, ...eastPart];
         if (allParts.length === 1 && allParts[0]) {
             return { type: "Polygon", coordinates: allParts[0] };
@@ -647,9 +794,6 @@ const getPolygonFromPointAndRadius = (point, radius) => {
         if (allParts.length > 1) {
             return { type: "MultiPolygon", coordinates: allParts };
         }
-        // Both hemisphere intersections produced zero polygons — degenerate case
-        // (e.g. very small polygon near antimeridian). Returning the original
-        // coordinates would produce invalid geometry per RFC 7946 Section 3.1.9.
         return null;
     }
     return {
@@ -657,6 +801,230 @@ const getPolygonFromPointAndRadius = (point, radius) => {
         coordinates: [coordinates],
     };
 };
+/**
+ * Interpolate the latitude where an edge crossing a longitude boundary intersects it.
+ */
+const interpolateLatAtBoundary = (from, to, boundaryLng) => {
+    const t = (boundaryLng - from[0]) / (to[0] - from[0]);
+    const lat = from[1] + t * (to[1] - from[1]);
+    return [boundaryLng, lat];
+};
+/**
+ * Split a ring at a longitude boundary into an "inside" ring (lng on the keepSide
+ * of the boundary) and an "outside" ring (lng on the other side).
+ * Returns closed rings with intersection points inserted at boundary crossings.
+ */
+const splitRingAtBoundary = (ring, boundary, insideTest) => {
+    const insideVertices = [];
+    const outsideVertices = [];
+    for (let i = 0; i < ring.length - 1; i++) {
+        const current = ring[i];
+        const next = ring[i + 1];
+        if (current === undefined || next === undefined) {
+            continue;
+        }
+        const currentInside = insideTest(current[0]);
+        const nextInside = insideTest(next[0]);
+        if (currentInside) {
+            insideVertices.push(current);
+        }
+        else {
+            outsideVertices.push(current);
+        }
+        if (currentInside !== nextInside) {
+            const intersection = interpolateLatAtBoundary(current, next, boundary);
+            insideVertices.push(intersection);
+            outsideVertices.push(intersection);
+        }
+    }
+    const firstInside = insideVertices[0];
+    if (insideVertices.length > 0 && firstInside !== undefined) {
+        insideVertices.push(firstInside);
+    }
+    const firstOutside = outsideVertices[0];
+    if (outsideVertices.length > 0 && firstOutside !== undefined) {
+        outsideVertices.push(firstOutside);
+    }
+    return { inside: insideVertices, outside: outsideVertices };
+};
+/**
+ * Shift all longitudes in a ring by a given offset.
+ */
+const shiftRingLongitudes = (ring, offset) => ring.map(pos => (pos.length === 3 ? [pos[0] + offset, pos[1], pos[2]] : [pos[0] + offset, pos[1]]));
+/**
+ * Removes consecutive duplicate positions from a closed linear ring (including
+ * duplicate seam vertices produced when two edges meet at a boundary crossing).
+ */
+const dedupeConsecutiveLinearRing = (ring) => {
+    if (ring.length <= 2) {
+        return ring;
+    }
+    const seed = ring[0];
+    if (seed === undefined) {
+        return ring;
+    }
+    const out = [seed];
+    for (let i = 1; i < ring.length; i++) {
+        const prev = out[out.length - 1];
+        const cur = ring[i];
+        if (prev === undefined || cur === undefined) {
+            continue;
+        }
+        const same2d = prev[0] === cur[0] && prev[1] === cur[1];
+        const sameZ = prev.length < 3 || cur.length < 3 ? true : prev[2] === cur[2];
+        if (!same2d || !sameZ) {
+            out.push(cur);
+        }
+    }
+    const first = out[0];
+    const last = out[out.length - 1];
+    if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1])) {
+        out.push(first);
+    }
+    return out;
+};
+const ringLongitudeBounds = (ring) => {
+    const lngs = ring.map(p => p[0]);
+    return { minLng: Math.min(...lngs), maxLng: Math.max(...lngs) };
+};
+/**
+ * For a hole ring fully in [-180, 180], assigns it to the first or second
+ * MultiPolygon member so hole indices align with merge (east i-th hole pairs with west i-th hole):
+ * the i-th hole on the first shell pairs with the i-th hole on the second.
+ * Uses longitude midpoint: Pacific / positive → first polygon, Americas / negative → second.
+ */
+const oneSidedHoleGoesToFirstMultiPolygonMember = (hole) => {
+    const { minLng, maxLng } = ringLongitudeBounds(hole);
+    const midLng = (minLng + maxLng) / 2;
+    if (midLng > 0) {
+        return true;
+    }
+    if (midLng < 0) {
+        return false;
+    }
+    const firstLng = hole[0]?.[0] ?? 0;
+    return firstLng >= 0;
+};
+/**
+ * Appends interior rings to east/west shell lists for an antimeridian split.
+ * Rings that already lie in [-180, 180] are assigned to exactly one half (see
+ * `oneSidedHoleGoesToFirstMultiPolygonMember`). Rings that cross the seam are
+ * split via `splitCrossingHole`, which returns false when either fragment has
+ * fewer than four positions — invalid for a GeoJSON closed linear ring — in that
+ * case this function returns false and the caller must discard the whole split
+ * and return the input polygon unchanged.
+ */
+const distributeInteriorRingsForAntimeridianSplit = (holeRings, eastHoles, westHoles, splitCrossingHole) => {
+    for (const hole of holeRings) {
+        const hb = ringLongitudeBounds(hole);
+        if (hb.maxLng <= 180 && hb.minLng >= -180) {
+            if (oneSidedHoleGoesToFirstMultiPolygonMember(hole)) {
+                eastHoles.push(hole);
+            }
+            else {
+                westHoles.push(hole);
+            }
+        }
+        else if (!splitCrossingHole(hole)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * @description Splits a polygon (exterior + holes) at the antimeridian (±180°)
+ * into a two-member MultiPolygon per RFC 7946 Section 3.1.9, preserving
+ * interior rings and pairing east/west hole fragments by stable original order.
+ * If the exterior does not cross the antimeridian, the input is returned unchanged
+ * (including any hole coordinates).
+ *
+ * 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
+ * fewer than four positions (not a valid closed ring), the original polygon is
+ * returned unchanged.
+ */
+const splitPolygonWithHolesAtAntimeridian = (polygon) => {
+    const outerRing = polygon.coordinates[0];
+    if (outerRing === undefined) {
+        return polygon;
+    }
+    const holeRings = polygon.coordinates.slice(1);
+    const { maxLng, minLng } = ringLongitudeBounds(outerRing);
+    if (maxLng <= 180 && minLng >= -180) {
+        return polygon;
+    }
+    const eastHoles = [];
+    const westHoles = [];
+    const pushSplitHolePlus180 = (hole) => {
+        const { inside: eastRing, outside: westRing } = splitRingAtBoundary(hole, 180, lng => lng <= 180);
+        if (eastRing.length < 4 || westRing.length < 4) {
+            return false;
+        }
+        eastHoles.push(dedupeConsecutiveLinearRing(eastRing));
+        westHoles.push(dedupeConsecutiveLinearRing(shiftRingLongitudes(westRing, -360)));
+        return true;
+    };
+    const pushSplitHoleMinus180 = (hole) => {
+        const { inside: holeWestInside, outside: holeEastOutside } = splitRingAtBoundary(hole, -180, lng => lng >= -180);
+        if (holeEastOutside.length < 4 || holeWestInside.length < 4) {
+            return false;
+        }
+        eastHoles.push(dedupeConsecutiveLinearRing(shiftRingLongitudes(holeEastOutside, 360)));
+        westHoles.push(dedupeConsecutiveLinearRing(holeWestInside));
+        return true;
+    };
+    if (maxLng > 180) {
+        const { inside: eastRing, outside: westRing } = splitRingAtBoundary(outerRing, 180, lng => lng <= 180);
+        if (eastRing.length < 4 || westRing.length < 4) {
+            return polygon;
+        }
+        const eastOuter = dedupeConsecutiveLinearRing(eastRing);
+        const westOuter = dedupeConsecutiveLinearRing(shiftRingLongitudes(westRing, -360));
+        if (!distributeInteriorRingsForAntimeridianSplit(holeRings, eastHoles, westHoles, pushSplitHolePlus180)) {
+            return polygon;
+        }
+        return {
+            type: "MultiPolygon",
+            coordinates: [
+                [eastOuter, ...eastHoles],
+                [westOuter, ...westHoles],
+            ],
+        };
+    }
+    const { inside: outerWestInside, outside: outerEastOutside } = splitRingAtBoundary(outerRing, -180, lng => lng >= -180);
+    if (outerEastOutside.length < 4 || outerWestInside.length < 4) {
+        return polygon;
+    }
+    const minus180EastOuter = dedupeConsecutiveLinearRing(shiftRingLongitudes(outerEastOutside, 360));
+    const minus180WestOuter = dedupeConsecutiveLinearRing(outerWestInside);
+    if (!distributeInteriorRingsForAntimeridianSplit(holeRings, eastHoles, westHoles, pushSplitHoleMinus180)) {
+        return polygon;
+    }
+    return {
+        type: "MultiPolygon",
+        coordinates: [
+            [minus180EastOuter, ...eastHoles],
+            [minus180WestOuter, ...westHoles],
+        ],
+    };
+};
+/**
+ * @description Splits a polygon at the antimeridian (±180° longitude) into a
+ * 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.
+ *
+ * Delegates to {@link splitPolygonWithHolesAtAntimeridian} (holes are preserved).
+ */
+const splitPolygonAtAntimeridian = (polygon) => splitPolygonWithHolesAtAntimeridian(polygon);
 /**
  * @description Gets the extreme point of a polygon in a given direction.
  * @param {object} params - The parameters object
@@ -1114,6 +1482,8 @@ exports.isGeoJsonPointInPolygon = isGeoJsonPointInPolygon;
 exports.isGeoJsonPositionInLinearRing = isGeoJsonPositionInLinearRing;
 exports.isPositionInsideRing = isPositionInsideRing;
 exports.normalizeLongitudes = normalizeLongitudes;
+exports.splitPolygonAtAntimeridian = splitPolygonAtAntimeridian;
+exports.splitPolygonWithHolesAtAntimeridian = splitPolygonWithHolesAtAntimeridian;
 exports.toFeatureCollection = toFeatureCollection;
 exports.toPosition2d = toPosition2d;
 exports.tuGeoJsonPointRadiusSchema = tuGeoJsonPointRadiusSchema;

package/index.esm.js

@@ -591,6 +591,7 @@ const getBboxFromGeoJsonPolygon = (polygon) => {
     const { minLon, maxLon } = getMinMaxLongitudes(longitudes);
     return [minLon, Math.min(...latitudes), maxLon, Math.max(...latitudes)];
 };
+/** Folds any longitude to the [-180, 180] range. */
 const normalizeLongitude = (lon) => ((lon + 540) % 360) - 180;
 const WESTERN_HEMISPHERE = [
     [
@@ -610,18 +611,148 @@ const EASTERN_HEMISPHERE = [
         [0, -90],
     ],
 ];
+/** Unwrapped longitudes in (180°, 360°] — western half of a shape that crossed +180°. */
+const EAST_OF_ANTIMERIDIAN_CLIP = [
+    [
+        [180, -90],
+        [360, -90],
+        [360, 90],
+        [180, 90],
+        [180, -90],
+    ],
+];
+/** Unwrapped longitudes in [-360°, -180°) — eastern half of a shape that crossed -180°. */
+const WEST_OF_ANTIMERIDIAN_CLIP = [
+    [
+        [-360, -90],
+        [-180, -90],
+        [-180, 90],
+        [-360, 90],
+        [-360, -90],
+    ],
+];
+const shiftClipPolygonLongitudes = (polygon, offset) => polygon.map(ring => ring.map(([x, y]) => [x + offset, y]));
+const signedAreaOfClosedClipRing = (ring) => {
+    let sum = 0;
+    for (let i = 0; i < ring.length - 1; i++) {
+        const a = ring[i];
+        const b = ring[i + 1];
+        if (a === undefined || b === undefined) {
+            continue;
+        }
+        sum += a[0] * b[1] - b[0] * a[1];
+    }
+    return sum / 2;
+};
+/**
+ * Intersection with [180°, 360°] often traces the dateline as thousands of
+ * near-180° samples instead of a straight ±180° seam. That breaks
+ * antimeridian stitching (no consecutive ±180 vertices). Collapse the long
+ * near-dateline detour and keep the true western bulk arc.
+ */
+const repairWesternDatelineOverflowExteriorRing = (ring) => {
+    const openLen = ring.length - 1;
+    if (openLen < 4) {
+        return ring;
+    }
+    const antimeridianTol = 1e-5;
+    const amIndices = [];
+    for (let i = 0; i < openLen; i++) {
+        const lng = ring[i]?.[0];
+        if (lng !== undefined && Math.abs(lng + 180) < antimeridianTol) {
+            amIndices.push(i);
+        }
+    }
+    if (amIndices.length < 2) {
+        return ring;
+    }
+    const firstAm = amIndices[0];
+    const lastAm = amIndices[amIndices.length - 1];
+    if (firstAm === undefined || lastAm === undefined) {
+        return ring;
+    }
+    const vFirst = ring[firstAm];
+    const vLast = ring[lastAm];
+    if (vFirst === undefined || vLast === undefined) {
+        return ring;
+    }
+    const southIdx = vFirst[1] <= vLast[1] ? firstAm : lastAm;
+    const northIdx = vFirst[1] <= vLast[1] ? lastAm : firstAm;
+    const mainLonThreshold = -179.5;
+    const mainIndices = [];
+    for (let i = 0; i < openLen; i++) {
+        if (i === southIdx || i === northIdx) {
+            continue;
+        }
+        const lng = ring[i]?.[0];
+        if (lng !== undefined && lng > mainLonThreshold) {
+            mainIndices.push(i);
+        }
+    }
+    if (mainIndices.length === 0) {
+        return ring;
+    }
+    const vertexCountBetweenSouthAndNorth = northIdx > southIdx ? northIdx - southIdx - 1 : openLen - southIdx + northIdx - 1;
+    if (vertexCountBetweenSouthAndNorth < 100) {
+        return ring;
+    }
+    const south = ring[southIdx];
+    const north = ring[northIdx];
+    if (south === undefined || north === undefined) {
+        return ring;
+    }
+    const orderedMain = mainIndices.toSorted((a, b) => a - b);
+    const middle = [];
+    for (const idx of orderedMain) {
+        const pt = ring[idx];
+        if (pt !== undefined) {
+            middle.push(pt);
+        }
+    }
+    const originalSign = Math.sign(signedAreaOfClosedClipRing(ring));
+    // Seam on the western piece must run north→south at lng=-180 so latitudes are the reverse of
+    // the eastern piece at +180; mergeAntimeridianFeatures matches east vs reversed-west runs.
+    let candidate = [north, south, ...middle, north];
+    if (originalSign !== 0 && Math.sign(signedAreaOfClosedClipRing(candidate)) !== originalSign) {
+        const open = candidate.slice(0, -1).toReversed();
+        const first = open[0];
+        if (first !== undefined) {
+            candidate = [...open, first];
+        }
+    }
+    return candidate;
+};
+const mapWestOverflowPolygon = (poly) => {
+    const shifted = shiftClipPolygonLongitudes(poly, -360);
+    const [ext, ...holes] = shifted;
+    if (ext === undefined) {
+        return shifted;
+    }
+    return [repairWesternDatelineOverflowExteriorRing(ext), ...holes];
+};
 /**
  * @description Creates a round polygon from a point and a radius.
- * Handles antimeridian crossing per RFC 7946 Section 3.1.9 by splitting
+ *
+ * - Handles **antimeridian crossing** per RFC 7946 Section 3.1.9 by splitting
  * into a MultiPolygon. Clamps polar latitudes to [-90, 90].
  *
- * Returns null when the polygon crosses the antimeridian but both hemisphere
+ * - **Center longitude:** Map inputs may be outside [-180, 180] (e.g. 540°). The center is folded once by
+ * whole 360° turns into that range—same meridian on the ground; only the number used for math changes.
+ * - **Sampling the ring:** Each vertex is `lonCenter + offset` along the loop. Vertices use **continuous**
+ * longitude (no per-point normalization to [-180, 180]) so the planar ring does not self-intersect at the
+ * dateline; each hemisphere is clipped separately. We do not normalize every vertex to [-180, 180] by
+ * itself; that would turn a short step across the dateline into a long wrong chord. The western overflow
+ * piece is repaired so the ±180° seam is a short edge, which allows consumers such as
+ * `mergeAntimeridianFeatures` to merge halves for rendering.
+ *
+ * Returns **null** when the polygon crosses the antimeridian but both hemisphere
  * intersections yield zero polygons (e.g. very small polygons near the
  * dateline). In that case, returning the original coordinates would produce
- * invalid geometry per RFC 7946.
+ * invalid geometry per RFC 7946 Section 3.1.9.
  */
 const getPolygonFromPointAndRadius = (point, radius) => {
     const [lon, lat] = point.coordinates;
+    const lonCenter = normalizeLongitude(lon);
     const pointsCount = Math.max(32, Math.floor(radius / 100));
     const angleStep = (2 * Math.PI) / pointsCount;
     const deltaLat = (radius / EARTH_RADIUS) * (180 / Math.PI);
@@ -630,14 +761,30 @@ const getPolygonFromPointAndRadius = (point, radius) => {
     for (let i = 0; i <= pointsCount; i++) {
         const angle = i * angleStep;
         const newLat = Math.max(-90, Math.min(90, lat + deltaLat * Math.sin(angle)));
-        const newLon = normalizeLongitude(lon + deltaLon * Math.cos(angle));
+        const newLon = lonCenter + deltaLon * Math.cos(angle);
         coordinates.push([newLon, newLat]);
     }
-    const longitudes = coordinates.map(c => c[0]);
-    if (checkCrossesMeridian(longitudes)) {
-        const rawPolygon = [coordinates.map(c => [c[0], c[1]])];
-        const westPart = polygonClipping.intersection(rawPolygon, WESTERN_HEMISPHERE);
+    const rawLngs = coordinates.map(c => c[0]);
+    const minRawLon = Math.min(...rawLngs);
+    const maxRawLon = Math.max(...rawLngs);
+    const rawPolygon = [coordinates.map(c => [c[0], c[1]])];
+    if (maxRawLon > 180) {
         const eastPart = polygonClipping.intersection(rawPolygon, EASTERN_HEMISPHERE);
+        const westOverflow = polygonClipping.intersection(rawPolygon, EAST_OF_ANTIMERIDIAN_CLIP);
+        const westPart = westOverflow.map(mapWestOverflowPolygon);
+        const allParts = [...westPart, ...eastPart];
+        if (allParts.length === 1 && allParts[0]) {
+            return { type: "Polygon", coordinates: allParts[0] };
+        }
+        if (allParts.length > 1) {
+            return { type: "MultiPolygon", coordinates: allParts };
+        }
+        return null;
+    }
+    if (minRawLon < -180) {
+        const westPart = polygonClipping.intersection(rawPolygon, WESTERN_HEMISPHERE);
+        const eastOverflow = polygonClipping.intersection(rawPolygon, WEST_OF_ANTIMERIDIAN_CLIP);
+        const eastPart = eastOverflow.map(poly => shiftClipPolygonLongitudes(poly, 360));
         const allParts = [...westPart, ...eastPart];
         if (allParts.length === 1 && allParts[0]) {
             return { type: "Polygon", coordinates: allParts[0] };
@@ -645,9 +792,6 @@ const getPolygonFromPointAndRadius = (point, radius) => {
         if (allParts.length > 1) {
             return { type: "MultiPolygon", coordinates: allParts };
         }
-        // Both hemisphere intersections produced zero polygons — degenerate case
-        // (e.g. very small polygon near antimeridian). Returning the original
-        // coordinates would produce invalid geometry per RFC 7946 Section 3.1.9.
         return null;
     }
     return {
@@ -655,6 +799,230 @@ const getPolygonFromPointAndRadius = (point, radius) => {
         coordinates: [coordinates],
     };
 };
+/**
+ * Interpolate the latitude where an edge crossing a longitude boundary intersects it.
+ */
+const interpolateLatAtBoundary = (from, to, boundaryLng) => {
+    const t = (boundaryLng - from[0]) / (to[0] - from[0]);
+    const lat = from[1] + t * (to[1] - from[1]);
+    return [boundaryLng, lat];
+};
+/**
+ * Split a ring at a longitude boundary into an "inside" ring (lng on the keepSide
+ * of the boundary) and an "outside" ring (lng on the other side).
+ * Returns closed rings with intersection points inserted at boundary crossings.
+ */
+const splitRingAtBoundary = (ring, boundary, insideTest) => {
+    const insideVertices = [];
+    const outsideVertices = [];
+    for (let i = 0; i < ring.length - 1; i++) {
+        const current = ring[i];
+        const next = ring[i + 1];
+        if (current === undefined || next === undefined) {
+            continue;
+        }
+        const currentInside = insideTest(current[0]);
+        const nextInside = insideTest(next[0]);
+        if (currentInside) {
+            insideVertices.push(current);
+        }
+        else {
+            outsideVertices.push(current);
+        }
+        if (currentInside !== nextInside) {
+            const intersection = interpolateLatAtBoundary(current, next, boundary);
+            insideVertices.push(intersection);
+            outsideVertices.push(intersection);
+        }
+    }
+    const firstInside = insideVertices[0];
+    if (insideVertices.length > 0 && firstInside !== undefined) {
+        insideVertices.push(firstInside);
+    }
+    const firstOutside = outsideVertices[0];
+    if (outsideVertices.length > 0 && firstOutside !== undefined) {
+        outsideVertices.push(firstOutside);
+    }
+    return { inside: insideVertices, outside: outsideVertices };
+};
+/**
+ * Shift all longitudes in a ring by a given offset.
+ */
+const shiftRingLongitudes = (ring, offset) => ring.map(pos => (pos.length === 3 ? [pos[0] + offset, pos[1], pos[2]] : [pos[0] + offset, pos[1]]));
+/**
+ * Removes consecutive duplicate positions from a closed linear ring (including
+ * duplicate seam vertices produced when two edges meet at a boundary crossing).
+ */
+const dedupeConsecutiveLinearRing = (ring) => {
+    if (ring.length <= 2) {
+        return ring;
+    }
+    const seed = ring[0];
+    if (seed === undefined) {
+        return ring;
+    }
+    const out = [seed];
+    for (let i = 1; i < ring.length; i++) {
+        const prev = out[out.length - 1];
+        const cur = ring[i];
+        if (prev === undefined || cur === undefined) {
+            continue;
+        }
+        const same2d = prev[0] === cur[0] && prev[1] === cur[1];
+        const sameZ = prev.length < 3 || cur.length < 3 ? true : prev[2] === cur[2];
+        if (!same2d || !sameZ) {
+            out.push(cur);
+        }
+    }
+    const first = out[0];
+    const last = out[out.length - 1];
+    if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1])) {
+        out.push(first);
+    }
+    return out;
+};
+const ringLongitudeBounds = (ring) => {
+    const lngs = ring.map(p => p[0]);
+    return { minLng: Math.min(...lngs), maxLng: Math.max(...lngs) };
+};
+/**
+ * For a hole ring fully in [-180, 180], assigns it to the first or second
+ * MultiPolygon member so hole indices align with merge (east i-th hole pairs with west i-th hole):
+ * the i-th hole on the first shell pairs with the i-th hole on the second.
+ * Uses longitude midpoint: Pacific / positive → first polygon, Americas / negative → second.
+ */
+const oneSidedHoleGoesToFirstMultiPolygonMember = (hole) => {
+    const { minLng, maxLng } = ringLongitudeBounds(hole);
+    const midLng = (minLng + maxLng) / 2;
+    if (midLng > 0) {
+        return true;
+    }
+    if (midLng < 0) {
+        return false;
+    }
+    const firstLng = hole[0]?.[0] ?? 0;
+    return firstLng >= 0;
+};
+/**
+ * Appends interior rings to east/west shell lists for an antimeridian split.
+ * Rings that already lie in [-180, 180] are assigned to exactly one half (see
+ * `oneSidedHoleGoesToFirstMultiPolygonMember`). Rings that cross the seam are
+ * split via `splitCrossingHole`, which returns false when either fragment has
+ * fewer than four positions — invalid for a GeoJSON closed linear ring — in that
+ * case this function returns false and the caller must discard the whole split
+ * and return the input polygon unchanged.
+ */
+const distributeInteriorRingsForAntimeridianSplit = (holeRings, eastHoles, westHoles, splitCrossingHole) => {
+    for (const hole of holeRings) {
+        const hb = ringLongitudeBounds(hole);
+        if (hb.maxLng <= 180 && hb.minLng >= -180) {
+            if (oneSidedHoleGoesToFirstMultiPolygonMember(hole)) {
+                eastHoles.push(hole);
+            }
+            else {
+                westHoles.push(hole);
+            }
+        }
+        else if (!splitCrossingHole(hole)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * @description Splits a polygon (exterior + holes) at the antimeridian (±180°)
+ * into a two-member MultiPolygon per RFC 7946 Section 3.1.9, preserving
+ * interior rings and pairing east/west hole fragments by stable original order.
+ * If the exterior does not cross the antimeridian, the input is returned unchanged
+ * (including any hole coordinates).
+ *
+ * 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
+ * fewer than four positions (not a valid closed ring), the original polygon is
+ * returned unchanged.
+ */
+const splitPolygonWithHolesAtAntimeridian = (polygon) => {
+    const outerRing = polygon.coordinates[0];
+    if (outerRing === undefined) {
+        return polygon;
+    }
+    const holeRings = polygon.coordinates.slice(1);
+    const { maxLng, minLng } = ringLongitudeBounds(outerRing);
+    if (maxLng <= 180 && minLng >= -180) {
+        return polygon;
+    }
+    const eastHoles = [];
+    const westHoles = [];
+    const pushSplitHolePlus180 = (hole) => {
+        const { inside: eastRing, outside: westRing } = splitRingAtBoundary(hole, 180, lng => lng <= 180);
+        if (eastRing.length < 4 || westRing.length < 4) {
+            return false;
+        }
+        eastHoles.push(dedupeConsecutiveLinearRing(eastRing));
+        westHoles.push(dedupeConsecutiveLinearRing(shiftRingLongitudes(westRing, -360)));
+        return true;
+    };
+    const pushSplitHoleMinus180 = (hole) => {
+        const { inside: holeWestInside, outside: holeEastOutside } = splitRingAtBoundary(hole, -180, lng => lng >= -180);
+        if (holeEastOutside.length < 4 || holeWestInside.length < 4) {
+            return false;
+        }
+        eastHoles.push(dedupeConsecutiveLinearRing(shiftRingLongitudes(holeEastOutside, 360)));
+        westHoles.push(dedupeConsecutiveLinearRing(holeWestInside));
+        return true;
+    };
+    if (maxLng > 180) {
+        const { inside: eastRing, outside: westRing } = splitRingAtBoundary(outerRing, 180, lng => lng <= 180);
+        if (eastRing.length < 4 || westRing.length < 4) {
+            return polygon;
+        }
+        const eastOuter = dedupeConsecutiveLinearRing(eastRing);
+        const westOuter = dedupeConsecutiveLinearRing(shiftRingLongitudes(westRing, -360));
+        if (!distributeInteriorRingsForAntimeridianSplit(holeRings, eastHoles, westHoles, pushSplitHolePlus180)) {
+            return polygon;
+        }
+        return {
+            type: "MultiPolygon",
+            coordinates: [
+                [eastOuter, ...eastHoles],
+                [westOuter, ...westHoles],
+            ],
+        };
+    }
+    const { inside: outerWestInside, outside: outerEastOutside } = splitRingAtBoundary(outerRing, -180, lng => lng >= -180);
+    if (outerEastOutside.length < 4 || outerWestInside.length < 4) {
+        return polygon;
+    }
+    const minus180EastOuter = dedupeConsecutiveLinearRing(shiftRingLongitudes(outerEastOutside, 360));
+    const minus180WestOuter = dedupeConsecutiveLinearRing(outerWestInside);
+    if (!distributeInteriorRingsForAntimeridianSplit(holeRings, eastHoles, westHoles, pushSplitHoleMinus180)) {
+        return polygon;
+    }
+    return {
+        type: "MultiPolygon",
+        coordinates: [
+            [minus180EastOuter, ...eastHoles],
+            [minus180WestOuter, ...westHoles],
+        ],
+    };
+};
+/**
+ * @description Splits a polygon at the antimeridian (±180° longitude) into a
+ * 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.
+ *
+ * Delegates to {@link splitPolygonWithHolesAtAntimeridian} (holes are preserved).
+ */
+const splitPolygonAtAntimeridian = (polygon) => splitPolygonWithHolesAtAntimeridian(polygon);
 /**
  * @description Gets the extreme point of a polygon in a given direction.
  * @param {object} params - The parameters object
@@ -1071,4 +1439,4 @@ const tuGeoJsonRectangularBoxPolygonSchema = z
     }
 });
 
-export { EARTH_RADIUS, boundingBoxCrossesMeridian, checkCrossesMeridian, computeGeometryCentroid, coordinatesToStandardFormat, denormalizeLongitude, extractEdges, extractFirstPointCoordinate, extractPositionsFromGeometry, geoJsonBboxSchema, geoJsonFeatureCollectionSchema, geoJsonFeatureSchema, geoJsonGeometryCollectionSchema, geoJsonGeometrySchema, geoJsonLineStringSchema, geoJsonLinearRingSchema, geoJsonMultiLineStringSchema, geoJsonMultiPointSchema, geoJsonMultiPolygonSchema, geoJsonPointSchema, geoJsonPolygonSchema, geoJsonPosition2dSchema, geoJsonPositionSchema, getBboxFromGeoJsonPolygon, getBoundingBoxFromGeoJsonBbox, getBoundingBoxFromGeoJsonPolygon, getExtremeGeoJsonPointFromPolygon, getGeoJsonPolygonFromBoundingBox, getGeoJsonPolygonIntersection, getMinMaxLongitudes, getMultipleCoordinatesFromGeoJsonObject, getPointCoordinateFromGeoJsonObject, getPointCoordinateFromGeoJsonPoint, getPolygonFromBbox, getPolygonFromPointAndRadius, isBboxInsideFeatureCollection, isFullyContainedInGeoJsonPolygon, isGeoJsonPointInPolygon, isGeoJsonPositionInLinearRing, isPositionInsideRing, normalizeLongitudes, toFeatureCollection, toPosition2d, tuGeoJsonPointRadiusSchema, tuGeoJsonPolygonNoHolesSchema, tuGeoJsonRectangularBoxPolygonSchema };
+export { EARTH_RADIUS, boundingBoxCrossesMeridian, checkCrossesMeridian, computeGeometryCentroid, coordinatesToStandardFormat, denormalizeLongitude, extractEdges, extractFirstPointCoordinate, extractPositionsFromGeometry, geoJsonBboxSchema, geoJsonFeatureCollectionSchema, geoJsonFeatureSchema, geoJsonGeometryCollectionSchema, geoJsonGeometrySchema, geoJsonLineStringSchema, geoJsonLinearRingSchema, geoJsonMultiLineStringSchema, geoJsonMultiPointSchema, geoJsonMultiPolygonSchema, geoJsonPointSchema, geoJsonPolygonSchema, geoJsonPosition2dSchema, geoJsonPositionSchema, getBboxFromGeoJsonPolygon, getBoundingBoxFromGeoJsonBbox, getBoundingBoxFromGeoJsonPolygon, getExtremeGeoJsonPointFromPolygon, getGeoJsonPolygonFromBoundingBox, getGeoJsonPolygonIntersection, getMinMaxLongitudes, getMultipleCoordinatesFromGeoJsonObject, getPointCoordinateFromGeoJsonObject, getPointCoordinateFromGeoJsonPoint, getPolygonFromBbox, getPolygonFromPointAndRadius, isBboxInsideFeatureCollection, isFullyContainedInGeoJsonPolygon, isGeoJsonPointInPolygon, isGeoJsonPositionInLinearRing, isPositionInsideRing, normalizeLongitudes, splitPolygonAtAntimeridian, splitPolygonWithHolesAtAntimeridian, toFeatureCollection, toPosition2d, tuGeoJsonPointRadiusSchema, tuGeoJsonPolygonNoHolesSchema, tuGeoJsonRectangularBoxPolygonSchema };

package/package.json

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

package/src/GeoJsonUtils.d.ts

@@ -13,15 +13,55 @@ export declare const getPolygonFromBbox: (bbox: GeoJsonBbox) => GeoJsonPolygon |
 export declare const getBboxFromGeoJsonPolygon: (polygon: GeoJsonPolygon | GeoJsonMultiPolygon) => GeoJsonBbox | null;
 /**
  * @description Creates a round polygon from a point and a radius.
- * Handles antimeridian crossing per RFC 7946 Section 3.1.9 by splitting
+ *
+ * - Handles **antimeridian crossing** per RFC 7946 Section 3.1.9 by splitting
  * into a MultiPolygon. Clamps polar latitudes to [-90, 90].
  *
- * Returns null when the polygon crosses the antimeridian but both hemisphere
+ * - **Center longitude:** Map inputs may be outside [-180, 180] (e.g. 540°). The center is folded once by
+ * whole 360° turns into that range—same meridian on the ground; only the number used for math changes.
+ * - **Sampling the ring:** Each vertex is `lonCenter + offset` along the loop. Vertices use **continuous**
+ * longitude (no per-point normalization to [-180, 180]) so the planar ring does not self-intersect at the
+ * dateline; each hemisphere is clipped separately. We do not normalize every vertex to [-180, 180] by
+ * itself; that would turn a short step across the dateline into a long wrong chord. The western overflow
+ * piece is repaired so the ±180° seam is a short edge, which allows consumers such as
+ * `mergeAntimeridianFeatures` to merge halves for rendering.
+ *
+ * Returns **null** when the polygon crosses the antimeridian but both hemisphere
  * intersections yield zero polygons (e.g. very small polygons near the
  * dateline). In that case, returning the original coordinates would produce
- * invalid geometry per RFC 7946.
+ * invalid geometry per RFC 7946 Section 3.1.9.
  */
 export declare const getPolygonFromPointAndRadius: (point: GeoJsonPoint, radius: number) => GeoJsonPolygon | GeoJsonMultiPolygon | null;
+/**
+ * @description Splits a polygon (exterior + holes) at the antimeridian (±180°)
+ * into a two-member MultiPolygon per RFC 7946 Section 3.1.9, preserving
+ * interior rings and pairing east/west hole fragments by stable original order.
+ * If the exterior does not cross the antimeridian, the input is returned unchanged
+ * (including any hole coordinates).
+ *
+ * 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
+ * fewer than four positions (not a valid closed ring), the original polygon is
+ * returned unchanged.
+ */
+export declare const splitPolygonWithHolesAtAntimeridian: (polygon: GeoJsonPolygon) => GeoJsonPolygon | GeoJsonMultiPolygon;
+/**
+ * @description Splits a polygon at the antimeridian (±180° longitude) into a
+ * 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.
+ *
+ * Delegates to {@link splitPolygonWithHolesAtAntimeridian} (holes are preserved).
+ */
+export declare const splitPolygonAtAntimeridian: (polygon: GeoJsonPolygon) => GeoJsonPolygon | GeoJsonMultiPolygon;
 /**
  * @description Gets the extreme point of a polygon in a given direction.
  * @param {object} params - The parameters object