@trackunit/geo-json-utils 1.14.30 → 1.14.32

package/index.cjs.js

@@ -1256,6 +1256,202 @@ const getGeoJsonPolygonIntersection = (polygon1, polygon2) => {
         coordinates: intersectionResult,
     };
 };
+/**
+ * Computes the difference of subject minus the union of all clips.
+ * Returns null when the subject is fully covered (zero remaining area).
+ * Returns Polygon for a single-ring result, MultiPolygon otherwise.
+ * When clips is empty the subject is returned unchanged.
+ */
+const geoJsonPolygonDifference = (subject, clips) => {
+    if (clips.length === 0) {
+        return subject;
+    }
+    const subjectClip = subject.type === "MultiPolygon" ? toClipMultiPolygon(subject.coordinates) : [toClipPolygon(subject.coordinates)];
+    const clipsConverted = clips.map(clip => clip.type === "MultiPolygon" ? toClipMultiPolygon(clip.coordinates) : [toClipPolygon(clip.coordinates)]);
+    let differenceResult;
+    try {
+        differenceResult = polygonClipping.difference(subjectClip, ...clipsConverted);
+    }
+    catch {
+        // polygon-clipping can throw "Unable to complete output ring" for degenerate or
+        // near-self-intersecting polygons. Fall back to returning the subject unclipped
+        // so the shape still renders rather than crashing the caller.
+        return subject;
+    }
+    if (differenceResult.length === 0) {
+        return null;
+    }
+    if (differenceResult.length === 1 && differenceResult[0]) {
+        return {
+            type: "Polygon",
+            coordinates: differenceResult[0],
+        };
+    }
+    return {
+        type: "MultiPolygon",
+        coordinates: differenceResult,
+    };
+};
+// Web Mercator (EPSG:3857) latitude limit. Beyond this the projection diverges to
+// infinity; clamping keeps the round-trip finite for shapes near the poles.
+const WEB_MERCATOR_MAX_LAT = 85.05112878;
+const DEG_TO_RAD$1 = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+/**
+ * Project a `[lng, lat]` position to Web Mercator metres (EPSG:3857).
+ *
+ * Web map renderers (Google Maps, Mapbox, …) draw straight polygon edges in this
+ * projected space, not in planar lng/lat. Boolean geometry operations whose result
+ * must visually align with rendered edges therefore have to run in Web Mercator —
+ * see `unprojectWebMercatorToLngLat` for the inverse.
+ */
+const projectLngLatToWebMercator = (position) => {
+    const [lng, lat] = position;
+    const clampedLat = Math.max(-WEB_MERCATOR_MAX_LAT, Math.min(WEB_MERCATOR_MAX_LAT, lat));
+    const x = lng * DEG_TO_RAD$1 * EARTH_RADIUS;
+    const y = Math.log(Math.tan(Math.PI / 4 + (clampedLat * DEG_TO_RAD$1) / 2)) * EARTH_RADIUS;
+    return [x, y];
+};
+/** Inverse of `projectLngLatToWebMercator`: Web Mercator metres back to `[lng, lat]`. */
+const unprojectWebMercatorToLngLat = (position) => {
+    const [x, y] = position;
+    const lng = (x / EARTH_RADIUS) * RAD_TO_DEG;
+    const lat = (2 * Math.atan(Math.exp(y / EARTH_RADIUS)) - Math.PI / 2) * RAD_TO_DEG;
+    return [lng, lat];
+};
+const mapPolygonalCoordinates = (geometry, project) => {
+    const mapRing = (ring) => ring.map(project);
+    if (geometry.type === "Polygon") {
+        return { type: "Polygon", coordinates: geometry.coordinates.map(mapRing) };
+    }
+    return { type: "MultiPolygon", coordinates: geometry.coordinates.map(rings => rings.map(mapRing)) };
+};
+/**
+ * Project a polygonal geometry's coordinates to Web Mercator metres, preserving its
+ * ring/part structure. The output is no longer valid lng/lat — feed it to operations
+ * such as `geoJsonPolygonDifference` and unproject the result with
+ * `unprojectPolygonalFromWebMercator`.
+ */
+const projectPolygonalToWebMercator = (geometry) => mapPolygonalCoordinates(geometry, projectLngLatToWebMercator);
+/** Inverse of `projectPolygonalToWebMercator`. */
+const unprojectPolygonalFromWebMercator = (geometry) => mapPolygonalCoordinates(geometry, unprojectWebMercatorToLngLat);
+/**
+ * Generalisation of isFullyContainedInGeoJsonPolygon to Polygon|MultiPolygon arguments.
+ * Returns true when every outer-ring vertex of geom1 lies inside geom2 (holes respected).
+ * For a MultiPolygon geom2, "inside" means inside any one of its polygon members.
+ * Returns null if either geometry fails validation.
+ */
+const isFullyContainedInGeoJsonGeometry = (geom1, geom2) => {
+    const outerRings1 = [];
+    if (geom1.type === "Polygon") {
+        const parsed = geoJsonPolygonSchema.safeParse(geom1);
+        if (!parsed.success)
+            return null;
+        const outerRing = parsed.data.coordinates[0];
+        if (!outerRing)
+            return null;
+        outerRings1.push(outerRing);
+    }
+    else {
+        const parsed = geoJsonMultiPolygonSchema.safeParse(geom1);
+        if (!parsed.success)
+            return null;
+        for (const poly of parsed.data.coordinates) {
+            const outerRing = poly[0];
+            if (!outerRing)
+                return null;
+            outerRings1.push(outerRing);
+        }
+    }
+    const polygonParts2 = [];
+    if (geom2.type === "Polygon") {
+        const parsed = geoJsonPolygonSchema.safeParse(geom2);
+        if (!parsed.success)
+            return null;
+        polygonParts2.push(parsed.data);
+    }
+    else {
+        const parsed = geoJsonMultiPolygonSchema.safeParse(geom2);
+        if (!parsed.success)
+            return null;
+        for (const poly of parsed.data.coordinates) {
+            polygonParts2.push({ type: "Polygon", coordinates: poly });
+        }
+    }
+    for (const outerRing of outerRings1) {
+        for (const position of outerRing) {
+            const point = { coordinates: position };
+            let insideAny = false;
+            for (const part of polygonParts2) {
+                const result = isGeoJsonPointInPolygon({ point, polygon: part });
+                if (result === null)
+                    return null;
+                if (result) {
+                    insideAny = true;
+                    break;
+                }
+            }
+            if (!insideAny)
+                return false;
+        }
+    }
+    return true;
+};
+/**
+ * Returns the minimum distance (in coordinate units) from the given position to the
+ * nearest edge segment of any ring of the polygon/multipolygon, including hole rings.
+ * Returns null if the geometry fails validation.
+ *
+ * Distance is in geographic-coordinate units (degrees), appropriate for relative
+ * Penetration Depth comparisons where only ordering matters, not absolute metric values.
+ */
+const distanceToGeoJsonPolygonBoundary = (position, geometry) => {
+    const rings = [];
+    if (geometry.type === "Polygon") {
+        const parsed = geoJsonPolygonSchema.safeParse(geometry);
+        if (!parsed.success)
+            return null;
+        rings.push(...parsed.data.coordinates);
+    }
+    else {
+        const parsed = geoJsonMultiPolygonSchema.safeParse(geometry);
+        if (!parsed.success)
+            return null;
+        for (const poly of parsed.data.coordinates) {
+            rings.push(...poly);
+        }
+    }
+    if (rings.length === 0)
+        return null;
+    const [px, py] = position;
+    let minDist = Infinity;
+    for (const ring of rings) {
+        for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+            const a = ring[j];
+            const b = ring[i];
+            if (!a || !b)
+                continue;
+            const [ax, ay] = a;
+            const [bx, by] = b;
+            const dx = bx - ax;
+            const dy = by - ay;
+            let dist;
+            if (dx === 0 && dy === 0) {
+                dist = Math.sqrt((px - ax) ** 2 + (py - ay) ** 2);
+            }
+            else {
+                const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)));
+                const nearx = ax + t * dx;
+                const neary = ay + t * dy;
+                dist = Math.sqrt((px - nearx) ** 2 + (py - neary) ** 2);
+            }
+            if (dist < minDist) {
+                minDist = dist;
+            }
+        }
+    }
+    return minDist === Infinity ? null : minDist;
+};
 
 //! These tools are used to bridge the gap with out poorly typed graphql types
 // Should be ideally be avoided but are needed until we fix the graphql types
