bruce-models 3.4.2 → 3.4.4

package/dist/bruce-models.es5.js

@@ -2473,6 +2473,129 @@ 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;
@@ -3265,6 +3388,92 @@ var Entity;
         });
     }
     Entity.GetList = GetList;
+    function ToGeoJson(params) {
+        const { entities, excludeAltitude, altitude, includeUserData } = params;
+        const features = [];
+        const cloneObj = (obj) => {
+            return JSON.parse(JSON.stringify(obj));
+        };
+        const populateProperties = (feature, entity) => {
+            let properties = null;
+            // All properties.
+            if (includeUserData != false) {
+                properties = cloneObj(entity);
+                // We exclude geometry since the geojson is supposed to represent that attribute.
+                delete properties.geometry;
+            }
+            // Only specific internal properties.
+            else {
+                properties = {
+                    Bruce: entity.Bruce ? cloneObj(entity.Bruce) : null,
+                    location: entity.location ? cloneObj(entity.location) : null,
+                    transform: entity.transform ? cloneObj(entity.transform) : null,
+                    boundaries: entity.boundaries ? cloneObj(entity.boundaries) : null,
+                };
+            }
+            feature.properties = properties;
+        };
+        const processGeometry = (geometry, entity) => {
+            const feature = {
+                type: 'Feature',
+                properties: {},
+                geometry: null
+            };
+            populateProperties(feature, entity);
+            if (geometry.Polygon) {
+                const sortedPolygons = geometry.Polygon.sort((a, b) => a.Facing === Geometry.EPolygonRingType.Boundaries ? -1 : 1);
+                const coordinates = sortedPolygons.map(polygonRing => 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 : [])];
+                }));
+                feature.geometry = {
+                    type: 'Polygon',
+                    coordinates: coordinates,
+                };
+            }
+            if (geometry.Point) {
+                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 (geometry.LineString) {
+                const coordinates = 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 : [])];
+                });
+                feature.geometry = {
+                    type: 'LineString',
+                    coordinates,
+                };
+            }
+            if (geometry.MultiGeometry) {
+                geometry.MultiGeometry.forEach(geo => processGeometry(geo, entity));
+                return;
+            }
+            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.geometry;
+            if (!geometry && (((_b = entity.location) === null || _b === void 0 ? void 0 : _b.longitude) && ((_c = entity.location) === null || _c === void 0 ? void 0 : _c.latitude))) {
+                geometry = {
+                    Point: `${entity.location.longitude},${entity.location.latitude}` + (entity.location.altitude != null ? `,${entity.location.altitude}` : ""),
+                };
+            }
+            processGeometry(geometry, entity);
+        });
+        return {
+            type: 'FeatureCollection',
+            features,
+        };
+    }
+    Entity.ToGeoJson = ToGeoJson;
 })(Entity || (Entity = {}));
 
 /**
@@ -3773,189 +3982,6 @@ var Calculator;
     Calculator.GetInputValue = GetInputValue;
 })(Calculator || (Calculator = {}));
 
-/**
- * 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;
-    function ToGeoJson(params) {
-        const { entities, excludeAltitude } = params;
-        const features = [];
-        const processGeometry = (geometry, ID) => {
-            if (geometry.Polygon) {
-                const sortedPolygons = geometry.Polygon.sort((a, b) => a.Facing === EPolygonRingType.Boundaries ? -1 : 1);
-                const coordinates = sortedPolygons.map(polygonRing => polygonRing.LinearRing.split(' ').map(coord => {
-                    const [lon, lat, alt] = coord.split(',').map(Number);
-                    return excludeAltitude ? [lon, lat] : [lon, lat, ...(alt ? [alt] : [])];
-                }));
-                features.push({
-                    type: 'Feature',
-                    properties: { ID },
-                    geometry: {
-                        type: 'Polygon',
-                        coordinates: coordinates,
-                    }
-                });
-            }
-            if (geometry.Point) {
-                const [lon, lat, alt] = geometry.Point.split(',').map(Number);
-                const coordinates = excludeAltitude ? [lon, lat] : [lon, lat, ...(alt ? [alt] : [])];
-                features.push({
-                    type: 'Feature',
-                    properties: { ID },
-                    geometry: {
-                        type: 'Point',
-                        coordinates,
-                    }
-                });
-            }
-            if (geometry.LineString) {
-                const coordinates = geometry.LineString.split(' ').map(coord => {
-                    const [lon, lat, alt] = coord.split(',').map(Number);
-                    return excludeAltitude ? [lon, lat] : [lon, lat, ...(alt ? [alt] : [])];
-                });
-                features.push({
-                    type: 'Feature',
-                    properties: { ID },
-                    geometry: {
-                        type: 'LineString',
-                        coordinates,
-                    }
-                });
-            }
-            if (geometry.MultiGeometry) {
-                geometry.MultiGeometry.forEach(geo => processGeometry(geo, ID));
-            }
-        };
-        entities.forEach(entity => {
-            const { ID } = entity.Bruce;
-            const { geometry } = entity;
-            processGeometry(geometry, ID);
-        });
-        return {
-            type: 'FeatureCollection',
-            features,
-        };
-    }
-    Geometry.ToGeoJson = ToGeoJson;
-})(Geometry || (Geometry = {}));
-
 var Bounds;
 (function (Bounds) {
     /**
@@ -10770,7 +10796,7 @@ var DataSource;
     DataSource.GetList = GetList;
 })(DataSource || (DataSource = {}));
 
-const VERSION = "3.4.2";
+const VERSION = "3.4.4";
 
 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, ClientFile, ProgramKey, ZoomControl, MenuItem, ProjectViewBookmark, ProjectView, ProjectViewLegacyTile, ProjectViewTile, ProjectViewLegacy, ProjectViewLegacyBookmark, PendingAction, MessageBroker, HostingLocation, Style, Tileset, Permission, Session, UserGroup, User, Account, AccountInvite, EncryptUtils, MathUtils, ObjectUtils, PathUtils, UrlUtils, DataLab, ImportCad, ImportCsv, ImportJson, ImportKml, ImportedFile, Markup, Uploader, Plugin, ENVIRONMENT, DataSource };
 //# sourceMappingURL=bruce-models.es5.js.map