bruce-models 1.1.5 → 1.1.7

package/dist/bruce-models.umd.js

@@ -79,7 +79,8 @@
             EEnv["UAT"] = "UAT";
             EEnv["PROD"] = "PROD";
         })(EEnv = Api.EEnv || (Api.EEnv = {}));
-        Api.DEFAULT_CACHE_STATE = true;
+        // False = cache is enabled by default for req-params.
+        Api.DEFAULT_NO_CACHE = false;
         /**
          * Prepares a string to be included in a url.
          * @param str
@@ -457,7 +458,7 @@
         GetCacheItem(key, reqParams) {
             let noCache = reqParams === null || reqParams === void 0 ? void 0 : reqParams.noCache;
             if (noCache == null) {
-                noCache = exports.Api.DEFAULT_CACHE_STATE;
+                noCache = exports.Api.DEFAULT_NO_CACHE;
             }
             if (noCache) {
                 return null;
@@ -1924,6 +1925,180 @@
         Calculator.GetInputValue = GetInputValue;
     })(exports.Calculator || (exports.Calculator = {}));
 
+    /**
+     * Describes vector geometry that Bruce uses.
+     */
+    (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;
+        function ParsePoints(data) {
+            data = data.replace(/[^\d.,-\s]/g, "");
+            let splitterCoordinates = " ";
+            let splitterAxis = ",";
+            const commaIndex = data.indexOf(",");
+            const spaceIndex = data.indexOf(" ");
+            if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
+                splitterCoordinates = ",";
+                splitterAxis = " ";
+            }
+            let points = data.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;
+    })(exports.Geometry || (exports.Geometry = {}));
+
+    (function (Bounds) {
+        /**
+         * Calculates boundaries from entity.
+         * This will not use the set entity boundaries and instead calculate from geometry and location.
+         * @param entity
+         */
+        function FromEntity(entity) {
+            const bounds = {
+                maxAltitude: null,
+                maxLatitude: null,
+                maxLongitude: null,
+                minAltitude: null,
+                minLatitude: null,
+                minLongitude: null
+            };
+            const points = [];
+            if (entity.location) {
+                points.push(entity.location);
+            }
+            if (entity.geometry) {
+                if (entity.geometry.Point) {
+                    points.push(...exports.Geometry.ParsePoints(entity.geometry.Point));
+                }
+                if (entity.geometry.LineString) {
+                    points.push(...exports.Geometry.ParsePoints(entity.geometry.LineString));
+                }
+                if (entity.geometry.Polygon) {
+                    for (const ring of entity.geometry.Polygon) {
+                        points.push(...exports.Geometry.ParsePoints(ring.LinearRing));
+                    }
+                }
+            }
+            for (const point of points) {
+                if (bounds.maxLatitude == null || point.latitude > bounds.maxLatitude) {
+                    bounds.maxLatitude = point.latitude;
+                }
+                if (bounds.maxLongitude == null || point.longitude > bounds.maxLongitude) {
+                    bounds.maxLongitude = point.longitude;
+                }
+                if (bounds.maxAltitude == null || point.altitude > bounds.maxAltitude) {
+                    bounds.maxAltitude = point.altitude;
+                }
+                if (bounds.minLatitude == null || point.latitude < bounds.minLatitude) {
+                    bounds.minLatitude = point.latitude;
+                }
+                if (bounds.minLongitude == null || point.longitude < bounds.minLongitude) {
+                    bounds.minLongitude = point.longitude;
+                }
+                if (bounds.minAltitude == null || point.altitude < bounds.minAltitude) {
+                    bounds.minAltitude = point.altitude;
+                }
+            }
+            return bounds;
+        }
+        Bounds.FromEntity = FromEntity;
+    })(exports.Bounds || (exports.Bounds = {}));
+
     /**
      * Simple event utility.
      * Instantiate the model, then subscribe and trigger events.
@@ -2205,123 +2380,6 @@
         }
     }
 
-    /**
-     * Describes vector geometry that Bruce uses.
-     */
-    (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;
-        function ParsePoints(data) {
-            data = data.replace(/[^\d.,-\s]/g, "");
-            let splitterCoordinates = " ";
-            let splitterAxis = ",";
-            const commaIndex = data.indexOf(",");
-            const spaceIndex = data.indexOf(" ");
-            if ((spaceIndex > -1 && commaIndex > spaceIndex) || commaIndex <= -1) {
-                splitterCoordinates = ",";
-                splitterAxis = " ";
-            }
-            let points = data.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;
-    })(exports.Geometry || (exports.Geometry = {}));
-
     /**
      * Describes a Bruce stored date.
      */