@@ -1553,6 +1749,7 @@ exports.checkCrossesMeridian = checkCrossesMeridian;
 exports.computeGeometryCentroid = computeGeometryCentroid;
 exports.coordinatesToStandardFormat = coordinatesToStandardFormat;
 exports.denormalizeLongitude = denormalizeLongitude;
+exports.distanceToGeoJsonPolygonBoundary = distanceToGeoJsonPolygonBoundary;
 exports.edgePixelLength = edgePixelLength;
 exports.extractEdges = extractEdges;
 exports.extractFirstPointCoordinate = extractFirstPointCoordinate;
@@ -1568,6 +1765,7 @@ exports.geoJsonMultiLineStringSchema = geoJsonMultiLineStringSchema;
 exports.geoJsonMultiPointSchema = geoJsonMultiPointSchema;
 exports.geoJsonMultiPolygonSchema = geoJsonMultiPolygonSchema;
 exports.geoJsonPointSchema = geoJsonPointSchema;
+exports.geoJsonPolygonDifference = geoJsonPolygonDifference;
 exports.geoJsonPolygonSchema = geoJsonPolygonSchema;
 exports.geoJsonPosition2dSchema = geoJsonPosition2dSchema;
 exports.geoJsonPositionSchema = geoJsonPositionSchema;
