bruce-models 4.6.5 → 4.6.7

package/dist/bruce-models.es5.js

@@ -2208,129 +2208,6 @@ var Color;
     Color.ColorFromStr = ColorFromStr;
 })(Color || (Color = {}));
 
-/**
- * Describes vector geometry that Bruce uses.
- */
-var Geometry;
-(function (Geometry) {
-    let EPolygonRingType;
-    (function (EPolygonRingType) {
-        EPolygonRingType["Boundaries"] = "out";
-        EPolygonRingType["Hole"] = "in";
-    })(EPolygonRingType = Geometry.EPolygonRingType || (Geometry.EPolygonRingType = {}));
-    /**
-     * Turns an array of points into string vector geometry that Bruce can use.
-     * This is used for saving polyline and polygon data.
-     * @param points
-     * @returns
-     */
-    function LineStrFromPoints(points) {
-        if (!points.length) {
-            throw ("points is empty.");
-        }
-        let carto = points[0];
-        let lineString = `${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
-        for (let i = 1; i < points.length; i++) {
-            carto = points[i];
-            lineString += ` ${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
-        }
-        return lineString;
-    }
-    Geometry.LineStrFromPoints = LineStrFromPoints;
-    /**
-     * Removes same points that occur in a row.
-     * This will not modify the original array.
-     * @param positions
-     * @returns
-     */
-    function RemoveRepeatPoints(positions) {
-        const filteredList = [];
-        for (let i = 0; i < positions.length; i++) {
-            const pos = positions[i];
-            const lastPos = filteredList.length > 0 ? filteredList[filteredList.length - 1] : null;
-            if (!lastPos || (pos.latitude != lastPos.latitude || pos.longitude != lastPos.longitude || pos.altitude != lastPos.altitude)) {
-                filteredList.push(pos);
-            }
-        }
-        return filteredList;
-    }
-    Geometry.RemoveRepeatPoints = RemoveRepeatPoints;
-    /**
-     * Parses a string of points into an array of points.
-     * @param pointsStr
-     * @returns
-     */
-    function ParsePoints(pointsStr) {
-        pointsStr = pointsStr.replace(/[^\d.,-\s]/g, "");
-        let splitterCoordinates = " ";
-        let splitterAxis = ",";
-        const commaIndex = pointsStr.indexOf(",");
-        const spaceIndex = pointsStr.indexOf(" ");
-        if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
-            splitterCoordinates = ",";
-            splitterAxis = " ";
-        }
-        let points = pointsStr.trim().split(splitterCoordinates);
-        points = points.filter(a => a != "");
-        const result = [];
-        for (let i = 0; i < points.length; i++) {
-            const pointData = points[i];
-            const coords = pointData.trim().split(splitterAxis);
-            if (coords.length == 2 || coords.length == 3) {
-                const longitude = Number(coords[0]);
-                const latitude = Number(coords[1]);
-                const altitude = Number(coords.length >= 3 ? coords[2] : 0);
-                if (longitude != null && latitude != null) {
-                    result.push({
-                        altitude: altitude,
-                        latitude: latitude,
-                        longitude: longitude
-                    });
-                }
-                else {
-                    console.warn("Invalid point data detected.", pointData);
-                }
-            }
-        }
-        return result;
-    }
-    Geometry.ParsePoints = ParsePoints;
-    /**
-     * Parses both string and object Bruce geometry.
-     * String geometry is legacy Bruce data.
-     * @param geometry
-     * @returns
-     */
-    function ParseGeometry(geometry) {
-        if (typeof geometry == "string") {
-            let positions = [];
-            const geometryParsed = (geometry || "").split(";");
-            for (let i = 0; i < geometryParsed.length; i++) {
-                const data = geometryParsed[i];
-                const points = ParsePoints(data);
-                if (points && points.length > 0) {
-                    positions = positions.concat(points);
-                }
-            }
-            positions = RemoveRepeatPoints(positions);
-            const newGeometry = {};
-            if (positions.length > 0) {
-                const topPoint = positions[0];
-                newGeometry.Point = `${topPoint.latitude},${topPoint.longitude}` + (topPoint.altitude != null ? `,${topPoint.altitude}` : "");
-                if (positions.length > 1) {
-                    newGeometry.Polygon = [{ Facing: EPolygonRingType.Boundaries, LinearRing: LineStrFromPoints(positions) }];
-                }
-                if (positions.length > 2) {
-                    newGeometry.LineString = LineStrFromPoints(positions);
-                }
-            }
-            return newGeometry;
-        }
-        return geometry;
-    }
-    Geometry.ParseGeometry = ParseGeometry;
-})(Geometry || (Geometry = {}));
-
 var ObjectUtils;
 (function (ObjectUtils) {
     const DEFAULT_LENGTH = 36;
@@ -2966,28 +2843,6 @@ var PathUtils;
     PathUtils.ParseLegacy = ParseLegacy;
 })(PathUtils || (PathUtils = {}));
 
