@trackunit/shared-utils 0.0.84 → 0.0.85

package/index.cjs.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var zod = require('zod');
+var polygonClipping = require('polygon-clipping');
 var uuid = require('uuid');
 
 /**
@@ -480,15 +481,6 @@ const geoJsonLinearRingSchema = zod.z
             message: "First and last coordinate positions must be identical (to close the linear ring aka polygon).",
         });
     }
-    // Check if any coordinate is (0, 0)
-    coords.forEach((coord, index) => {
-        if (coord[0] === 0 && coord[1] === 0) {
-            ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
-                message: `Coordinate at index ${index} should not be (0, 0). This is likely not a valid coordinate.`,
-            });
-        }
-    });
     // Check if consecutive points are identical (excluding first and last)
     for (let i = 1; i < coords.length - 1; i++) {
         if (JSON.stringify(coords[i]) === JSON.stringify(coords[i - 1])) {
@@ -536,59 +528,239 @@ const geoJsonBboxSchema = zod.z
     .refine(([minLng, minLat, maxLng, maxLat]) => maxLng > minLng && maxLat > minLat, {
     message: "Invalid bounding box: maxLng should be greater than minLng, and maxLat should be greater than minLat.",
 });
-//* -------- Extras -------- *//
+
+const EARTH_RADIUS = 6378137; // Earth’s mean radius in meters
 /**
- * Polygon geometry object that explicitly disallows holes.
- * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ * @description Creates a polygon (with no holes) from a bounding box.
  */
-const geoJsonPolygonNoHolesSchema = zod.z.strictObject({
-    type: zod.z.literal("Polygon"),
-    //uses tuple instead of array to enforce only 1 linear ring aka the polygon itself
-    coordinates: zod.z.tuple([geoJsonLinearRingSchema]),
-});
+const getPolygonFromBbox = (bbox) => {
+    const [minLon, minLat, maxLon, maxLat] = bbox;
+    return {
+        type: "Polygon",
+        coordinates: [
+            [
+                [minLon, minLat],
+                [maxLon, minLat],
+                [maxLon, maxLat],
+                [minLon, maxLat],
+                [minLon, minLat],
+            ],
+        ],
+    };
+};
 /**
- * A Polygon with exactly 5 points and 4 horizontal/vertical sides that form a normal rectangular box.
+ * @description Creates a bounding box from a GeoJSON Polygon.
  */