@@ -1584,11 +1782,14 @@ exports.getPointCoordinateFromGeoJsonPoint = getPointCoordinateFromGeoJsonPoint;
 exports.getPolygonFromBbox = getPolygonFromBbox;
 exports.getPolygonFromPointAndRadius = getPolygonFromPointAndRadius;
 exports.isBboxInsideFeatureCollection = isBboxInsideFeatureCollection;
+exports.isFullyContainedInGeoJsonGeometry = isFullyContainedInGeoJsonGeometry;
 exports.isFullyContainedInGeoJsonPolygon = isFullyContainedInGeoJsonPolygon;
 exports.isGeoJsonPointInPolygon = isGeoJsonPointInPolygon;
 exports.isGeoJsonPositionInLinearRing = isGeoJsonPositionInLinearRing;
 exports.isPositionInsideRing = isPositionInsideRing;
 exports.normalizeLongitudes = normalizeLongitudes;
+exports.projectLngLatToWebMercator = projectLngLatToWebMercator;
+exports.projectPolygonalToWebMercator = projectPolygonalToWebMercator;
 exports.splitPolygonAtAntimeridian = splitPolygonAtAntimeridian;
 exports.splitPolygonWithHolesAtAntimeridian = splitPolygonWithHolesAtAntimeridian;
 exports.toFeatureCollection = toFeatureCollection;
@@ -1596,6 +1797,8 @@ exports.toPosition2d = toPosition2d;
 exports.tuGeoJsonPointRadiusSchema = tuGeoJsonPointRadiusSchema;
 exports.tuGeoJsonPolygonNoHolesSchema = tuGeoJsonPolygonNoHolesSchema;
 exports.tuGeoJsonRectangularBoxPolygonSchema = tuGeoJsonRectangularBoxPolygonSchema;
+exports.unprojectPolygonalFromWebMercator = unprojectPolygonalFromWebMercator;
+exports.unprojectWebMercatorToLngLat = unprojectWebMercatorToLngLat;
 exports.validateBbox = validateBbox;
 exports.validateBboxWithFallback = validateBboxWithFallback;
 exports.validateFeatureCollection = validateFeatureCollection;

package/index.esm.js

@@ -1254,6 +1254,202 @@ const getGeoJsonPolygonIntersection = (polygon1, polygon2) => {
         coordinates: intersectionResult,
     };
 };