-/**
- * Describes an expectation on what should be rendered for a menu item-
- * between a min-max distance of an entity to the camera.
- */
-var ZoomControl;
-(function (ZoomControl) {
-    /**
-     * Available display types for a menu item.
-     */
-    let EDisplayType;
-    (function (EDisplayType) {
-        // Hidden means it will not be rendered.
-        EDisplayType["Hidden"] = "hidden";
-        // Point will try render a point based on any available Entity data.
-        EDisplayType["Point"] = "point";
-        // Geometry means it will try render multi-geometry, polygon, polyline, or point in order of priority.
-        EDisplayType["Geometry"] = "geometry";
-        // 3D means it will try render 3D model, multi-geometry, polygon, polyline, or point in order of priority.
-        EDisplayType["Model3D"] = "3d";
-    })(EDisplayType = ZoomControl.EDisplayType || (ZoomControl.EDisplayType = {}));
-})(ZoomControl || (ZoomControl = {}));
-
 var EntityHistoricData;
 (function (EntityHistoricData) {
     /**
@@ -3946,132 +3801,6 @@ var Entity;
         return Object.assign(Object.assign({}, baseEntity), { "Bruce": bruce });
     }
     Entity.Assert = Assert;
-    /**
-     * Helper method that returns a geojson object for a given set of Entities.
-     * @param params
-     * @returns
-     */
-    function ToGeoJson(params) {
-        const { entities, excludeAltitude, altitude, includeUserData, allowedDisplayTypes } = params;
-        const features = [];
-        const allowPoint = allowedDisplayTypes == null || allowedDisplayTypes.includes(ZoomControl.EDisplayType.Point);
-        const allowGeometry = allowedDisplayTypes == null || allowedDisplayTypes.includes(ZoomControl.EDisplayType.Geometry);
-        const cloneObj = (obj) => {
-            return JSON.parse(JSON.stringify(obj));
-        };
-        const areCoordinatesEqual = (coord1, coord2) => {
-            return coord1[0] === coord2[0] && coord1[1] === coord2[1] && (coord1[2] === coord2[2] || (coord1.length < 3 && coord2.length < 3));
-        };
-        const removeConsecutiveDuplicates = (coordinates) => {
-            return coordinates.filter((coord, index, array) => {
-                return index === 0 || !areCoordinatesEqual(coord, array[index - 1]);
-            });
-        };
-        const closePolygonCoordinates = (coordinates) => {
-            if (coordinates.length > 0 && !areCoordinatesEqual(coordinates[0], coordinates[coordinates.length - 1])) {
-                const firstPointCopy = [...coordinates[0]];
-                coordinates.push(firstPointCopy);
-            }
-            return coordinates;
-        };
-        const populateProperties = (feature, entity) => {
-            let properties = null;
-            // All properties.
-            if (includeUserData != false) {
-                properties = cloneObj(entity);
-                // The GeoJSON is supposed to represent the geometry attribute.
-                delete properties.Bruce.VectorGeometry;
-                delete properties.Bruce.Boundaries;
-            }
-            // Only specific internal properties.
-            else {
-                const bClone = cloneObj(entity.Bruce);
-                // The GeoJSON is supposed to represent the geometry attribute.
-                delete bClone.VectorGeometry;
-                delete bClone.Boundaries;
-                properties = {
-                    Bruce: bClone
-                };
-            }
-            feature.properties = properties;
-        };
-        const processGeometry = (geometry, entity) => {
-            var _a, _b;
-            const feature = {
-                type: "Feature",
-                properties: {},
-                geometry: null
-            };
-            populateProperties(feature, entity);
-            if (((_a = geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) && allowGeometry) {
-                geometry.MultiGeometry.forEach(geo => processGeometry(geo, entity));
-                return;
-            }
-            else if (((_b = geometry.Polygon) === null || _b === void 0 ? void 0 : _b.length) && allowGeometry) {
-                const sortedPolygons = geometry.Polygon.sort((a, b) => a.Facing === Geometry.EPolygonRingType.Boundaries ? -1 : 1);
-                const coordinates = sortedPolygons.map(polygonRing => closePolygonCoordinates(removeConsecutiveDuplicates(polygonRing.LinearRing.split(' ').map(coord => {
-                    const [lon, lat, alt] = coord.split(',').map(Number);
-                    return excludeAltitude ? [lon, lat] : [lon, lat, altitude !== undefined ? altitude : (alt !== undefined ? alt : [])];
-                }))));
-                // Check if the polygon has at least 4 points.
-                const isValidPolygon = coordinates.every(polygon => polygon.length >= 4);
-                if (!isValidPolygon) {
-                    // Perhaps try other geometry instead of returning?
-                    return;
-                }
-                feature.geometry = {
-                    type: "Polygon",
-                    coordinates: coordinates,
-                };
-            }
-            else if (geometry.LineString && (allowedDisplayTypes == null || allowedDisplayTypes.includes(ZoomControl.EDisplayType.Geometry))) {
-                const coordinates = removeConsecutiveDuplicates(geometry.LineString.split(' ').map(coord => {
-                    const [lon, lat, alt] = coord.split(',').map(Number);
-                    return excludeAltitude ? [lon, lat] : [lon, lat, altitude !== undefined ? altitude : (alt !== undefined ? alt : [])];
-                }));
-                // Check if the polyline has at least 2 points.
-                if (coordinates.length < 2) {
-                    // Perhaps try other geometry instead of returning?
-                    return;
-                }
-                feature.geometry = {
-                    type: "LineString",
-                    coordinates,
-                };
-            }
-            else if (geometry.Point && allowPoint) {
-                const [lon, lat, alt] = geometry.Point.split(',').map(Number);
-                const coordinates = excludeAltitude ? [lon, lat] : [lon, lat, altitude !== undefined ? altitude : (alt !== undefined ? alt : [])];
-                feature.geometry = {
-                    type: "Point",
-                    coordinates,
-                };
-            }
-            if (feature.geometry) {
-                features.push(feature);
-            }
-        };
-        entities.forEach(entity => {
-            var _a, _b, _c;
-            if (!((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID)) {
-                return;
-            }
-            let geometry = entity.Bruce.VectorGeometry;
-            if (!geometry && (((_b = entity.Bruce.Location) === null || _b === void 0 ? void 0 : _b.longitude) && ((_c = entity.Bruce.Location) === null || _c === void 0 ? void 0 : _c.latitude))) {
-                geometry = {
-                    Point: `${entity.Bruce.Location.longitude},${entity.Bruce.Location.latitude}` + (entity.Bruce.Location.altitude != null ? `,${entity.Bruce.Location.altitude}` : ""),
-                };
-            }
-            if (geometry) {
-                processGeometry(geometry, entity);
-            }
-        });
-        return {
-            type: "FeatureCollection",
-            features,
-        };
-    }
-    Entity.ToGeoJson = ToGeoJson;
     /**
      * Returns cache identifier for an entity record.
      * Example: {
@@ -4653,6 +4382,479 @@ var Calculator;
     Calculator.GetInputValue = GetInputValue;
 })(Calculator || (Calculator = {}));
 
+/**
+ * GeoJSON data structures.
+ */
+var GeoJson;
+(function (GeoJson) {
+    let EType;
+    (function (EType) {
+        EType["Point"] = "Point";
+        EType["MultiPoint"] = "MultiPoint";
+        EType["LineString"] = "LineString";
+        EType["MultiLineString"] = "MultiLineString";
+        EType["Polygon"] = "Polygon";
+        EType["MultiPolygon"] = "MultiPolygon";
+        EType["GeometryCollection"] = "GeometryCollection";
+        EType["Feature"] = "Feature";
+        EType["FeatureCollection"] = "FeatureCollection";
+    })(EType = GeoJson.EType || (GeoJson.EType = {}));
+})(GeoJson || (GeoJson = {}));
+
+/**
+ * Describes vector geometry that Bruce uses.
+ */
+var Geometry;
+(function (Geometry) {
+    let EPolygonRingType;
+    (function (EPolygonRingType) {
+        EPolygonRingType["Boundaries"] = "out";
+        EPolygonRingType["Hole"] = "in";
+    })(EPolygonRingType = Geometry.EPolygonRingType || (Geometry.EPolygonRingType = {}));
+    /**
+     * Turns an array of points into string vector geometry that Bruce can use.
+     * This is used for saving polyline and polygon data.
+     * @param points
+     * @returns
+     */
+    function LineStrFromPoints(points) {
+        if (!points.length) {
+            throw ("points is empty.");
+        }
+        let carto = points[0];
+        let lineString = `${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
+        for (let i = 1; i < points.length; i++) {
+            carto = points[i];
+            lineString += ` ${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "");
+        }
+        return lineString;
+    }
+    Geometry.LineStrFromPoints = LineStrFromPoints;
+    /**
+     * Removes same points that occur in a row.
+     * This will not modify the original array.
+     * @param positions
+     * @returns
+     */
+    function RemoveRepeatPoints(positions) {
+        const filteredList = [];
+        for (let i = 0; i < positions.length; i++) {
+            const pos = positions[i];
+            const lastPos = filteredList.length > 0 ? filteredList[filteredList.length - 1] : null;
+            if (!lastPos || (pos.latitude != lastPos.latitude || pos.longitude != lastPos.longitude || pos.altitude != lastPos.altitude)) {
+                filteredList.push(pos);
+            }
+        }
+        return filteredList;
+    }
+    Geometry.RemoveRepeatPoints = RemoveRepeatPoints;
+    /**
+     * Parses a string of points into an array of points.
+     * @param pointsStr
+     * @returns
+     */
+    function ParsePoints(pointsStr) {
+        pointsStr = pointsStr.replace(/[^\d.,-\s]/g, "");
+        let splitterCoordinates = " ";
+        let splitterAxis = ",";
+        const commaIndex = pointsStr.indexOf(",");
+        const spaceIndex = pointsStr.indexOf(" ");
+        if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
+            splitterCoordinates = ",";
+            splitterAxis = " ";
+        }
+        let points = pointsStr.trim().split(splitterCoordinates);
+        points = points.filter(a => a != "");
+        const result = [];
+        for (let i = 0; i < points.length; i++) {
+            const pointData = points[i];
+            const coords = pointData.trim().split(splitterAxis);
+            if (coords.length == 2 || coords.length == 3) {
+                const longitude = Number(coords[0]);
+                const latitude = Number(coords[1]);
+                const altitude = Number(coords.length >= 3 ? coords[2] : 0);
+                if (longitude != null && latitude != null) {
+                    result.push({
+                        altitude: altitude,
+                        latitude: latitude,
+                        longitude: longitude
+                    });
+                }
+                else {
+                    console.warn("Invalid point data detected.", pointData);
+                }
+            }
+        }
+        return result;
+    }
+    Geometry.ParsePoints = ParsePoints;
+    /**
+     * Parses both string and object Bruce geometry.
+     * String geometry is legacy Bruce data.
+     * @param geometry
+     * @returns
+     */
+    function ParseGeometry(geometry) {
+        if (typeof geometry == "string") {
+            let positions = [];
+            const geometryParsed = (geometry || "").split(";");
+            for (let i = 0; i < geometryParsed.length; i++) {
+                const data = geometryParsed[i];
+                const points = ParsePoints(data);
+                if (points && points.length > 0) {
+                    positions = positions.concat(points);
+                }
+            }
+            positions = RemoveRepeatPoints(positions);
+            const newGeometry = {};
+            if (positions.length > 0) {
+                const topPoint = positions[0];
+                newGeometry.Point = `${topPoint.latitude},${topPoint.longitude}` + (topPoint.altitude != null ? `,${topPoint.altitude}` : "");
+                if (positions.length > 1) {
+                    newGeometry.Polygon = [{ Facing: EPolygonRingType.Boundaries, LinearRing: LineStrFromPoints(positions) }];
+                }
+                if (positions.length > 2) {
+                    newGeometry.LineString = LineStrFromPoints(positions);
+                }
+            }
+            return newGeometry;
+        }
+        return geometry;
+    }
+    Geometry.ParseGeometry = ParseGeometry;
+    /**
+     * Converts Bruce geometry to GeoJSON.
+     * @param geometry
+     * @returns returns GeoJSON or null if conversion failed or resulted in an empty object.
+     */
+    function ToGeoJsonFeature(params) {
+        const { geometry, properties, altitude } = params;
+        // Primary collection of geometries.
+        // We will return a single feature that contains many geometries.
+        // That way we can attach properties to the top-level.
+        const collection = [];
+        // Returns if two coordinates are equal.
+        const areCoordinatesEqual = (coord1, coord2) => {
+            return coord1[0] === coord2[0] && coord1[1] === coord2[1] && coord1[2] === coord2[2];
+        };
+        // Removes consecutive duplicate coordinates.
+        const removeConsecutiveDuplicates = (coordinates) => {
+            return coordinates.filter((coord, index) => {
+                return index === 0 || !areCoordinatesEqual(coord, coordinates[index - 1]);
+            });
+        };
+        // Ensures that the polygon is closed.
+        const closePolygonCoordinates = (coordinates) => {
+            return coordinates.map(ring => {
+                if (!areCoordinatesEqual(ring[0], ring[ring.length - 1])) {
+                    ring.push(ring[0]);
+                }
+                return ring;
+            });
+        };
+        /**
+         * Processes Bruce geometry.
+         * Called recursively for MultiGeometry.
+         * @param geometry
+         * @returns if a geometry was processed and added.
+         */
+        const processGeometry = (geometry) => {
+            var _a, _b;
+            let jGeometry = null;
+            // We add in order of priority while ignoring anything lower priority.
+            // This mimics how we render Bruce geometry.
+            if ((_a = geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) {
+                let passed = false;
+                geometry.MultiGeometry.forEach(geo => {
+                    if (processGeometry(geo)) {
+                        passed = true;
+                    }
+                });
+                if (passed) {
+                    return true;
+                }
+            }
+            if (!jGeometry && ((_b = geometry.Polygon) === null || _b === void 0 ? void 0 : _b.length)) {
+                // Sorts polygons so that boundaries come first.
+                const sortedPolygons = geometry.Polygon.sort((a, b) => a.Facing === Geometry.EPolygonRingType.Boundaries ? -1 : 1);
+                // Converts polygons to GeoJSON coordinates.
+                // This will close the polygon if it's not already closed and remove consecutive duplicates.
+                const coordinates = closePolygonCoordinates(sortedPolygons.map(polygon => {
+                    const points = ParsePoints(polygon.LinearRing);
+                    return removeConsecutiveDuplicates(points.map(coord => {
+                        const { longitude: lon, latitude: lat, altitude: alt } = coord;
+                        return (altitude != null ? [lon, lat, altitude] : [lon, lat, alt !== undefined ? alt : 0]);
+                    }));
+                }));
+                if (coordinates.every(polygon => polygon.length >= 4)) {
+                    jGeometry = {
+                        coordinates: coordinates,
+                        type: GeoJson.EType.Polygon
+                    };
+                }
+            }
+            if (!jGeometry && geometry.LineString) {
+                const points = ParsePoints(geometry.LineString);
+                const coordinates = removeConsecutiveDuplicates(points.map(coord => {
+                    const { longitude: lon, latitude: lat, altitude: alt } = coord;
+                    return (altitude != null ? [lon, lat, altitude] : [lon, lat, alt !== undefined ? alt : 0]);
+                }));
+                if (coordinates.length >= 2) {
+                    jGeometry = {
+                        coordinates: coordinates,
+                        type: GeoJson.EType.LineString
+                    };
+                }
+            }
+            if (!jGeometry && geometry.Point) {
+                const points = ParsePoints(geometry.Point);
+                if (points.length) {
+                    const { longitude: lon, latitude: lat, altitude: alt } = points[0];
+                    const coordinates = altitude != null ? [lon, lat, altitude] : [lon, lat, alt !== undefined ? alt : 0];
+                    jGeometry = {
+                        coordinates: coordinates,
+                        type: GeoJson.EType.Point
+                    };
+                }
+            }
+            if (jGeometry) {
+                collection.push(jGeometry);
+                return true;
+            }
+            // Nothing :(
+            return false;
+        };
+        // Add all geometries to the collection.
+        processGeometry(geometry);
+        // Nothing was produced.
+        if (!collection.length) {
+            return null;
+        }
+        // Just 1 item. We can have a single feature rather than geometry collection.
+        if (collection.length === 1) {
+            const geoJson = {
+                type: GeoJson.EType.Feature,
+                geometry: collection[0],
+                properties: properties || {}
+            };
+            return geoJson;
+        }
+        // Construct the base feature and append the collection.
+        const geoJson = {
+            type: GeoJson.EType.Feature,
+            geometry: {
+                type: GeoJson.EType.GeometryCollection,
+                geometries: collection
+            },
+            properties: properties || {}
+        };
+        return geoJson;
+    }
+    Geometry.ToGeoJsonFeature = ToGeoJsonFeature;
+    /**
+     * Converts GeoJSON to Bruce geometry.
+     * @param geoJson
+     * @returns
+     */
+    function FromGeoJson(params) {
+        var _a;
+        const { geoJson } = params;
+        // Don't process if there's no geometry.
+        if (geoJson.type === GeoJson.EType.FeatureCollection) {
+            if (!geoJson.features.length) {
+                return null;
+            }
+        }
+        // We start by populating multi-geometry.
+        // If we end up with only 1 level then we'll return the single geometry.
+        const full = {
+            MultiGeometry: []
+        };
+        // Merged properties added to as we go.
+        const properties = {};
+        // Traverse a geojson hierarchy and generate a Bruce multi-geometry from it.
+        // This will append to the "full" object as it goes.
+        const traverse = (feature) => {
+            // Geometry collections don't have coords so we have to cast as any.
+            const { type, coordinates, properties } = feature.geometry;
+            // Unknown thing. Ignoring.
+            if (!type) {
+                return;
+            }
+            // No coordinates. Ignoring.
+            if (!coordinates) {
+                return;
+            }
+            // Simple properties merge.
+            // Doesn't handle nested properties very well.
+            if (properties) {
+                Object.assign(properties, properties);
+            }
+            // We'll first match cases of nested collections and handle them early.
+            // Then we'll be left with simple geometry cases.
+            if (type === GeoJson.EType.GeometryCollection) {
+                const collection = feature;
+                for (let i = 0; i < collection.geometries.length; i++) {
+                    const geo = collection.geometries[i];
+                    traverse({
+                        type: GeoJson.EType.Feature,
+                        geometry: geo,
+                        properties: feature.properties
+                    });
+                }
+                return;
+            }
+            else if (type === GeoJson.EType.FeatureCollection) {
+                const collection = feature;
+                for (let i = 0; i < collection.features.length; i++) {
+                    traverse(collection.features[i]);
+                }
+                return;
+            }
+            const geometry = {};
+            switch (type) {
+                case GeoJson.EType.Polygon:
+                    if (!geometry.Polygon) {
+                        geometry.Polygon = [];
+                    }
+                    coordinates.forEach((polygon, index) => {
+                        const linearRing = polygon.map(coord => coord.join(',')).join(' ');
+                        geometry.Polygon.push({
+                            LinearRing: linearRing,
+                            Facing: index === 0 ? Geometry.EPolygonRingType.Boundaries : Geometry.EPolygonRingType.Hole
+                        });
+                    });
+                    break;
+                case GeoJson.EType.LineString:
+                    geometry.LineString = coordinates.map((coord) => coord.join(',')).join(' ');
+                    break;
+                case GeoJson.EType.Point:
+                    geometry.Point = coordinates.join(',');
+                    break;
+                case GeoJson.EType.MultiPolygon:
+                    if (!geometry.MultiGeometry) {
+                        geometry.MultiGeometry = [];
+                    }
+                    coordinates.forEach((multiPolygon) => {
+                        const multiPolygonGeometry = { Polygon: [] };
+                        multiPolygon.forEach((polygon, index) => {
+                            const linearRing = polygon.map(coord => coord.join(',')).join(' ');
+                            multiPolygonGeometry.Polygon.push({
+                                LinearRing: linearRing,
+                                Facing: index === 0 ? Geometry.EPolygonRingType.Boundaries : Geometry.EPolygonRingType.Hole
+                            });
+                        });
+                        geometry.MultiGeometry.push(multiPolygonGeometry);
+                    });
+                    break;
+                case GeoJson.EType.MultiLineString:
+                    if (!geometry.MultiGeometry) {
+                        geometry.MultiGeometry = [];
+                    }
+                    coordinates.forEach((multiLineString) => {
+                        geometry.MultiGeometry.push({
+                            LineString: multiLineString.map((coord) => coord.join(',')).join(' ')
+                        });
+                    });
+                    break;
+                case GeoJson.EType.MultiPoint:
+                    if (!geometry.MultiGeometry) {
+                        geometry.MultiGeometry = [];
+                    }
+                    coordinates.forEach((multiPoint) => {
+                        geometry.MultiGeometry.push({
+                            Point: multiPoint.join(',')
+                        });
+                    });
+                    break;
+                default:
+                    return;
+            }
+            // Nothing to do. Nothing was made.
+            if (Object.keys(geometry).length === 0) {
+                return;
+            }
+            full.MultiGeometry.push(geometry);
+        };
+        // Traverse all features.
+        if (geoJson.type === GeoJson.EType.Feature) {
+            traverse(geoJson);
+        }
+        else {
+            (_a = geoJson.features) === null || _a === void 0 ? void 0 : _a.forEach(traverse);
+        }
+        // If we only have 1 geometry then we'll return it directly.
+        if (full.MultiGeometry.length === 1) {
+            return {
+                geometry: full.MultiGeometry[0],
+                properties: properties
+            };
+        }
+        // If we have multiple but only 1 of each type then that's standard Bruce stuff.
+        // Eg: 1 point, 1 line, 1 polygon is a very normal Bruce geometry.
+        const countsPerType = {
+            Point: 0,
+            LineString: 0,
+            Polygon: 0
+        };
+        full.MultiGeometry.forEach(geo => {
+            if (geo.Point) {
+                countsPerType.Point++;
+            }
+            else if (geo.LineString) {
+                countsPerType.LineString++;
+            }
+            else if (geo.Polygon) {
+                countsPerType.Polygon++;
+            }
+        });
+        if (countsPerType.Point === 1 && countsPerType.LineString === 1 && countsPerType.Polygon === 1) {
+            const merged = {};
+            const addToMerged = (geo) => {
+                if (geo.Point) {
+                    merged.Point = geo.Point;
+                }
+                else if (geo.LineString) {
+                    merged.LineString = geo.LineString;
+                }
+                else if (geo.Polygon) {
+                    merged.Polygon = geo.Polygon;
+                }
+            };
+            full.MultiGeometry.forEach(addToMerged);
+            return {
+                geometry: merged,
+                properties: properties
+            };
+        }
+        // If there are many polygons but only 1 line and/or 1 point then we'll put those singles into the top-level.
+        // Eg: 5 polygons, 1 point, 1 line. That should be a single geometry.
+        if (countsPerType.Polygon > 1 && (countsPerType.LineString <= 1 && countsPerType.Point <= 1)) {
+            const semiMerged = {};
+            const addToSemiMerged = (geo) => {
+                if (geo.Point) {
+                    semiMerged.Point = geo.Point;
+                }
+                else if (geo.LineString) {
+                    semiMerged.LineString = geo.LineString;
+                }
+            };
+            semiMerged.MultiGeometry = full.MultiGeometry.filter(geo => geo.Polygon);
+            full.MultiGeometry.forEach(addToSemiMerged);
+            return {
+                geometry: semiMerged,
+                properties: properties
+            };
+        }
+        // More than 1 of each, then return the full multi-geometry as-is.
+        return {
+            geometry: full,
+            properties: properties
+        };
+    }
+    Geometry.FromGeoJson = FromGeoJson;
+})(Geometry || (Geometry = {}));
+
 var Bounds;
 (function (Bounds) {
     /**
@@ -8741,6 +8943,28 @@ var ProgramKey;
     ProgramKey.GetListCacheKey = GetListCacheKey;
 })(ProgramKey || (ProgramKey = {}));
 
+/**
+ * Describes an expectation on what should be rendered for a menu item-
+ * between a min-max distance of an entity to the camera.
+ */
+var ZoomControl;
+(function (ZoomControl) {
+    /**
+     * Available display types for a menu item.
+     */
+    let EDisplayType;
+    (function (EDisplayType) {
+        // Hidden means it will not be rendered.
+        EDisplayType["Hidden"] = "hidden";
+        // Point will try render a point based on any available Entity data.
+        EDisplayType["Point"] = "point";
+        // Geometry means it will try render multi-geometry, polygon, polyline, or point in order of priority.
+        EDisplayType["Geometry"] = "geometry";
+        // 3D means it will try render 3D model, multi-geometry, polygon, polyline, or point in order of priority.
+        EDisplayType["Model3D"] = "3d";
+    })(EDisplayType = ZoomControl.EDisplayType || (ZoomControl.EDisplayType = {}));
+})(ZoomControl || (ZoomControl = {}));
+
 /**
  * Converts legacy records into something easier to work with alongside the newer ones.
  * On save we'll convert back to the legacy format.
@@ -13802,7 +14026,7 @@ var DataSource;
 })(DataSource || (DataSource = {}));
 
 // This is updated with the package.json version on build.
-const VERSION = "4.6.5";
+const VERSION = "4.6.7";
 
-export { VERSION, AnnDocument, CustomForm, AbstractApi, Api, BruceApi, GlobalApi, GuardianApi, ApiGetters, Calculator, Bounds, BruceEvent, CacheControl, Camera, Cartes, Carto, Color, DelayQueue, Geometry, UTC, BruceVariable, LRUCache, EntityAttachmentType, EntityAttachment, EntityComment, EntityLink, EntityLod, EntityLodCategory, EntityRelationType, EntityRelation, EntitySource, EntityTag, EntityType, Entity, EntityCoords, EntityTypeVisualSettings, EntityAttribute, EntityHistoricData, EntityTableView, Comment, ClientFile, ProgramKey, ZoomControl, MenuItem, ProjectViewBookmark, ProjectView, ProjectViewLegacyTile, ProjectViewTile, ProjectViewLegacy, ProjectViewLegacyBookmark, PendingAction, MessageBroker, HostingLocation, Style, Tileset, Permission, Session, UserGroup, User, Account, AccountInvite, AccountFeatures, AccountLimits, EncryptUtils, MathUtils, ObjectUtils, PathUtils, UrlUtils, DataLab, ImportCad, ImportCsv, ImportJson, ImportKml, ImportedFile, Markup, Uploader, Plugin, ENVIRONMENT, DataSource };
+export { VERSION, AnnDocument, CustomForm, AbstractApi, Api, BruceApi, GlobalApi, GuardianApi, ApiGetters, Calculator, Bounds, BruceEvent, CacheControl, Camera, Cartes, Carto, Color, DelayQueue, Geometry, UTC, BruceVariable, LRUCache, GeoJson, EntityAttachmentType, EntityAttachment, EntityComment, EntityLink, EntityLod, EntityLodCategory, EntityRelationType, EntityRelation, EntitySource, EntityTag, EntityType, Entity, EntityCoords, EntityTypeVisualSettings, EntityAttribute, EntityHistoricData, EntityTableView, Comment, ClientFile, ProgramKey, ZoomControl, MenuItem, ProjectViewBookmark, ProjectView, ProjectViewLegacyTile, ProjectViewTile, ProjectViewLegacy, ProjectViewLegacyBookmark, PendingAction, MessageBroker, HostingLocation, Style, Tileset, Permission, Session, UserGroup, User, Account, AccountInvite, AccountFeatures, AccountLimits, EncryptUtils, MathUtils, ObjectUtils, PathUtils, UrlUtils, DataLab, ImportCad, ImportCsv, ImportJson, ImportKml, ImportedFile, Markup, Uploader, Plugin, ENVIRONMENT, DataSource };
 //# sourceMappingURL=bruce-models.es5.js.map