-const geoJsonRectangularBoxPolygonSchema = zod.z
-    .strictObject({
-    type: zod.z.literal("Polygon"),
-    coordinates: zod.z.array(geoJsonLinearRingSchema),
-})
-    .superRefine((data, ctx) => {
-    const coordinates = data.coordinates[0];
-    // Validate polygon has exactly 5 points
-    if ((coordinates === null || coordinates === void 0 ? void 0 : coordinates.length) !== 5) {
-        ctx.addIssue({
-            code: zod.z.ZodIssueCode.custom,
-            message: "Polygon must have exactly 5 coordinates to form a closed box.",
-        });
-        return;
+const getBboxFromGeoJsonPolygon = (polygon) => {
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
     }
-    // Check each side is either horizontal or vertical
-    for (let i = 0; i < 4; i++) {
-        const point1 = coordinates[i];
-        const point2 = coordinates[i + 1];
+    const points = polygonParsed.data.coordinates[0];
+    if (!points) {
+        // Should never happen since the schema checks for it
+        return null;
+    }
+    const latitudes = points.map(point => point[1]);
+    const longitudes = points.map(point => point[0]);
+    return [Math.min(...longitudes), Math.min(...latitudes), Math.max(...longitudes), Math.max(...latitudes)];
+};
+/**
+ * @description Creates a round polygon from a point and a radius.
+ */
+const getPolygonFromPointAndRadius = (point, radius) => {
+    const [lon, lat] = point.coordinates;
+    // Adjust the number of points based on radius (resolution)
+    const pointsCount = Math.max(32, Math.floor(radius / 100)); // More points for larger radius
+    const angleStep = (2 * Math.PI) / pointsCount;
+    const coordinates = [];
+    for (let i = 0; i <= pointsCount; i++) {
+        const angle = i * angleStep;
+        // Calculate offset in latitude and longitude
+        const deltaLat = (radius / EARTH_RADIUS) * (180 / Math.PI);
+        const deltaLon = deltaLat / Math.cos((lat * Math.PI) / 180);
+        // Calculate new coordinates based on angle
+        const newLat = lat + deltaLat * Math.sin(angle);
+        const newLon = lon + deltaLon * Math.cos(angle);
+        coordinates.push([newLon, newLat]);
+    }
+    return {
+        type: "Polygon",
+        coordinates: [coordinates],
+    };
+};
+/**
+ * @description Creates a TU bounding box from a GeoJson Polygon.
+ */
+const getBoundingBoxFromGeoJsonPolygon = (polygon) => {
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
+    }
+    const points = polygonParsed.data.coordinates[0];
+    if (!points) {
+        // Should never happen since the schema checks for it
+        return null;
+    }
+    const latitudes = points.map(point => point[1]);
+    const longitudes = points.map(point => point[0]);
+    return {
+        nw: {
+            latitude: Math.max(...latitudes),
+            longitude: Math.min(...longitudes),
+        },
+        se: {
+            latitude: Math.min(...latitudes),
+            longitude: Math.max(...longitudes),
+        },
+    };
+};
+/**
+ * @description Creates a GeoJSON Polygon from a TU bounding box.
+ */
+const getGeoJsonPolygonFromBoundingBox = (boundingBox) => {
+    const { nw, se } = boundingBox;
+    return {
+        type: "Polygon",
+        coordinates: [
+            [
+                [nw.longitude, nw.latitude], // Northwest corner
+                [se.longitude, nw.latitude], // Northeast corner
+                [se.longitude, se.latitude], // Southeast corner
+                [nw.longitude, se.latitude], // Southwest corner
+                [nw.longitude, nw.latitude], // Close the loop back to Northwest corner
+            ],
+        ],
+    };
+};
+/**
+ * @description Creates TU point coordinate from a GeoJSON Point.
+ */
+const getPointCoordinateFromGeoJsonPoint = (point) => {
+    return { latitude: point.coordinates[1], longitude: point.coordinates[0] };
+};
+/**
+ * @description Gets the extreme point of a polygon in a given direction.
+ * @param {object} params - The parameters object
+ * @param {GeoJsonPolygon} params.polygon - The polygon to get the extreme point from
+ * @param {("top" | "right" | "bottom" | "left")} params.direction - The direction to get the extreme point in
+ * @returns {GeoJsonPoint} The extreme point in the given direction
+ */
+const getExtremeGeoJsonPointFromPolygon = ({ polygon, direction, }) => {
+    var _a, _b, _c;
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
+    }
+    const firstPoint = (_a = polygonParsed.data.coordinates[0]) === null || _a === void 0 ? void 0 : _a[0];
+    if (!firstPoint) {
+        // Should never happen since the schema checks for it
+        return null;
+    }
+    const extremePosition = (_b = polygonParsed.data.coordinates[0]) === null || _b === void 0 ? void 0 : _b.reduce((extremePoint, currentPoint) => {
+        var _a, _b, _c, _d;
+        switch (direction) {
+            case "top":
+                return currentPoint[1] > ((_a = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[1]) !== null && _a !== void 0 ? _a : -Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            case "right":
+                return currentPoint[0] > ((_b = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[0]) !== null && _b !== void 0 ? _b : -Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            case "bottom":
+                return currentPoint[1] < ((_c = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[1]) !== null && _c !== void 0 ? _c : Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            case "left":
+                return currentPoint[0] < ((_d = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[0]) !== null && _d !== void 0 ? _d : Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            default: {
+                throw new Error(`${direction} is not known`);
+            }
+        }
+    }, (_c = polygonParsed.data.coordinates[0]) === null || _c === void 0 ? void 0 : _c[0]);
+    return extremePosition
+        ? {
+            type: "Point",
+            coordinates: extremePosition,
+        }
+        : null; // Should never happen since the schema checks for it
+};
+/**
+ * Checks if a position is inside a linear ring. On edge is considered inside.
+ */
+const isGeoJsonPositionInLinearRing = ({ position, linearRing, }) => {
+    const linearRingParsed = geoJsonLinearRingSchema.safeParse(linearRing);
+    if (!linearRingParsed.success) {
+        return null;
+    }
+    let inside = false;
+    const [x, y] = position;
+    for (let i = 0, j = linearRingParsed.data.length - 1; i < linearRingParsed.data.length; j = i++) {
+        const point1 = linearRingParsed.data[i];
+        const point2 = linearRingParsed.data[j];
         if (!point1 || !point2) {
-            ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
-                message: "Each coordinate must be a defined point.",
-            });
-            return;
+            continue;
         }
-        const [x1, y1] = point1;
-        const [x2, y2] = point2;
-        // Ensure each line segment is either horizontal or vertical
-        if (x1 !== x2 && y1 !== y2) {
-            ctx.addIssue({
-                code: zod.z.ZodIssueCode.custom,
-                message: "Polygon sides must be horizontal or vertical to form a box shape.",
-            });
-            return;
+        const [xi, yi] = point1;
+        const [xj, yj] = point2;
+        const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) {
+            inside = !inside;
         }
     }
-});
+    return inside;
+};
+/**
+ * @description Checks if a point is inside a polygon.
+ */
+const isGeoJsonPointInPolygon = ({ point, polygon, }) => {
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
+    }
+    return polygonParsed.data.coordinates.some(linearRing => isGeoJsonPositionInLinearRing({ position: point.coordinates, linearRing }));
+};
+/**
+ * Checks if polygon1 is fully contained within polygon2
+ */
+const isFullyContainedInGeoJsonPolygon = (polygon1, polygon2) => {
+    const polygon1Parsed = geoJsonPolygonSchema.safeParse(polygon1);
+    const polygon2Parsed = geoJsonPolygonSchema.safeParse(polygon2);
+    // The schema checks more than a TypeScript type can represent
+    if (!polygon1Parsed.success || !polygon2Parsed.success) {
+        return null;
+    }
+    return polygon1Parsed.data.coordinates.every(linearRing => polygon2Parsed.data.coordinates.some(lr => linearRing.every(position => isGeoJsonPositionInLinearRing({ position, linearRing: lr }))));
+};
+/**
+ * @description Gets the intersection between two GeoJSON polygons. If one polygon is fully contained within the other,
+ * returns the contained polygon. Otherwise returns a MultiPolygon representing the intersection.
+ * @param polygon1 The first polygon to check intersection
+ * @param polygon2 The second polygon to check intersection
+ * @returns {(GeoJsonMultiPolygon | GeoJsonPolygon)} The intersection as either a Polygon (if one contains the other) or MultiPolygon
+ */
+const getGeoJsonPolygonIntersection = (polygon1, polygon2) => {
+    const polygon1Parsed = geoJsonPolygonSchema.safeParse(polygon1);
+    const polygon2Parsed = geoJsonPolygonSchema.safeParse(polygon2);
+    if (!polygon1Parsed.success || !polygon2Parsed.success) {
+        return null;
+    }
+    if (isFullyContainedInGeoJsonPolygon(polygon1, polygon2)) {
+        return polygon1;
+    }
+    if (isFullyContainedInGeoJsonPolygon(polygon2, polygon1)) {
+        return polygon2;
+    }
+    const intersectionResult = polygonClipping.intersection(polygon1.coordinates, polygon2.coordinates);
+    if (intersectionResult.length === 1 && intersectionResult[0]) {
+        return {
+            type: "Polygon",
+            coordinates: intersectionResult[0],
+        };
+    }
+    return {
+        type: "MultiPolygon",
+        coordinates: polygonClipping.intersection(polygon1.coordinates, polygon2.coordinates),
+    };
+};
 
-const EARTH_RADIUS = 6378137; // Earth’s mean radius in meters
+//! 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
 const isDoubleNestedCoords = (coords) => Array.isArray(coords) &&
     Array.isArray(coords[0]) &&
     Array.isArray(coords[0][0]) &&