+/**
+ * Computes the difference of subject minus the union of all clips.
+ * Returns null when the subject is fully covered (zero remaining area).
+ * Returns Polygon for a single-ring result, MultiPolygon otherwise.
+ * When clips is empty the subject is returned unchanged.
+ */
+const geoJsonPolygonDifference = (subject, clips) => {
+    if (clips.length === 0) {
+        return subject;
+    }
+    const subjectClip = subject.type === "MultiPolygon" ? toClipMultiPolygon(subject.coordinates) : [toClipPolygon(subject.coordinates)];
+    const clipsConverted = clips.map(clip => clip.type === "MultiPolygon" ? toClipMultiPolygon(clip.coordinates) : [toClipPolygon(clip.coordinates)]);
+    let differenceResult;
+    try {
+        differenceResult = polygonClipping.difference(subjectClip, ...clipsConverted);
+    }
+    catch {
+        // polygon-clipping can throw "Unable to complete output ring" for degenerate or
+        // near-self-intersecting polygons. Fall back to returning the subject unclipped
+        // so the shape still renders rather than crashing the caller.
+        return subject;
+    }
+    if (differenceResult.length === 0) {
+        return null;
+    }
+    if (differenceResult.length === 1 && differenceResult[0]) {
+        return {
+            type: "Polygon",
+            coordinates: differenceResult[0],
+        };
+    }
+    return {
+        type: "MultiPolygon",
+        coordinates: differenceResult,
+    };
+};
+// Web Mercator (EPSG:3857) latitude limit. Beyond this the projection diverges to
+// infinity; clamping keeps the round-trip finite for shapes near the poles.
+const WEB_MERCATOR_MAX_LAT = 85.05112878;
+const DEG_TO_RAD$1 = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+/**
+ * Project a `[lng, lat]` position to Web Mercator metres (EPSG:3857).
+ *
+ * Web map renderers (Google Maps, Mapbox, …) draw straight polygon edges in this
+ * projected space, not in planar lng/lat. Boolean geometry operations whose result
+ * must visually align with rendered edges therefore have to run in Web Mercator —
+ * see `unprojectWebMercatorToLngLat` for the inverse.
+ */
+const projectLngLatToWebMercator = (position) => {
+    const [lng, lat] = position;
+    const clampedLat = Math.max(-WEB_MERCATOR_MAX_LAT, Math.min(WEB_MERCATOR_MAX_LAT, lat));
+    const x = lng * DEG_TO_RAD$1 * EARTH_RADIUS;
+    const y = Math.log(Math.tan(Math.PI / 4 + (clampedLat * DEG_TO_RAD$1) / 2)) * EARTH_RADIUS;
+    return [x, y];
+};
+/** Inverse of `projectLngLatToWebMercator`: Web Mercator metres back to `[lng, lat]`. */
+const unprojectWebMercatorToLngLat = (position) => {
+    const [x, y] = position;
+    const lng = (x / EARTH_RADIUS) * RAD_TO_DEG;
+    const lat = (2 * Math.atan(Math.exp(y / EARTH_RADIUS)) - Math.PI / 2) * RAD_TO_DEG;
+    return [lng, lat];
+};
+const mapPolygonalCoordinates = (geometry, project) => {
+    const mapRing = (ring) => ring.map(project);
+    if (geometry.type === "Polygon") {
+        return { type: "Polygon", coordinates: geometry.coordinates.map(mapRing) };
+    }
+    return { type: "MultiPolygon", coordinates: geometry.coordinates.map(rings => rings.map(mapRing)) };
+};
+/**
+ * Project a polygonal geometry's coordinates to Web Mercator metres, preserving its
+ * ring/part structure. The output is no longer valid lng/lat — feed it to operations
+ * such as `geoJsonPolygonDifference` and unproject the result with
+ * `unprojectPolygonalFromWebMercator`.
+ */
+const projectPolygonalToWebMercator = (geometry) => mapPolygonalCoordinates(geometry, projectLngLatToWebMercator);
+/** Inverse of `projectPolygonalToWebMercator`. */
+const unprojectPolygonalFromWebMercator = (geometry) => mapPolygonalCoordinates(geometry, unprojectWebMercatorToLngLat);
+/**
+ * Generalisation of isFullyContainedInGeoJsonPolygon to Polygon|MultiPolygon arguments.
+ * Returns true when every outer-ring vertex of geom1 lies inside geom2 (holes respected).
+ * For a MultiPolygon geom2, "inside" means inside any one of its polygon members.
+ * Returns null if either geometry fails validation.
+ */
+const isFullyContainedInGeoJsonGeometry = (geom1, geom2) => {
+    const outerRings1 = [];
+    if (geom1.type === "Polygon") {
+        const parsed = geoJsonPolygonSchema.safeParse(geom1);
+        if (!parsed.success)
+            return null;
+        const outerRing = parsed.data.coordinates[0];
+        if (!outerRing)
+            return null;
+        outerRings1.push(outerRing);
+    }
+    else {
+        const parsed = geoJsonMultiPolygonSchema.safeParse(geom1);
+        if (!parsed.success)
+            return null;
+        for (const poly of parsed.data.coordinates) {
+            const outerRing = poly[0];
+            if (!outerRing)
+                return null;
+            outerRings1.push(outerRing);
+        }
+    }
+    const polygonParts2 = [];
+    if (geom2.type === "Polygon") {
+        const parsed = geoJsonPolygonSchema.safeParse(geom2);
+        if (!parsed.success)
+            return null;
+        polygonParts2.push(parsed.data);
+    }
+    else {
+        const parsed = geoJsonMultiPolygonSchema.safeParse(geom2);
+        if (!parsed.success)
+            return null;
+        for (const poly of parsed.data.coordinates) {
+            polygonParts2.push({ type: "Polygon", coordinates: poly });
+        }
+    }
+    for (const outerRing of outerRings1) {
+        for (const position of outerRing) {
+            const point = { coordinates: position };
+            let insideAny = false;
+            for (const part of polygonParts2) {
+                const result = isGeoJsonPointInPolygon({ point, polygon: part });
+                if (result === null)
+                    return null;
+                if (result) {
+                    insideAny = true;
+                    break;
+                }
+            }
+            if (!insideAny)
+                return false;
+        }
+    }
+    return true;
+};
+/**
+ * Returns the minimum distance (in coordinate units) from the given position to the
+ * nearest edge segment of any ring of the polygon/multipolygon, including hole rings.
+ * Returns null if the geometry fails validation.
+ *
+ * Distance is in geographic-coordinate units (degrees), appropriate for relative
+ * Penetration Depth comparisons where only ordering matters, not absolute metric values.
+ */
+const distanceToGeoJsonPolygonBoundary = (position, geometry) => {
+    const rings = [];
+    if (geometry.type === "Polygon") {
+        const parsed = geoJsonPolygonSchema.safeParse(geometry);
+        if (!parsed.success)
+            return null;
+        rings.push(...parsed.data.coordinates);
+    }
+    else {
+        const parsed = geoJsonMultiPolygonSchema.safeParse(geometry);
+        if (!parsed.success)
+            return null;
+        for (const poly of parsed.data.coordinates) {
+            rings.push(...poly);
+        }
+    }
+    if (rings.length === 0)
+        return null;
+    const [px, py] = position;
+    let minDist = Infinity;
+    for (const ring of rings) {
+        for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+            const a = ring[j];
+            const b = ring[i];
+            if (!a || !b)
+                continue;
+            const [ax, ay] = a;
+            const [bx, by] = b;
+            const dx = bx - ax;
+            const dy = by - ay;
+            let dist;
+            if (dx === 0 && dy === 0) {
+                dist = Math.sqrt((px - ax) ** 2 + (py - ay) ** 2);
+            }
+            else {
+                const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)));
+                const nearx = ax + t * dx;
+                const neary = ay + t * dy;
+                dist = Math.sqrt((px - nearx) ** 2 + (py - neary) ** 2);
+            }
+            if (dist < minDist) {
+                minDist = dist;
+            }
+        }
+    }
+    return minDist === Infinity ? null : minDist;
+};
 
 //! These tools are used to bridge the gap with out poorly typed graphql types
 // Should be ideally be avoided but are needed until we fix the graphql types
