bruce-models 5.9.7 → 5.9.8

package/dist/bruce-models.umd.js

@@ -155,8 +155,6 @@
         Api.PrepReqParams = PrepReqParams;
     })(exports.Api || (exports.Api = {}));
 
-    // 1 minute.
-    const DEFAULT_DURATION = 60 * 1000;
     class CacheControl {
         constructor(id) {
             this.memory = new Map();
@@ -177,7 +175,7 @@
             }
             let { id, data, duration } = params;
             if (!duration || duration < 0) {
-                duration = DEFAULT_DURATION;
+                duration = exports.Api.DEFAULT_CACHE_DURATION;
             }
             id = String(id);
             const expires = Date.now() + duration;
@@ -1638,6 +1636,10 @@
         Unsubscribe(id) {
             let index = this.callbacks.findIndex(x => x._id == id);
             if (index > -1) {
+                // Null the callback function to prevent it from being called.
+                // This stops a trigger from calling it if it's currently looping.
+                this.callbacks[index].callback = null;
+                // Remove the callback from the list.
                 this.callbacks.splice(index, 1);
             }
         }
@@ -1647,9 +1649,10 @@
          * @param data
          */
         Trigger(data) {
-            let callbacks = this.callbacks;
-            for (let i = 0; i < callbacks.length; i++) {
-                let callback = callbacks[i];
+            // We copy in case the callback modifies the list.
+            const callbacksCopy = [...this.callbacks];
+            for (let i = 0; i < callbacksCopy.length; i++) {
+                const callback = callbacksCopy[i];
                 if (callback.callback) {
                     callback.callback(data);
                 }
@@ -2544,7 +2547,10 @@
             }
             const key = path[0];
             const item = items.find((i) => i.Key === key);
-            if (!item || !item.Structure || !path.length) {
+            if (!item) {
+                return null;
+            }
+            if (path.length === 1) {
                 return item;
             }
             return GetAttribute(item.Structure, path.slice(1));
@@ -3128,13 +3134,14 @@
             }
             const broken = str.split(".");
             for (let i = 0; i < broken.length; i++) {
-                let piece = broken[0];
-                if (piece.charAt(0) == "\"") {
-                    piece = broken[0] = piece.substring(1);
+                let piece = broken[i];
+                if (piece.startsWith("\"")) {
+                    piece = piece.substring(1);
                 }
-                if (piece.charAt(piece.length - 1) == "\"") {
-                    broken[0] = piece.substring(0, piece.length - 1);
+                if (piece.endsWith("\"")) {
+                    piece = piece.substring(0, piece.length - 1);
                 }
+                broken[i] = piece;
             }
             return broken;
         }
@@ -3792,7 +3799,7 @@
         function GetValue(params) {
             var _a;
             let { entity: data, path, handleLegacy: checkAgainstLegacy } = params;
-            if (checkAgainstLegacy == null) {
+            if (checkAgainstLegacy == null || checkAgainstLegacy == undefined) {
                 checkAgainstLegacy = true;
             }
             if (!path || !path.length) {
@@ -4337,25 +4344,6 @@
         Entity.GetHistoricContainsKey = GetHistoricContainsKey;
     })(exports.Entity || (exports.Entity = {}));
 
-    /**
-     * Gets the first Bruce variable in a string.
-     * @param str
-     * @returns
-     */
-    function getVariable(str) {
-        const start = str.indexOf("${");
-        if (start > -1) {
-            const end = str.indexOf("}");
-            if (end > -1) {
-                if (start < end) {
-                    const path = str.substring(start + 2, end);
-                    const txt = str.substring(start, end + 1);
-                    return { path: path, text: txt };
-                }
-            }
-        }
-        return null;
-    }
     (function (BruceVariable) {
         /**
          * Replaces all Bruce variables in a string with the value of the attribute.
@@ -4365,28 +4353,40 @@
          * @returns
          */
         function SwapValues(params) {
-            let { str, entity: data, legacyParse } = params;
-            if (!legacyParse) {
-                legacyParse = false;
-            }
-            while (true) {
-                const variable = getVariable(str);
-                if (variable) {
-                    const path = legacyParse ? exports.PathUtils.ParseLegacy(variable.path) : exports.PathUtils.Parse(variable.path);
-                    let value = "";
-                    if (path.length > 0) {
-                        value = exports.Entity.GetValue({
-                            entity: data,
-                            path: path
-                        });
-                    }
-                    str = str.replace(variable.text, value);
+            const { str, entity: data, legacyParse, retainType } = params;
+            // If the input is just a path, return the value of the path.
+            // We only do this for 'retainType=true' because all existing code expects a string result.
+            if (retainType && str.startsWith("${") && str.endsWith("}")) {
+                let pathStr = str.slice(2, -1);
+                pathStr = pathStr.trim();
+                const path = legacyParse ? exports.PathUtils.ParseLegacy(pathStr) : exports.PathUtils.Parse(pathStr);
+                return exports.Entity.GetValue({
+                    entity: data,
+                    path: path
+                });
+            }
+            // Regex that will match all Bruce variables.
+            // It looks for ${...} and captures the content inside the brackets.
+            const variableRegex = /\${([^}]*)}/g;
+            return str.replace(variableRegex, (match, pathStr) => {
+                // If the path is empty or just whitespace, return empty string
+                if (!pathStr || pathStr.trim().length === 0) {
+                    return "";
                 }
-                else {
-                    break;
+                pathStr = pathStr.trim();
+                const path = legacyParse ? exports.PathUtils.ParseLegacy(pathStr) : exports.PathUtils.Parse(pathStr);
+                if (!path.length) {
+                    return "";
                 }
-            }
-            return str;
+                const value = exports.Entity.GetValue({
+                    entity: data,
+                    path: path
+                });
+                if (value == null || value == undefined) {
+                    return "";
+                }
+                return String(value);
+            });
         }
         BruceVariable.SwapValues = SwapValues;
     })(exports.BruceVariable || (exports.BruceVariable = {}));
@@ -4465,6 +4465,11 @@
          */
         function Calculate(params) {
             let { fields, tags, data, defaultValue, type } = params;
+            // If params doesn't include a defaultValue, use null.
+            // Though passing in undefined is valid!
+            if ("defaultValue" in params == false) {
+                defaultValue = null;
+            }
             if (fields == null) {
                 return defaultValue;
             }
@@ -4515,11 +4520,6 @@
             let value = null;
             for (let i = 0; i < fieldsArr.length; i++) {
                 let field = fieldsArr[i];
-                if (field) {
-                    // Dereference.
-                    // We do this because we'll be modifying the field to fix bad data.
-                    field = JSON.parse(JSON.stringify(field));
-                }
                 // Bad data has it set to 'color' but expects the input to be a number.
                 if (type == "number" && field.type == EValueType.Color) {
                     field.type = EValueType.Input;
@@ -4876,20 +4876,26 @@
                 try {
                     value = exports.BruceVariable.SwapValues({
                         str: value,
-                        entity: entity
+                        entity: entity,
+                        retainType: true
                     });
-                    const isJsEval = value.startsWith("JS:");
-                    const MATH_REGEX = /(\d+\.?\d*|\.\d+)([+\-*/])(\d+\.?\d*|\.\d+)/;
-                    const isMathEval = isJsEval || MATH_REGEX.test(value);
-                    if (isJsEval || isMathEval) {
-                        if (isJsEval) {
-                            value = value.replace("JS:", "");
-                            value = value.trim();
+                    if (value == null || value == undefined) {
+                        return null;
+                    }
+                    if (typeof value === "string") {
+                        const isJsEval = value.startsWith("JS:");
+                        const MATH_REGEX = /(\d+\.?\d*|\.\d+)([+\-*/])(\d+\.?\d*|\.\d+)/;
+                        const isMathEval = isJsEval || MATH_REGEX.test(value);
+                        if (isJsEval || isMathEval) {
+                            if (isJsEval) {
+                                value = value.replace("JS:", "");
+                                value = value.trim();
+                            }
+                            // https://rollupjs.org/guide/en/#avoiding-eval
+                            // This stops eval warning.
+                            const eval2 = eval;
+                            return eval2(value);
                         }
-                        // https://rollupjs.org/guide/en/#avoiding-eval
-                        // This stops eval warning.
-                        const eval2 = eval;
-                        return eval2(value);
                     }
                 }
                 catch (exception) {
@@ -4943,13 +4949,7 @@
             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;
+            return points.map(carto => `${carto.longitude},${carto.latitude}` + (carto.altitude != null ? `,${carto.altitude}` : "")).join(' ');
         }
         Geometry.LineStrFromPoints = LineStrFromPoints;
         /**
@@ -5041,6 +5041,9 @@
                 }
                 return newGeometry;
             }
+            else if (!geometry) {
+                return {};
+            }
             return geometry;
         }
         Geometry.ParseGeometry = ParseGeometry;
@@ -5057,19 +5060,26 @@
             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];
+                return coord1[0] === coord2[0] && coord1[1] === coord2[1] &&
+                    (noAltitude || coord1[2] === coord2[2]);
             };
             // Removes consecutive duplicate coordinates.
             const removeConsecutiveDuplicates = (coordinates) => {
-                return coordinates.filter((coord, index) => {
-                    return index === 0 || !areCoordinatesEqual(coord, coordinates[index - 1]);
-                });
+                if (coordinates.length <= 1)
+                    return coordinates;
+                const result = [coordinates[0]];
+                for (let i = 1; i < coordinates.length; i++) {
+                    if (!areCoordinatesEqual(coordinates[i], coordinates[i - 1])) {
+                        result.push(coordinates[i]);
+                    }
+                }
+                return result;
             };
             // 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]);
+                    if (ring.length > 0 && !areCoordinatesEqual(ring[0], ring[ring.length - 1])) {
+                        return [...ring, ring[0]];
                     }
                     return ring;
                 });
@@ -5659,13 +5669,14 @@
      * If you have a method that may be called often, but you don't want it to run often, use this.
      */
     class DelayQueue {
-        constructor(callback, delay = 200) {
+        constructor(callback, delay = 200, startDelayed = false) {
             // Millisecond delay.
             this.delay = 200;
             // Date-time stamp for the last callback call.
             this.lastCallTime = null;
             this.callback = callback;
             this.delay = delay;
+            this.startDelayed = startDelayed;
         }
         /**
          * Request a call on the callback.
@@ -5673,7 +5684,10 @@
          */
         Call(force = false) {
             if (this.lastCallTime == null) {
-                force = true;
+                this.lastCallTime = new Date().getTime();
+                if (this.startDelayed) {
+                    force = false;
+                }
             }
             if (force) {
                 let endDate = new Date().getTime();
@@ -5777,28 +5791,36 @@
          * @param utc
          */
         function GetPassedTime(utc) {
-            const passedSeconds = GetPassedSeconds(utc);
+            let tense = "ago";
+            let passedSeconds = GetPassedSeconds(utc);
+            if (passedSeconds < 0) {
+                // Account for the time difference between the client and the server.
+                if (passedSeconds < -(15 * 60)) {
+                    return "recently";
+                }
+                tense = "from now";
+            }
             if (passedSeconds < 60) {
-                return `${passedSeconds} second${passedSeconds > 1 ? "s" : ""} ago`;
+                return `${passedSeconds} second${passedSeconds > 1 ? "s" : ""} ${tense}`;
             }
             const passedMinutes = Math.floor(passedSeconds / 60);
             if (passedMinutes < 60) {
-                return `${passedMinutes} minute${passedMinutes > 1 ? "s" : ""} ago`;
+                return `${passedMinutes} minute${passedMinutes > 1 ? "s" : ""} ${tense}`;
             }
             const passedHours = Math.floor(passedMinutes / 60);
             if (passedHours < 24) {
-                return `${passedHours} hour${passedHours > 1 ? "s" : ""} ago`;
+                return `${passedHours} hour${passedHours > 1 ? "s" : ""} ${tense}`;
             }
             const passedDays = Math.floor(passedHours / 24);
             if (passedDays < 30) {
-                return `${passedDays} day${passedDays > 1 ? "s" : ""} ago`;
+                return `${passedDays} day${passedDays > 1 ? "s" : ""} ${tense}`;
             }
             const passedMonths = Math.floor(passedDays / 30);
             if (passedMonths < 12) {
-                return `${passedMonths} month${passedMonths > 1 ? "s" : ""} ago`;
+                return `${passedMonths} month${passedMonths > 1 ? "s" : ""} ${tense}`;
             }
             const passedYears = Math.floor(passedMonths / 12);
-            return `${passedYears} year${passedYears > 1 ? "s" : ""} ago`;
+            return `${passedYears} year${passedYears > 1 ? "s" : ""} ${tense}`;
         }
         UTC.GetPassedTime = GetPassedTime;
         /**
@@ -5879,7 +5901,13 @@
          * @param value
          */
         Set(key, value) {
-            if (this.cache.size >= this.capacity) {
+            if (this.capacity <= 0) {
+                // Empty cache.
+                // Means we were configured to not cache anything.
+                this.cache.clear();
+                return;
+            }
+            else if (this.cache.size >= this.capacity) {
                 const leastRecentlyUsedKey = this.cache.keys().next().value;
                 this.cache.delete(leastRecentlyUsedKey);
             }
@@ -7589,15 +7617,15 @@
          * @returns
          */
         function Round(num, decimals = 0) {
-            if (decimals <= 0) {
-                return Math.round(num);
+            const n = typeof num === 'string' ? parseFloat(num) : num;
+            if (isNaN(n)) {
+                return 0;
             }
-            let tmp = "1";
-            for (let i = 0; i < decimals; i++) {
-                tmp += "0";
+            if (decimals <= 0) {
+                return Math.round(n);
             }
-            const d = parseFloat(tmp);
-            return Math.round((num + Number.EPSILON) * d) / d;
+            const multiplier = Math.pow(10, decimals);
+            return Math.round((n + Number.EPSILON) * multiplier) / multiplier;
         }
         MathUtils.Round = Round;
         /**
@@ -15340,7 +15368,7 @@
     })(exports.Scenario || (exports.Scenario = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "5.9.7";
+    const VERSION = "5.9.8";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;