@@ -597,7 +769,7 @@ const isSingleCoords = (coords) => typeof coords[0] === "number";
 /**
  * @description Returns coordinates in consistent format
  * @param inconsistentCoordinates Single point, array of points or nested array of points
- * @returns GeoPoint[]
+ * @returns {GeoJsonPosition[]} Array of standardized coordinates
  */
 const coordinatesToStandardFormat = (inconsistentCoordinates) => {
     if (!inconsistentCoordinates) {
@@ -662,93 +834,73 @@ const getMultipleCoordinatesFromGeoJsonObject = (geoObject) => {
         throw new Error(`Unable to extract point coordinate from ${JSON.stringify(geoObject)}`);
     }
 };
+
+//* -------- Trackunit-invented schemas and types to extend the GeoJson spec -------- *//
 /**
- * @description Creates a polygon from a bounding box.
+ * Polygon geometry object that explicitly disallows holes.
+ *
+ * Same as geoJsonPolygonSchema but type disallows holes by
+ * using tuple of one single linear ring instead of an array.
  */
-const getPolygonFromBbox = (bbox) => {
-    const [minLon, minLat, maxLon, maxLat] = bbox;
-    return {
-        type: "Polygon",
-        coordinates: [
-            [
-                [minLon, minLat],
-                [maxLon, minLat],
-                [maxLon, maxLat],
-                [minLon, maxLat],
-                [minLon, minLat],
-            ],
-        ],
-    };
-};
+const tuGeoJsonPolygonNoHolesSchema = zod.z.strictObject({
+    //The type is still "Polygon" (not PolygonNoHoles or similar) since it's always
+    //compliant with Polygon, just not the other way around
+    type: zod.z.literal("Polygon"),
+    //uses tuple instead of array to enforce only 1 linear ring aka the polygon itself
+    coordinates: zod.z.tuple([geoJsonLinearRingSchema]),
+});
 /**
- * @description Creates a round polygon from a point and a radius.
+ * Point radius object.
+ * For when you wish to define an area by a point and a radius.
+ *
+ * radius is in meters
  */
-const getPolygonFromPointAndRadius = (point, radius) => {
-    const [lon, lat] = point.coordinates;
-    // Adjust the number of points based on radius (resolution)
-    const pointsCount = Math.max(32, Math.floor(radius / 100)); // More points for larger radius
-    const angleStep = (2 * Math.PI) / pointsCount;
-    const coordinates = [];
-    for (let i = 0; i <= pointsCount; i++) {
-        const angle = i * angleStep;
-        // Calculate offset in latitude and longitude
-        const deltaLat = (radius / EARTH_RADIUS) * (180 / Math.PI);
-        const deltaLon = deltaLat / Math.cos((lat * Math.PI) / 180);
-        // Calculate new coordinates based on angle
-        const newLat = lat + deltaLat * Math.sin(angle);
-        const newLon = lon + deltaLon * Math.cos(angle);
-        coordinates.push([newLon, newLat]);
-    }
-    return {
-        type: "Polygon",
-        coordinates: [coordinates],
-    };
-};
+const tuGeoJsonPointRadiusSchema = zod.z.strictObject({
+    type: zod.z.literal("PointRadius"),
+    coordinates: geoJsonPositionSchema,
+    radius: zod.z.number().positive(), // in meters
+});
 /**
- * @description Creates a TU bounding box from a GeoJson Polygon.
+ * A Polygon with exactly 5 points and 4 horizontal/vertical sides that form a normal rectangular box.
  */
-const getBoundingBoxFromGeoJsonPolygon = (polygon) => {
-    const points = polygon.coordinates[0];
-    const latitudes = points === null || points === void 0 ? void 0 : points.map(point => point[1]);
-    const longitudes = points === null || points === void 0 ? void 0 : points.map(point => point[0]);
-    if (!latitudes || !longitudes) {
-        return undefined;
+const tuGeoJsonRectangularBoxPolygonSchema = zod.z
+    .strictObject({
+    type: zod.z.literal("Polygon"),
+    coordinates: zod.z.array(geoJsonLinearRingSchema),
+})
+    .superRefine((data, ctx) => {
+    const coordinates = data.coordinates[0];
+    // Validate polygon has exactly 5 points
+    if ((coordinates === null || coordinates === void 0 ? void 0 : coordinates.length) !== 5) {
+        ctx.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            message: "Polygon must have exactly 5 coordinates to form a closed box.",
+        });
+        return;
     }
-    return {
-        nw: {
-            latitude: Math.max(...latitudes),
-            longitude: Math.min(...longitudes),
-        },
-        se: {
-            latitude: Math.min(...latitudes),
-            longitude: Math.max(...longitudes),
-        },
-    };
-};
-/**
- * @description Creates a GeoJSON Polygon from a TU bounding box.
- */
-const getGeoJsonPolygonFromBoundingBox = (boundingBox) => {
-    const { nw, se } = boundingBox;
-    return {
-        type: "Polygon",
-        coordinates: [
-            [
-                [nw.longitude, nw.latitude], // Northwest corner
-                [se.longitude, nw.latitude], // Northeast corner
-                [se.longitude, se.latitude], // Southeast corner
-                [nw.longitude, se.latitude], // Southwest corner
-                [nw.longitude, nw.latitude], // Close the loop back to Northwest corner
-            ],
-        ],
-    };
-};
-/**
- * @description Creates TU point coordinate from a GeoJSON Point.
- */
-const getPointCoordinateFromGeoJsonPoint = (point) => {
-    return { latitude: point.coordinates[1], longitude: point.coordinates[0] };
-};
+    // Check each side is either horizontal or vertical
+    for (let i = 0; i < 4; i++) {
+        const point1 = coordinates[i];
+        const point2 = coordinates[i + 1];
+        if (point1 === undefined || point2 === undefined) {
+            ctx.addIssue({
+                code: zod.z.ZodIssueCode.custom,
+                message: "Each coordinate must be a defined point.",
+            });
+            return;
+        }
+        const [x1, y1] = point1;
+        const [x2, y2] = point2;
+        // Ensure each line segment is either horizontal or vertical
+        if (x1 !== x2 && y1 !== y2) {
+            ctx.addIssue({
+                code: zod.z.ZodIssueCode.custom,
+                message: "Polygon sides must be horizontal or vertical to form a box shape.",
+            });
+            return;
+        }
+    }
+});
 
 /**
  * Group an array of items by a key.
@@ -1428,15 +1580,16 @@ exports.geoJsonMultiLineStringSchema = geoJsonMultiLineStringSchema;
 exports.geoJsonMultiPointSchema = geoJsonMultiPointSchema;
 exports.geoJsonMultiPolygonSchema = geoJsonMultiPolygonSchema;
 exports.geoJsonPointSchema = geoJsonPointSchema;
-exports.geoJsonPolygonNoHolesSchema = geoJsonPolygonNoHolesSchema;
 exports.geoJsonPolygonSchema = geoJsonPolygonSchema;
 exports.geoJsonPositionSchema = geoJsonPositionSchema;
-exports.geoJsonRectangularBoxPolygonSchema = geoJsonRectangularBoxPolygonSchema;
+exports.getBboxFromGeoJsonPolygon = getBboxFromGeoJsonPolygon;
 exports.getBoundingBoxFromGeoJsonPolygon = getBoundingBoxFromGeoJsonPolygon;
 exports.getDifferenceBetweenDates = getDifferenceBetweenDates;
 exports.getEndOfDay = getEndOfDay;
+exports.getExtremeGeoJsonPointFromPolygon = getExtremeGeoJsonPointFromPolygon;
 exports.getFirstLevelObjectPropertyDifferences = getFirstLevelObjectPropertyDifferences;
 exports.getGeoJsonPolygonFromBoundingBox = getGeoJsonPolygonFromBoundingBox;
+exports.getGeoJsonPolygonIntersection = getGeoJsonPolygonIntersection;
 exports.getISOStringFromDate = getISOStringFromDate;
 exports.getMultipleCoordinatesFromGeoJsonObject = getMultipleCoordinatesFromGeoJsonObject;
 exports.getPointCoordinateFromGeoJsonObject = getPointCoordinateFromGeoJsonObject;
@@ -1450,6 +1603,9 @@ exports.groupTinyDataToOthers = groupTinyDataToOthers;
 exports.hourIntervals = hourIntervals;
 exports.intersection = intersection;
 exports.isArrayEqual = isArrayEqual;
+exports.isFullyContainedInGeoJsonPolygon = isFullyContainedInGeoJsonPolygon;
+exports.isGeoJsonPointInPolygon = isGeoJsonPointInPolygon;
+exports.isGeoJsonPositionInLinearRing = isGeoJsonPositionInLinearRing;
 exports.isSorted = isSorted;
 exports.isUUID = isUUID;
 exports.isValidImage = isValidImage;
@@ -1477,6 +1633,9 @@ exports.toUUID = toUUID;
 exports.trimIds = trimIds;
 exports.trimPath = trimPath;
 exports.truthy = truthy;
+exports.tuGeoJsonPointRadiusSchema = tuGeoJsonPointRadiusSchema;
+exports.tuGeoJsonPolygonNoHolesSchema = tuGeoJsonPolygonNoHolesSchema;
+exports.tuGeoJsonRectangularBoxPolygonSchema = tuGeoJsonRectangularBoxPolygonSchema;
 exports.unionArraysByKey = unionArraysByKey;
 exports.uuidv3 = uuidv3;
 exports.uuidv4 = uuidv4;

package/index.esm.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { intersection as intersection$1 } from 'polygon-clipping';
 import { v3, v4, v5 } from 'uuid';
 
 /**
@@ -478,15 +479,6 @@ const geoJsonLinearRingSchema = z
             message: "First and last coordinate positions must be identical (to close the linear ring aka polygon).",
         });
     }
-    // Check if any coordinate is (0, 0)
-    coords.forEach((coord, index) => {
-        if (coord[0] === 0 && coord[1] === 0) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `Coordinate at index ${index} should not be (0, 0). This is likely not a valid coordinate.`,
-            });
-        }
-    });
     // Check if consecutive points are identical (excluding first and last)
     for (let i = 1; i < coords.length - 1; i++) {
         if (JSON.stringify(coords[i]) === JSON.stringify(coords[i - 1])) {
@@ -534,59 +526,239 @@ const geoJsonBboxSchema = z
     .refine(([minLng, minLat, maxLng, maxLat]) => maxLng > minLng && maxLat > minLat, {
     message: "Invalid bounding box: maxLng should be greater than minLng, and maxLat should be greater than minLat.",
 });
-//* -------- Extras -------- *//
+
+const EARTH_RADIUS = 6378137; // Earth’s mean radius in meters
 /**
- * Polygon geometry object that explicitly disallows holes.
- * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ * @description Creates a polygon (with no holes) from a bounding box.
  */