@@ -1544,4 +1740,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, edgePixelLength, 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, validateBbox, validateBboxWithFallback, validateFeatureCollection, validatePosition };
+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, isGeoJsonPointInPolygon, isGeoJsonPositionInLinearRing, isPositionInsideRing, normalizeLongitudes, projectLngLatToWebMercator, projectPolygonalToWebMercator, splitPolygonAtAntimeridian, splitPolygonWithHolesAtAntimeridian, toFeatureCollection, toPosition2d, tuGeoJsonPointRadiusSchema, tuGeoJsonPolygonNoHolesSchema, tuGeoJsonRectangularBoxPolygonSchema, unprojectPolygonalFromWebMercator, unprojectWebMercatorToLngLat, validateBbox, validateBboxWithFallback, validateFeatureCollection, validatePosition };

package/package.json

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

package/src/GeoJsonUtils.d.ts

@@ -101,3 +101,46 @@ export declare const isFullyContainedInGeoJsonPolygon: (polygon1: GeoJsonPolygon
  * Returns a MultiPolygon representing the intersection, or null if there is no intersection.
  */
 export declare const getGeoJsonPolygonIntersection: (polygon1: GeoJsonPolygon | GeoJsonMultiPolygon, polygon2: GeoJsonPolygon | GeoJsonMultiPolygon) => GeoJsonMultiPolygon | GeoJsonPolygon | null;
+/**
+ * Computes the difference of subject minus the union of all clips.
+ * Returns null when the subject is fully covered (zero remaining area).
+ * Returns Polygon for a single-ring result, MultiPolygon otherwise.
+ * When clips is empty the subject is returned unchanged.
+ */
+export declare const geoJsonPolygonDifference: (subject: GeoJsonPolygon | GeoJsonMultiPolygon, clips: ReadonlyArray<GeoJsonPolygon | GeoJsonMultiPolygon>) => GeoJsonPolygon | GeoJsonMultiPolygon | null;
+/**
+ * Project a `[lng, lat]` position to Web Mercator metres (EPSG:3857).
+ *
+ * Web map renderers (Google Maps, Mapbox, …) draw straight polygon edges in this
+ * projected space, not in planar lng/lat. Boolean geometry operations whose result
+ * must visually align with rendered edges therefore have to run in Web Mercator —
+ * see `unprojectWebMercatorToLngLat` for the inverse.
+ */
+export declare const projectLngLatToWebMercator: (position: GeoJsonPosition) => GeoJsonPosition;
+/** Inverse of `projectLngLatToWebMercator`: Web Mercator metres back to `[lng, lat]`. */
+export declare const unprojectWebMercatorToLngLat: (position: GeoJsonPosition) => GeoJsonPosition;
+/**
+ * Project a polygonal geometry's coordinates to Web Mercator metres, preserving its
+ * ring/part structure. The output is no longer valid lng/lat — feed it to operations
+ * such as `geoJsonPolygonDifference` and unproject the result with
+ * `unprojectPolygonalFromWebMercator`.
+ */
+export declare const projectPolygonalToWebMercator: (geometry: GeoJsonPolygon | GeoJsonMultiPolygon) => GeoJsonPolygon | GeoJsonMultiPolygon;
+/** Inverse of `projectPolygonalToWebMercator`. */
+export declare const unprojectPolygonalFromWebMercator: (geometry: GeoJsonPolygon | GeoJsonMultiPolygon) => GeoJsonPolygon | GeoJsonMultiPolygon;
+/**
+ * Generalisation of isFullyContainedInGeoJsonPolygon to Polygon|MultiPolygon arguments.
+ * Returns true when every outer-ring vertex of geom1 lies inside geom2 (holes respected).
+ * For a MultiPolygon geom2, "inside" means inside any one of its polygon members.
+ * Returns null if either geometry fails validation.
+ */
+export declare const isFullyContainedInGeoJsonGeometry: (geom1: GeoJsonPolygon | GeoJsonMultiPolygon, geom2: GeoJsonPolygon | GeoJsonMultiPolygon) => boolean | null;
+/**
+ * Returns the minimum distance (in coordinate units) from the given position to the
+ * nearest edge segment of any ring of the polygon/multipolygon, including hole rings.
+ * Returns null if the geometry fails validation.
+ *
+ * Distance is in geographic-coordinate units (degrees), appropriate for relative
+ * Penetration Depth comparisons where only ordering matters, not absolute metric values.
+ */
+export declare const distanceToGeoJsonPolygonBoundary: (position: GeoJsonPosition, geometry: GeoJsonPolygon | GeoJsonMultiPolygon) => number | null;