-const geoJsonPolygonNoHolesSchema = z.strictObject({
-    type: z.literal("Polygon"),
-    //uses tuple instead of array to enforce only 1 linear ring aka the polygon itself
-    coordinates: z.tuple([geoJsonLinearRingSchema]),
-});
+const getPolygonFromBbox = (bbox) => {
+    const [minLon, minLat, maxLon, maxLat] = bbox;
+    return {
+        type: "Polygon",
+        coordinates: [
+            [
+                [minLon, minLat],
+                [maxLon, minLat],
+                [maxLon, maxLat],
+                [minLon, maxLat],
+                [minLon, minLat],
+            ],
+        ],
+    };
+};
 /**
- * A Polygon with exactly 5 points and 4 horizontal/vertical sides that form a normal rectangular box.
+ * @description Creates a bounding box from a GeoJSON Polygon.
  */
-const geoJsonRectangularBoxPolygonSchema = z
-    .strictObject({
-    type: z.literal("Polygon"),
-    coordinates: z.array(geoJsonLinearRingSchema),
-})
-    .superRefine((data, ctx) => {
-    const coordinates = data.coordinates[0];
-    // Validate polygon has exactly 5 points
-    if ((coordinates === null || coordinates === void 0 ? void 0 : coordinates.length) !== 5) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Polygon must have exactly 5 coordinates to form a closed box.",
-        });
-        return;
+const getBboxFromGeoJsonPolygon = (polygon) => {
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
     }
-    // Check each side is either horizontal or vertical
-    for (let i = 0; i < 4; i++) {
-        const point1 = coordinates[i];
-        const point2 = coordinates[i + 1];
+    const points = polygonParsed.data.coordinates[0];
+    if (!points) {
+        // Should never happen since the schema checks for it
+        return null;
+    }
+    const latitudes = points.map(point => point[1]);
+    const longitudes = points.map(point => point[0]);
+    return [Math.min(...longitudes), Math.min(...latitudes), Math.max(...longitudes), Math.max(...latitudes)];
+};
+/**
+ * @description Creates a round polygon from a point and a radius.
+ */
+const getPolygonFromPointAndRadius = (point, radius) => {
+    const [lon, lat] = point.coordinates;
+    // Adjust the number of points based on radius (resolution)
+    const pointsCount = Math.max(32, Math.floor(radius / 100)); // More points for larger radius
+    const angleStep = (2 * Math.PI) / pointsCount;
+    const coordinates = [];
+    for (let i = 0; i <= pointsCount; i++) {
+        const angle = i * angleStep;
+        // Calculate offset in latitude and longitude
+        const deltaLat = (radius / EARTH_RADIUS) * (180 / Math.PI);
+        const deltaLon = deltaLat / Math.cos((lat * Math.PI) / 180);
+        // Calculate new coordinates based on angle
+        const newLat = lat + deltaLat * Math.sin(angle);
+        const newLon = lon + deltaLon * Math.cos(angle);
+        coordinates.push([newLon, newLat]);
+    }
+    return {
+        type: "Polygon",
+        coordinates: [coordinates],
+    };
+};
+/**
+ * @description Creates a TU bounding box from a GeoJson Polygon.
+ */
+const getBoundingBoxFromGeoJsonPolygon = (polygon) => {
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
+    }
+    const points = polygonParsed.data.coordinates[0];
+    if (!points) {
+        // Should never happen since the schema checks for it
+        return null;
+    }
+    const latitudes = points.map(point => point[1]);
+    const longitudes = points.map(point => point[0]);
+    return {
+        nw: {
+            latitude: Math.max(...latitudes),
+            longitude: Math.min(...longitudes),
+        },
+        se: {
+            latitude: Math.min(...latitudes),
+            longitude: Math.max(...longitudes),
+        },
+    };
+};
+/**
+ * @description Creates a GeoJSON Polygon from a TU bounding box.
+ */
+const getGeoJsonPolygonFromBoundingBox = (boundingBox) => {
+    const { nw, se } = boundingBox;
+    return {
+        type: "Polygon",
+        coordinates: [
+            [
+                [nw.longitude, nw.latitude], // Northwest corner
+                [se.longitude, nw.latitude], // Northeast corner
+                [se.longitude, se.latitude], // Southeast corner
+                [nw.longitude, se.latitude], // Southwest corner
+                [nw.longitude, nw.latitude], // Close the loop back to Northwest corner
+            ],
+        ],
+    };
+};
+/**
+ * @description Creates TU point coordinate from a GeoJSON Point.
+ */
+const getPointCoordinateFromGeoJsonPoint = (point) => {
+    return { latitude: point.coordinates[1], longitude: point.coordinates[0] };
+};
+/**
+ * @description Gets the extreme point of a polygon in a given direction.
+ * @param {object} params - The parameters object
+ * @param {GeoJsonPolygon} params.polygon - The polygon to get the extreme point from
+ * @param {("top" | "right" | "bottom" | "left")} params.direction - The direction to get the extreme point in
+ * @returns {GeoJsonPoint} The extreme point in the given direction
+ */
+const getExtremeGeoJsonPointFromPolygon = ({ polygon, direction, }) => {
+    var _a, _b, _c;
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
+    }
+    const firstPoint = (_a = polygonParsed.data.coordinates[0]) === null || _a === void 0 ? void 0 : _a[0];
+    if (!firstPoint) {
+        // Should never happen since the schema checks for it
+        return null;
+    }
+    const extremePosition = (_b = polygonParsed.data.coordinates[0]) === null || _b === void 0 ? void 0 : _b.reduce((extremePoint, currentPoint) => {
+        var _a, _b, _c, _d;
+        switch (direction) {
+            case "top":
+                return currentPoint[1] > ((_a = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[1]) !== null && _a !== void 0 ? _a : -Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            case "right":
+                return currentPoint[0] > ((_b = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[0]) !== null && _b !== void 0 ? _b : -Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            case "bottom":
+                return currentPoint[1] < ((_c = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[1]) !== null && _c !== void 0 ? _c : Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            case "left":
+                return currentPoint[0] < ((_d = extremePoint === null || extremePoint === void 0 ? void 0 : extremePoint[0]) !== null && _d !== void 0 ? _d : Infinity) ? currentPoint : extremePoint !== null && extremePoint !== void 0 ? extremePoint : currentPoint;
+            default: {
+                throw new Error(`${direction} is not known`);
+            }
+        }
+    }, (_c = polygonParsed.data.coordinates[0]) === null || _c === void 0 ? void 0 : _c[0]);
+    return extremePosition
+        ? {
+            type: "Point",
+            coordinates: extremePosition,
+        }
+        : null; // Should never happen since the schema checks for it
+};
+/**
+ * Checks if a position is inside a linear ring. On edge is considered inside.
+ */
+const isGeoJsonPositionInLinearRing = ({ position, linearRing, }) => {
+    const linearRingParsed = geoJsonLinearRingSchema.safeParse(linearRing);
+    if (!linearRingParsed.success) {
+        return null;
+    }
+    let inside = false;
+    const [x, y] = position;
+    for (let i = 0, j = linearRingParsed.data.length - 1; i < linearRingParsed.data.length; j = i++) {
+        const point1 = linearRingParsed.data[i];
+        const point2 = linearRingParsed.data[j];
         if (!point1 || !point2) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "Each coordinate must be a defined point.",
-            });
-            return;
+            continue;
         }
-        const [x1, y1] = point1;
-        const [x2, y2] = point2;
-        // Ensure each line segment is either horizontal or vertical
-        if (x1 !== x2 && y1 !== y2) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "Polygon sides must be horizontal or vertical to form a box shape.",
-            });
-            return;
+        const [xi, yi] = point1;
+        const [xj, yj] = point2;
+        const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) {
+            inside = !inside;
         }
     }
-});
+    return inside;
+};
+/**
+ * @description Checks if a point is inside a polygon.
+ */
+const isGeoJsonPointInPolygon = ({ point, polygon, }) => {
+    const polygonParsed = geoJsonPolygonSchema.safeParse(polygon);
+    if (!polygonParsed.success) {
+        return null;
+    }
+    return polygonParsed.data.coordinates.some(linearRing => isGeoJsonPositionInLinearRing({ position: point.coordinates, linearRing }));
+};
+/**
+ * Checks if polygon1 is fully contained within polygon2
+ */
+const isFullyContainedInGeoJsonPolygon = (polygon1, polygon2) => {
+    const polygon1Parsed = geoJsonPolygonSchema.safeParse(polygon1);
+    const polygon2Parsed = geoJsonPolygonSchema.safeParse(polygon2);
+    // The schema checks more than a TypeScript type can represent
+    if (!polygon1Parsed.success || !polygon2Parsed.success) {
+        return null;
+    }
+    return polygon1Parsed.data.coordinates.every(linearRing => polygon2Parsed.data.coordinates.some(lr => linearRing.every(position => isGeoJsonPositionInLinearRing({ position, linearRing: lr }))));
+};
+/**
+ * @description Gets the intersection between two GeoJSON polygons. If one polygon is fully contained within the other,
+ * returns the contained polygon. Otherwise returns a MultiPolygon representing the intersection.
+ * @param polygon1 The first polygon to check intersection
+ * @param polygon2 The second polygon to check intersection
+ * @returns {(GeoJsonMultiPolygon | GeoJsonPolygon)} The intersection as either a Polygon (if one contains the other) or MultiPolygon
+ */
+const getGeoJsonPolygonIntersection = (polygon1, polygon2) => {
+    const polygon1Parsed = geoJsonPolygonSchema.safeParse(polygon1);
+    const polygon2Parsed = geoJsonPolygonSchema.safeParse(polygon2);
+    if (!polygon1Parsed.success || !polygon2Parsed.success) {
+        return null;
+    }
+    if (isFullyContainedInGeoJsonPolygon(polygon1, polygon2)) {
+        return polygon1;
+    }
+    if (isFullyContainedInGeoJsonPolygon(polygon2, polygon1)) {
+        return polygon2;
+    }
+    const intersectionResult = intersection$1(polygon1.coordinates, polygon2.coordinates);
+    if (intersectionResult.length === 1 && intersectionResult[0]) {
+        return {
+            type: "Polygon",
+            coordinates: intersectionResult[0],
+        };
+    }
+    return {
+        type: "MultiPolygon",
+        coordinates: intersection$1(polygon1.coordinates, polygon2.coordinates),
+    };
+};
 
-const EARTH_RADIUS = 6378137; // Earth’s mean radius in meters
+//! 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
 const isDoubleNestedCoords = (coords) => Array.isArray(coords) &&
     Array.isArray(coords[0]) &&
     Array.isArray(coords[0][0]) &&
@@ -595,7 +767,7 @@ const isSingleCoords = (coords) => typeof coords[0] === "number";
 /**
  * @description Returns coordinates in consistent format
  * @param inconsistentCoordinates Single point, array of points or nested array of points
- * @returns GeoPoint[]
+ * @returns {GeoJsonPosition[]} Array of standardized coordinates
  */
 const coordinatesToStandardFormat = (inconsistentCoordinates) => {
     if (!inconsistentCoordinates) {
@@ -660,93 +832,73 @@ const getMultipleCoordinatesFromGeoJsonObject = (geoObject) => {
         throw new Error(`Unable to extract point coordinate from ${JSON.stringify(geoObject)}`);
     }
 };
+
+//* -------- Trackunit-invented schemas and types to extend the GeoJson spec -------- *//
 /**
- * @description Creates a polygon from a bounding box.
+ * Polygon geometry object that explicitly disallows holes.
+ *
+ * Same as geoJsonPolygonSchema but type disallows holes by
+ * using tuple of one single linear ring instead of an array.
  */
-const getPolygonFromBbox = (bbox) => {
-    const [minLon, minLat, maxLon, maxLat] = bbox;
-    return {
-        type: "Polygon",
-        coordinates: [
-            [
-                [minLon, minLat],
-                [maxLon, minLat],
-                [maxLon, maxLat],
-                [minLon, maxLat],
-                [minLon, minLat],
-            ],
-        ],
-    };
-};
+const tuGeoJsonPolygonNoHolesSchema = z.strictObject({
+    //The type is still "Polygon" (not PolygonNoHoles or similar) since it's always
+    //compliant with Polygon, just not the other way around
+    type: z.literal("Polygon"),
+    //uses tuple instead of array to enforce only 1 linear ring aka the polygon itself
+    coordinates: z.tuple([geoJsonLinearRingSchema]),
+});
 /**
- * @description Creates a round polygon from a point and a radius.
+ * Point radius object.
+ * For when you wish to define an area by a point and a radius.
+ *
+ * radius is in meters
  */
-const getPolygonFromPointAndRadius = (point, radius) => {
-    const [lon, lat] = point.coordinates;
-    // Adjust the number of points based on radius (resolution)
-    const pointsCount = Math.max(32, Math.floor(radius / 100)); // More points for larger radius
-    const angleStep = (2 * Math.PI) / pointsCount;
-    const coordinates = [];
-    for (let i = 0; i <= pointsCount; i++) {
-        const angle = i * angleStep;
-        // Calculate offset in latitude and longitude
-        const deltaLat = (radius / EARTH_RADIUS) * (180 / Math.PI);
-        const deltaLon = deltaLat / Math.cos((lat * Math.PI) / 180);
-        // Calculate new coordinates based on angle
-        const newLat = lat + deltaLat * Math.sin(angle);
-        const newLon = lon + deltaLon * Math.cos(angle);
-        coordinates.push([newLon, newLat]);
-    }
-    return {
-        type: "Polygon",
-        coordinates: [coordinates],
-    };
-};
+const tuGeoJsonPointRadiusSchema = z.strictObject({
+    type: z.literal("PointRadius"),
+    coordinates: geoJsonPositionSchema,
+    radius: z.number().positive(), // in meters
+});
 /**
- * @description Creates a TU bounding box from a GeoJson Polygon.
+ * A Polygon with exactly 5 points and 4 horizontal/vertical sides that form a normal rectangular box.
  */
-const getBoundingBoxFromGeoJsonPolygon = (polygon) => {
-    const points = polygon.coordinates[0];
-    const latitudes = points === null || points === void 0 ? void 0 : points.map(point => point[1]);
-    const longitudes = points === null || points === void 0 ? void 0 : points.map(point => point[0]);
-    if (!latitudes || !longitudes) {
-        return undefined;
+const tuGeoJsonRectangularBoxPolygonSchema = z
+    .strictObject({
+    type: z.literal("Polygon"),
+    coordinates: z.array(geoJsonLinearRingSchema),
+})
+    .superRefine((data, ctx) => {
+    const coordinates = data.coordinates[0];
+    // Validate polygon has exactly 5 points
+    if ((coordinates === null || coordinates === void 0 ? void 0 : coordinates.length) !== 5) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Polygon must have exactly 5 coordinates to form a closed box.",
+        });
+        return;
     }
-    return {
-        nw: {
-            latitude: Math.max(...latitudes),
-            longitude: Math.min(...longitudes),
-        },
-        se: {
-            latitude: Math.min(...latitudes),
-            longitude: Math.max(...longitudes),
-        },
-    };
-};
-/**
- * @description Creates a GeoJSON Polygon from a TU bounding box.
- */
-const getGeoJsonPolygonFromBoundingBox = (boundingBox) => {
-    const { nw, se } = boundingBox;
-    return {
-        type: "Polygon",
-        coordinates: [
-            [
-                [nw.longitude, nw.latitude], // Northwest corner
-                [se.longitude, nw.latitude], // Northeast corner
-                [se.longitude, se.latitude], // Southeast corner
-                [nw.longitude, se.latitude], // Southwest corner
-                [nw.longitude, nw.latitude], // Close the loop back to Northwest corner
-            ],
-        ],
-    };
-};
-/**
- * @description Creates TU point coordinate from a GeoJSON Point.
- */
-const getPointCoordinateFromGeoJsonPoint = (point) => {
-    return { latitude: point.coordinates[1], longitude: point.coordinates[0] };
-};
+    // Check each side is either horizontal or vertical
+    for (let i = 0; i < 4; i++) {
+        const point1 = coordinates[i];
+        const point2 = coordinates[i + 1];
+        if (point1 === undefined || point2 === undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "Each coordinate must be a defined point.",
+            });
+            return;
+        }
+        const [x1, y1] = point1;
+        const [x2, y2] = point2;
+        // Ensure each line segment is either horizontal or vertical
+        if (x1 !== x2 && y1 !== y2) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "Polygon sides must be horizontal or vertical to form a box shape.",
+            });
+            return;
+        }
+    }
+});
 
 /**
  * Group an array of items by a key.
@@ -1394,4 +1546,4 @@ const uuidv4 = () => {
  */
 const uuidv5 = (name, namespace) => v5(name, namespace);
 
-export { DateTimeFormat, EARTH_RADIUS, HoursAndMinutesFormat, align, alphabeticallySort, arrayLengthCompare, arrayNotEmpty, booleanCompare, capitalize, convertBlobToBase64, convertMetersToYards, convertYardsToMeters, coordinatesToStandardFormat, dateCompare, deleteUndefinedKeys, difference, doNothing, enumFromValue, enumFromValueTypesafe, enumOrUndefinedFromValue, exhaustiveCheck, filterByMultiple, formatAddress, formatCoordinates, fuzzySearch, geoJsonBboxSchema, geoJsonGeometrySchema, geoJsonLineStringSchema, geoJsonLinearRingSchema, geoJsonMultiLineStringSchema, geoJsonMultiPointSchema, geoJsonMultiPolygonSchema, geoJsonPointSchema, geoJsonPolygonNoHolesSchema, geoJsonPolygonSchema, geoJsonPositionSchema, geoJsonRectangularBoxPolygonSchema, getBoundingBoxFromGeoJsonPolygon, getDifferenceBetweenDates, getEndOfDay, getFirstLevelObjectPropertyDifferences, getGeoJsonPolygonFromBoundingBox, getISOStringFromDate, getMultipleCoordinatesFromGeoJsonObject, getPointCoordinateFromGeoJsonObject, getPointCoordinateFromGeoJsonPoint, getPolygonFromBbox, getPolygonFromPointAndRadius, getResizedDimensions, getStartOfDay, groupBy, groupTinyDataToOthers, hourIntervals, intersection, isArrayEqual, isSorted, isUUID, isValidImage, nonNullable, numberCompare, numberCompareUnknownAfterHighest, objNotEmpty, objectEntries, objectFromEntries, objectKeys, objectValues, pick, removeLeftPadding, resizeBlob, resizeImage, size, stringCompare, stringCompareFromKey, stringNaturalCompare, stripHiddenCharacters, titleCase, toID, toIDs, toUUID, trimIds, trimPath, truthy, unionArraysByKey, uuidv3, uuidv4, uuidv5 };
+export { DateTimeFormat, EARTH_RADIUS, HoursAndMinutesFormat, align, alphabeticallySort, arrayLengthCompare, arrayNotEmpty, booleanCompare, capitalize, convertBlobToBase64, convertMetersToYards, convertYardsToMeters, coordinatesToStandardFormat, dateCompare, deleteUndefinedKeys, difference, doNothing, enumFromValue, enumFromValueTypesafe, enumOrUndefinedFromValue, exhaustiveCheck, filterByMultiple, formatAddress, formatCoordinates, fuzzySearch, geoJsonBboxSchema, geoJsonGeometrySchema, geoJsonLineStringSchema, geoJsonLinearRingSchema, geoJsonMultiLineStringSchema, geoJsonMultiPointSchema, geoJsonMultiPolygonSchema, geoJsonPointSchema, geoJsonPolygonSchema, geoJsonPositionSchema, getBboxFromGeoJsonPolygon, getBoundingBoxFromGeoJsonPolygon, getDifferenceBetweenDates, getEndOfDay, getExtremeGeoJsonPointFromPolygon, getFirstLevelObjectPropertyDifferences, getGeoJsonPolygonFromBoundingBox, getGeoJsonPolygonIntersection, getISOStringFromDate, getMultipleCoordinatesFromGeoJsonObject, getPointCoordinateFromGeoJsonObject, getPointCoordinateFromGeoJsonPoint, getPolygonFromBbox, getPolygonFromPointAndRadius, getResizedDimensions, getStartOfDay, groupBy, groupTinyDataToOthers, hourIntervals, intersection, isArrayEqual, isFullyContainedInGeoJsonPolygon, isGeoJsonPointInPolygon, isGeoJsonPositionInLinearRing, isSorted, isUUID, isValidImage, nonNullable, numberCompare, numberCompareUnknownAfterHighest, objNotEmpty, objectEntries, objectFromEntries, objectKeys, objectValues, pick, removeLeftPadding, resizeBlob, resizeImage, size, stringCompare, stringCompareFromKey, stringNaturalCompare, stripHiddenCharacters, titleCase, toID, toIDs, toUUID, trimIds, trimPath, truthy, tuGeoJsonPointRadiusSchema, tuGeoJsonPolygonNoHolesSchema, tuGeoJsonRectangularBoxPolygonSchema, unionArraysByKey, uuidv3, uuidv4, uuidv5 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/shared-utils",
-  "version": "0.0.84",
+  "version": "0.0.85",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {
@@ -8,7 +8,8 @@
   },
   "dependencies": {
     "uuid": "^10.0.0",
-    "zod": "3.22.4"
+    "zod": "3.22.4",
+    "polygon-clipping": "^0.15.7"
   },
   "module": "./index.esm.js",
   "main": "./index.cjs.js",

package/src/GeoJson/GeoJsonSchemas.d.ts

@@ -174,37 +174,3 @@ export type GeoJsonGeometry = z.infer<typeof geoJsonGeometrySchema>;
  */
 export declare const geoJsonBboxSchema: z.ZodEffects<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, [number, number, number, number], [number, number, number, number]>;
 export type GeoJsonBbox = z.infer<typeof geoJsonBboxSchema>;
-/**
- * Polygon geometry object that explicitly disallows holes.
- * https://tools.ietf.org/html/rfc7946#section-3.1.6
- */
-export declare const geoJsonPolygonNoHolesSchema: z.ZodObject<{
-    type: z.ZodLiteral<"Polygon">;
-    coordinates: z.ZodTuple<[z.ZodEffects<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, [number, number][], [number, number][]>], null>;
-}, "strict", z.ZodTypeAny, {
-    type: "Polygon";
-    coordinates: [[number, number][]];
-}, {
-    type: "Polygon";
-    coordinates: [[number, number][]];
-}>;
-export type GeoJsonPolygonNoHoles = z.infer<typeof geoJsonPolygonNoHolesSchema>;
-/**
- * A Polygon with exactly 5 points and 4 horizontal/vertical sides that form a normal rectangular box.
- */
-export declare const geoJsonRectangularBoxPolygonSchema: z.ZodEffects<z.ZodObject<{
-    type: z.ZodLiteral<"Polygon">;
-    coordinates: z.ZodArray<z.ZodEffects<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, [number, number][], [number, number][]>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "Polygon";
-    coordinates: [number, number][][];
-}, {
-    type: "Polygon";
-    coordinates: [number, number][][];
-}>, {
-    type: "Polygon";
-    coordinates: [number, number][][];
-}, {
-    type: "Polygon";
-    coordinates: [number, number][][];
-}>;

package/src/GeoJson/GeoJsonUtils.d.ts

@@ -1,4 +1,5 @@
-import { GeoJsonBbox, GeoJsonPoint, GeoJsonPolygon } from "./GeoJsonSchemas";
+import { GeoJsonBbox, GeoJsonLinearRing, GeoJsonMultiPolygon, GeoJsonPoint, GeoJsonPolygon, GeoJsonPosition } from "./GeoJsonSchemas";
+import { TuGeoJsonPolygonNoHoles } from "./TuGeoJsonSchemas";
 export declare const EARTH_RADIUS = 6378137;
 interface PointCoordinate {
     longitude: number;
@@ -8,38 +9,14 @@ interface BoundingBox {
     nw: PointCoordinate;
     se: PointCoordinate;
 }
-export type GeoPoint = [number, number];
-interface GeoJSONGeometry {
-    type?: unknown;
-    coordinates?: GeoPoint | GeoPoint[] | GeoPoint[][] | null;
-}
-interface GeoJsonFeature {
-    type?: unknown;
-    geometry?: GeoJSONGeometry | null;
-}
-/**
- * @description Returns coordinates in consistent format
- * @param inconsistentCoordinates Single point, array of points or nested array of points
- * @returns GeoPoint[]
- */
-export declare const coordinatesToStandardFormat: (inconsistentCoordinates: GeoPoint | GeoPoint[] | GeoPoint[][] | null | undefined) => GeoPoint[];
 /**
- * @description Extracts a point coordinate from a GeoJSON object.
- * @param geoObject A GeoJSON object.
- * @returns {PointCoordinate} A point coordinate.
+ * @description Creates a polygon (with no holes) from a bounding box.
  */
-export declare const getPointCoordinateFromGeoJsonObject: (geoObject: GeoJsonFeature | GeoJSONGeometry | undefined | null) => PointCoordinate | undefined;
+export declare const getPolygonFromBbox: (bbox: GeoJsonBbox) => TuGeoJsonPolygonNoHoles;
 /**
- * @description Extracts multiple point coordinates from a GeoJSON object.
- * @param geoObject A GeoJSON object.
- * @returns {PointCoordinate[]} An array of point coordinates.
- * @example getMultipleCoordinatesFromGeoJsonObject({ type: "Point", coordinates: [1, 2] }) // [{ longitude: 1, latitude: 2 }]
+ * @description Creates a bounding box from a GeoJSON Polygon.
  */
-export declare const getMultipleCoordinatesFromGeoJsonObject: (geoObject: GeoJsonFeature | GeoJSONGeometry | undefined | null) => PointCoordinate[] | undefined;
-/**
- * @description Creates a polygon from a bounding box.
- */
-export declare const getPolygonFromBbox: (bbox: GeoJsonBbox) => GeoJsonPolygon;
+export declare const getBboxFromGeoJsonPolygon: (polygon: GeoJsonPolygon) => GeoJsonBbox | null;
 /**
  * @description Creates a round polygon from a point and a radius.
  */
@@ -47,7 +24,7 @@ export declare const getPolygonFromPointAndRadius: (point: GeoJsonPoint, radius:
 /**
  * @description Creates a TU bounding box from a GeoJson Polygon.
  */
-export declare const getBoundingBoxFromGeoJsonPolygon: (polygon: GeoJsonPolygon) => BoundingBox | undefined;
+export declare const getBoundingBoxFromGeoJsonPolygon: (polygon: GeoJsonPolygon) => BoundingBox | null;
 /**
  * @description Creates a GeoJSON Polygon from a TU bounding box.
  */
@@ -56,4 +33,41 @@ export declare const getGeoJsonPolygonFromBoundingBox: (boundingBox: BoundingBox
  * @description Creates TU point coordinate from a GeoJSON Point.
  */
 export declare const getPointCoordinateFromGeoJsonPoint: (point: GeoJsonPoint) => PointCoordinate;
+/**
+ * @description Gets the extreme point of a polygon in a given direction.
+ * @param {object} params - The parameters object
+ * @param {GeoJsonPolygon} params.polygon - The polygon to get the extreme point from
+ * @param {("top" | "right" | "bottom" | "left")} params.direction - The direction to get the extreme point in
+ * @returns {GeoJsonPoint} The extreme point in the given direction
+ */
+export declare const getExtremeGeoJsonPointFromPolygon: ({ polygon, direction, }: {
+    polygon: GeoJsonPolygon;
+    direction: "top" | "right" | "bottom" | "left";
+}) => GeoJsonPoint | null;
+/**
+ * Checks if a position is inside a linear ring. On edge is considered inside.
+ */
+export declare const isGeoJsonPositionInLinearRing: ({ position, linearRing, }: {
+    position: GeoJsonPosition;
+    linearRing: GeoJsonLinearRing;
+}) => boolean | null;
+/**
+ * @description Checks if a point is inside a polygon.
+ */
+export declare const isGeoJsonPointInPolygon: ({ point, polygon, }: {
+    point: GeoJsonPoint;
+    polygon: GeoJsonPolygon;
+}) => boolean | null;
+/**
+ * Checks if polygon1 is fully contained within polygon2
+ */
+export declare const isFullyContainedInGeoJsonPolygon: (polygon1: GeoJsonPolygon, polygon2: GeoJsonPolygon) => boolean | null;
+/**
+ * @description Gets the intersection between two GeoJSON polygons. If one polygon is fully contained within the other,
+ * returns the contained polygon. Otherwise returns a MultiPolygon representing the intersection.
+ * @param polygon1 The first polygon to check intersection
+ * @param polygon2 The second polygon to check intersection
+ * @returns {(GeoJsonMultiPolygon | GeoJsonPolygon)} The intersection as either a Polygon (if one contains the other) or MultiPolygon
+ */
+export declare const getGeoJsonPolygonIntersection: (polygon1: GeoJsonPolygon, polygon2: GeoJsonPolygon) => GeoJsonMultiPolygon | GeoJsonPolygon | null;
 export {};

package/src/GeoJson/TUGeoJsonObjectBridgeUtils.d.ts

@@ -0,0 +1,33 @@
+import { GeoJsonPosition } from "./GeoJsonSchemas";
+interface PointCoordinate {
+    longitude: number;
+    latitude: number;
+}
+interface GeoJSONGeometry {
+    type?: unknown;
+    coordinates?: GeoJsonPosition | GeoJsonPosition[] | GeoJsonPosition[][] | null;
+}
+interface GeoJsonFeature {
+    type?: unknown;
+    geometry?: GeoJSONGeometry | null;
+}
+/**
+ * @description Returns coordinates in consistent format
+ * @param inconsistentCoordinates Single point, array of points or nested array of points
+ * @returns {GeoJsonPosition[]} Array of standardized coordinates
+ */
+export declare const coordinatesToStandardFormat: (inconsistentCoordinates: GeoJsonPosition | GeoJsonPosition[] | GeoJsonPosition[][] | null | undefined) => [number, number][];
+/**
+ * @description Extracts a point coordinate from a GeoJSON object.
+ * @param geoObject A GeoJSON object.
+ * @returns {PointCoordinate} A point coordinate.
+ */
+export declare const getPointCoordinateFromGeoJsonObject: (geoObject: GeoJsonFeature | GeoJSONGeometry | undefined | null) => PointCoordinate | undefined;
+/**
+ * @description Extracts multiple point coordinates from a GeoJSON object.
+ * @param geoObject A GeoJSON object.
+ * @returns {PointCoordinate[]} An array of point coordinates.
+ * @example getMultipleCoordinatesFromGeoJsonObject({ type: "Point", coordinates: [1, 2] }) // [{ longitude: 1, latitude: 2 }]
+ */
+export declare const getMultipleCoordinatesFromGeoJsonObject: (geoObject: GeoJsonFeature | GeoJSONGeometry | undefined | null) => PointCoordinate[] | undefined;
+export {};

package/src/GeoJson/TuGeoJsonSchemas.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+/**
+ * Polygon geometry object that explicitly disallows holes.
+ *
+ * Same as geoJsonPolygonSchema but type disallows holes by
+ * using tuple of one single linear ring instead of an array.
+ */
+export declare const tuGeoJsonPolygonNoHolesSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodTuple<[z.ZodEffects<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, [number, number][], [number, number][]>], null>;
+}, "strict", z.ZodTypeAny, {
+    type: "Polygon";
+    coordinates: [[number, number][]];
+}, {
+    type: "Polygon";
+    coordinates: [[number, number][]];
+}>;
+export type TuGeoJsonPolygonNoHoles = z.infer<typeof tuGeoJsonPolygonNoHolesSchema>;
+/**
+ * Point radius object.
+ * For when you wish to define an area by a point and a radius.
+ *
+ * radius is in meters
+ */
+export declare const tuGeoJsonPointRadiusSchema: z.ZodObject<{
+    type: z.ZodLiteral<"PointRadius">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    radius: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    type: "PointRadius";
+    coordinates: [number, number];
+    radius: number;
+}, {
+    type: "PointRadius";
+    coordinates: [number, number];
+    radius: number;
+}>;
+export type TuGeoJsonPointRadius = z.infer<typeof tuGeoJsonPointRadiusSchema>;
+/**
+ * A Polygon with exactly 5 points and 4 horizontal/vertical sides that form a normal rectangular box.
+ */
+export declare const tuGeoJsonRectangularBoxPolygonSchema: z.ZodEffects<z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodEffects<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, [number, number][], [number, number][]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}>, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}>;
+export type TuGeoJsonRectangularBoxPolygon = z.infer<typeof tuGeoJsonRectangularBoxPolygonSchema>;

package/src/index.d.ts

@@ -11,6 +11,8 @@ export * from "./fastArrayOperations";
 export * from "./filter";
 export * from "./GeoJson/GeoJsonSchemas";
 export * from "./GeoJson/GeoJsonUtils";
+export * from "./GeoJson/TUGeoJsonObjectBridgeUtils";
+export * from "./GeoJson/TuGeoJsonSchemas";
 export * from "./groupBy/groupBy";
 export * from "./GroupingUtility";
 export * from "./idUtils";