bruce-models 7.1.53 → 7.1.55

package/dist/bruce-models.umd.js

@@ -2707,6 +2707,88 @@
         Account.GetDbRegionListCacheKey = GetDbRegionListCacheKey;
     })(exports.Account || (exports.Account = {}));
 
+    (function (AccountAudit) {
+        let EType;
+        (function (EType) {
+            EType["LOG"] = "L";
+            EType["CREATE"] = "C";
+            EType["UPDATE"] = "U";
+            EType["DELETE"] = "D";
+        })(EType = AccountAudit.EType || (AccountAudit.EType = {}));
+        let ESeverity;
+        (function (ESeverity) {
+            ESeverity["DEBUG"] = "D";
+            ESeverity["INFO"] = "I";
+            ESeverity["WARN"] = "W";
+            ESeverity["ERROR"] = "E";
+        })(ESeverity = AccountAudit.ESeverity || (AccountAudit.ESeverity = {}));
+        let EDetailLevel;
+        (function (EDetailLevel) {
+            EDetailLevel["SUMMARY"] = "summary";
+            EDetailLevel["FULL"] = "full";
+        })(EDetailLevel = AccountAudit.EDetailLevel || (AccountAudit.EDetailLevel = {}));
+        let EAction;
+        (function (EAction) {
+            EAction["CREATED"] = "Created";
+            EAction["UPDATED"] = "Updated";
+            EAction["DELETED"] = "Deleted";
+        })(EAction = AccountAudit.EAction || (AccountAudit.EAction = {}));
+        let EOrderBy;
+        (function (EOrderBy) {
+            EOrderBy["ID"] = "ID";
+            EOrderBy["LOGGED"] = "Logged";
+            EOrderBy["CREATED"] = "Created";
+            EOrderBy["CREATED_DATE"] = "CreatedDate";
+            EOrderBy["SEVERITY"] = "Severity";
+            EOrderBy["TYPE"] = "Type";
+            EOrderBy["ACTION"] = "Action";
+            EOrderBy["MESSAGE"] = "Message";
+            EOrderBy["CONCEPT"] = "Concept";
+            EOrderBy["SCOPE"] = "Scope";
+            EOrderBy["USER_ID"] = "User.ID";
+        })(EOrderBy = AccountAudit.EOrderBy || (AccountAudit.EOrderBy = {}));
+        function GetConceptList(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req: reqParams, concept, pageSize, pageIndex, lastSeenId, search, orderBy, sortOrder, recordId, detailLevel } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!concept) {
+                    throw new Error("Concept is required.");
+                }
+                const urlParams = new URLSearchParams();
+                if (pageSize != null) {
+                    urlParams.append("PageSize", String(pageSize));
+                }
+                if (pageIndex != null) {
+                    urlParams.append("PageIndex", String(pageIndex));
+                }
+                if (lastSeenId != null) {
+                    urlParams.append("LastSeenID", String(lastSeenId));
+                }
+                if (search) {
+                    urlParams.append("Search", search);
+                }
+                if (orderBy) {
+                    urlParams.append("OrderBy", orderBy);
+                }
+                if (sortOrder) {
+                    urlParams.append("SortOrder", sortOrder);
+                }
+                if (recordId) {
+                    urlParams.append("RecordID", recordId);
+                }
+                if (detailLevel) {
+                    urlParams.append("DetailLevel", detailLevel);
+                }
+                const query = urlParams.toString();
+                const route = `v3/accountAudits/concept/${exports.Api.Encode(String(concept))}`;
+                return api.GET(query ? `${route}?${query}` : route, exports.Api.PrepReqParams(reqParams));
+            });
+        }
+        AccountAudit.GetConceptList = GetConceptList;
+    })(exports.AccountAudit || (exports.AccountAudit = {}));
+
     (function (AccountFeatures) {
         let EFeature;
         (function (EFeature) {
@@ -7111,12 +7193,234 @@
             EValueType[EValueType["RandomColor"] = 5] = "RandomColor";
         })(EValueType = Calculator.EValueType || (Calculator.EValueType = {}));
         /**
-         * Calculates a value-type 'T' based on given set of fields.
-         * The supplied data + tags are fed into the calculation.
-         * When a value fails to be calculated, the 'defaultValue' is returned.
-         * If no 'defaultValue' is provided, then 'null' is returned.
+         * Decodes an effective string produced by TraceCalculate back into a structured object.
+         * Returns null if the string is null, empty, or does not match the expected format.
          */
-        function Calculate(params) {
+        function DecodeEffective(effective) {
+            if (!effective) {
+                return null;
+            }
+            // Format: f{index}:{type}[:{part1}[:{part2}]]
+            const match = effective.match(/^f(\d+):([^:]+)(?::([^:]+)(?::([^:]+))?)?$/);
+            if (!match) {
+                return null;
+            }
+            const fieldIndex = parseInt(match[1], 10);
+            const type = match[2];
+            const part1 = match[3] != null ? decodeEffective(match[3]) : null;
+            const part2 = match[4] != null ? decodeEffective(match[4]) : null;
+            const base = { type, fieldIndex };
+            switch (type) {
+                case "color":
+                    if (part1 == null) {
+                        return null;
+                    }
+                    return Object.assign(Object.assign({}, base), { colorStr: part1 });
+                case "gradient":
+                case "mapping":
+                    return Object.assign(Object.assign(Object.assign({}, base), (part1 != null && { path: part1 })), (part2 != null && { entityValue: part2 }));
+                case "input":
+                    if (part1 == null || part2 == null) {
+                        return null;
+                    }
+                    return Object.assign(Object.assign({}, base), { template: part1, resolvedValue: part2 });
+                case "tag":
+                    if (part1 == null) {
+                        return null;
+                    }
+                    return Object.assign(Object.assign({}, base), { tagColor: part1 });
+                case "random":
+                case "fn":
+                    return base;
+                default:
+                    return null;
+            }
+        }
+        Calculator.DecodeEffective = DecodeEffective;
+        function encodeEffective(str) {
+            const s = String(str == null ? "" : str);
+            try {
+                if (typeof Buffer !== "undefined") {
+                    return Buffer.from(s).toString("base64").replace(/=+$/, "");
+                }
+                // Browser fallback
+                return btoa(s).replace(/=+$/, "");
+            }
+            catch (e) {
+                return encodeURIComponent(s);
+            }
+        }
+        function decodeEffective(encoded) {
+            try {
+                if (typeof Buffer !== "undefined") {
+                    return Buffer.from(encoded, "base64").toString("utf8");
+                }
+                return atob(encoded);
+            }
+            catch (e) {
+                return decodeURIComponent(encoded);
+            }
+        }
+        function _getMappingTrace(value, entity) {
+            const attrPaths = parseLegacyPath(value.field);
+            for (let i = 0; i < attrPaths.length; i++) {
+                const attrPath = attrPaths[i];
+                let eValue = exports.Entity.GetValue({
+                    entity: entity,
+                    path: attrPath
+                });
+                let isValueNum = !isNaN(+eValue);
+                if (eValue == null) {
+                    isValueNum = false;
+                }
+                for (let j = 0; j < value.values.length; j++) {
+                    const option = value.values[j];
+                    const fieldValues = Array.isArray(option.fieldValue) ? option.fieldValue : [option.fieldValue];
+                    for (let k = 0; k < fieldValues.length; k++) {
+                        let mapValue = fieldValues[k];
+                        // If mapValue is prefixed with "JS:", we evaluate it as JavaScript.
+                        // This lets us do things like JS:Boolean("${}") as a quick way to map 'existence' to a target value.
+                        if (typeof mapValue === "string" && mapValue.startsWith("JS:")) {
+                            try {
+                                let jsEval = mapValue.replace("JS:", "").trim();
+                                const attrPathStr = exports.PathUtils.Wrap(attrPath);
+                                jsEval = jsEval.replace("${}", "${" + attrPathStr + "}");
+                                jsEval = exports.BruceVariable.SwapValues({
+                                    str: jsEval,
+                                    entity: entity
+                                });
+                                // https://rollupjs.org/guide/en/#avoiding-eval
+                                // This stops eval warning.
+                                const eval2 = eval;
+                                mapValue = eval2(jsEval);
+                                if (mapValue) {
+                                    return { result: option.appliedValue, attrPath, eValue };
+                                }
+                                else {
+                                    continue;
+                                }
+                            }
+                            catch (exception) {
+                                const e = exception;
+                                let suppress = false;
+                                if (e && typeof e == "object") {
+                                    const msg = e.message;
+                                    suppress = !!msg && (msg.includes("Unexpected end") || msg.includes("got end of script"));
+                                }
+                                if (!suppress) {
+                                    console.error(e);
+                                }
+                                // Eval failed, therefor not a valid mapping-row.
+                                continue;
+                            }
+                        }
+                        let isMapValueNum = !isNaN(+mapValue);
+                        if (isMapValueNum == null) {
+                            isMapValueNum = false;
+                        }
+                        if (isValueNum && (isMapValueNum || (typeof mapValue === "string" && mapValue.includes("-")))) {
+                            if (+mapValue == +eValue) {
+                                return { result: option.appliedValue, attrPath, eValue };
+                            }
+                            const mapSplit = mapValue.split("-");
+                            if (mapSplit.length == 2) {
+                                const min = mapSplit[0];
+                                const max = mapSplit[1];
+                                if (min != "") {
+                                    if (+eValue < +min) {
+                                        continue;
+                                    }
+                                }
+                                if (max != "") {
+                                    if (+eValue > +max) {
+                                        continue;
+                                    }
+                                }
+                                if (min == "" && max == "") {
+                                    continue;
+                                }
+                                return { result: option.appliedValue, attrPath, eValue };
+                            }
+                        }
+                        else {
+                            if (mapValue == eValue) {
+                                return { result: option.appliedValue, attrPath, eValue };
+                            }
+                            // Case where Entity value is a boolean but the mapping value is a string.
+                            // Common as mapping value is typically a user-entered string.
+                            else if (typeof eValue === "boolean" && typeof mapValue === "string") {
+                                const eValueStr = eValue ? "true" : "false";
+                                if (mapValue.toLowerCase() == eValueStr) {
+                                    return { result: option.appliedValue, attrPath, eValue };
+                                }
+                            }
+                            // Handling possible case where the opposite is true.
+                            // Have not seen this happen yet, but preparing for any future cases.
+                            else if (typeof mapValue === "boolean" && typeof eValue === "string") {
+                                const mapValueStr = mapValue ? "true" : "false";
+                                if (mapValueStr == eValue.toLowerCase()) {
+                                    return { result: option.appliedValue, attrPath, eValue };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return { result: null, attrPath: null, eValue: null };
+        }
+        function _getGradientTrace(value, entity, defaultToMin) {
+            const min = +value.points[0].position;
+            const max = +value.points[value.points.length - 1].position;
+            const attrPaths = parseLegacyPath(value.field);
+            for (let i = 0; i < attrPaths.length; i++) {
+                const attrPath = attrPaths[i];
+                let eValue = exports.Entity.GetValue({
+                    entity: entity,
+                    path: attrPath
+                });
+                if (typeof eValue == "string") {
+                    eValue = Number(eValue);
+                }
+                if ((!eValue && eValue != 0) || isNaN(eValue)) {
+                    continue;
+                }
+                if (eValue >= max) {
+                    return { result: exports.Color.ColorFromStr(value.points[value.points.length - 1].color), attrPath, eValue };
+                }
+                else if (eValue <= min) {
+                    return { result: exports.Color.ColorFromStr(value.points[0].color), attrPath, eValue };
+                }
+                for (let j = 0; j < value.points.length - 1; j++) {
+                    const pointA = value.points[j];
+                    const pointB = value.points[j + 1];
+                    if (eValue >= pointA.position && eValue <= pointB.position) {
+                        if (pointA.position == pointB.position) {
+                            return { result: exports.Color.ColorFromStr(pointA.color), attrPath, eValue };
+                        }
+                        const distance = (eValue - pointA.position) / (pointB.position - pointA.position);
+                        const colorA = exports.Color.ColorFromStr(pointA.color);
+                        const colorB = exports.Color.ColorFromStr(pointB.color);
+                        return {
+                            result: {
+                                red: colorA.red + (colorB.red - colorA.red) * distance,
+                                green: colorA.green + (colorB.green - colorA.green) * distance,
+                                blue: colorA.blue + (colorB.blue - colorA.blue) * distance,
+                                alpha: colorA.alpha + (colorB.alpha - colorA.alpha) * distance
+                            },
+                            attrPath,
+                            eValue
+                        };
+                    }
+                }
+            }
+            // Fallback to min (static, no data path resolved).
+            return { result: exports.Color.ColorFromStr(value.points[0].color), attrPath: null, eValue: null };
+        }
+        /**
+         * Like Calculate, but also returns an 'effective' key describing how the value
+         * was derived. See ITraceResult for the key format.
+         */
+        function TraceCalculate(params) {
             let { fields, tags, data, defaultValue, type } = params;
             // If params doesn't include a defaultValue, use null.
             // Though passing in undefined is valid!
@@ -7124,7 +7428,7 @@
                 defaultValue = null;
             }
             if (fields == null) {
-                return defaultValue;
+                return { value: defaultValue, effective: null };
             }
             if (data == null || typeof data != "object") {
                 data = {};
@@ -7169,16 +7473,21 @@
                 }
                 return false;
             };
-            // Calculate the value.
             let value = null;
+            let computedEffective = null;
             for (let i = 0; i < fieldsArr.length; i++) {
                 let field = fieldsArr[i];
+                // Intermediate trace parts — assembled into effective only if value resolves.
+                let traceType = null;
+                let tracePart1 = null;
+                let tracePart2 = null;
                 // 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;
                 }
                 // Custom resolution.
                 if (field.value instanceof Function) {
+                    traceType = "fn";
                     value = field.value(data, tags);
                     if (type == "number") {
                         if (typeof value == "string" && value != "" && value != null && value != undefined) {
@@ -7212,6 +7521,8 @@
                                 break;
                             }
                             value = field.value;
+                            traceType = "color";
+                            tracePart1 = encodeEffective(value);
                             value = assertColor(value);
                             if (value && type == "string") {
                                 value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
@@ -7221,10 +7532,17 @@
                             if (type === "number") {
                                 break;
                             }
-                            value = GetGradientValue(field.value, data, shouldRangesDefaultToMin);
-                            value = assertColor(value);
-                            if (value && type == "string") {
-                                value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                            {
+                                const gradTrace = _getGradientTrace(field.value, data, shouldRangesDefaultToMin);
+                                value = assertColor(gradTrace.result);
+                                traceType = "gradient";
+                                if (gradTrace.attrPath != null) {
+                                    tracePart1 = encodeEffective(exports.PathUtils.Wrap(gradTrace.attrPath));
+                                    tracePart2 = encodeEffective(String(gradTrace.eValue));
+                                }
+                                if (value && type == "string") {
+                                    value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                                }
                             }
                             break;
                         case EValueType.RandomColor:
@@ -7233,6 +7551,7 @@
                             }
                             value = exports.Color.RandomColor();
                             value = assertColor(value);
+                            traceType = "random";
                             if (value && type == "string") {
                                 value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
                             }
@@ -7241,12 +7560,14 @@
                             if (type === "number") {
                                 break;
                             }
-                            for (let i = 0; i < tags.length; i++) {
-                                const tag = tags[i];
+                            for (let ti = 0; ti < tags.length; ti++) {
+                                const tag = tags[ti];
                                 if (tag.Color) {
                                     value = exports.Color.ColorFromStr(tag.Color);
                                     value = assertColor(value);
                                     if (value) {
+                                        traceType = "tag";
+                                        tracePart1 = encodeEffective(tag.Color);
                                         break;
                                     }
                                 }
@@ -7260,31 +7581,37 @@
                         // Eg: Result is a colour, a number, a string.
                         // This means we first calculate the value, then validate it in the context of the desired type.
                         case EValueType.Input:
-                            value = GetInputValue(field.value, data);
-                            if (value != null) {
-                                if (type == "number") {
-                                    if (typeof value == "string" && value != "" && value != null && value != undefined) {
-                                        value = Number(value);
-                                    }
-                                    else if (typeof value != "number") {
-                                        value = null;
-                                    }
-                                }
-                                else if (type == "string") {
-                                    if (typeof value == "number") {
-                                        value = String(value);
-                                    }
-                                    else if (typeof value == "object") {
-                                        if (isColor(value)) {
-                                            value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                            {
+                                const inputTemplate = String(field.value);
+                                value = GetInputValue(field.value, data);
+                                if (value != null) {
+                                    traceType = "input";
+                                    tracePart1 = encodeEffective(inputTemplate);
+                                    tracePart2 = encodeEffective(String(value));
+                                    if (type == "number") {
+                                        if (typeof value == "string" && value != "" && value != null && value != undefined) {
+                                            value = Number(value);
                                         }
-                                        else {
+                                        else if (typeof value != "number") {
                                             value = null;
                                         }
                                     }
-                                }
-                                else if (type == "color") {
-                                    value = assertColor(value);
+                                    else if (type == "string") {
+                                        if (typeof value == "number") {
+                                            value = String(value);
+                                        }
+                                        else if (typeof value == "object") {
+                                            if (isColor(value)) {
+                                                value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                                            }
+                                            else {
+                                                value = null;
+                                            }
+                                        }
+                                    }
+                                    else if (type == "color") {
+                                        value = assertColor(value);
+                                    }
                                 }
                             }
                             break;
@@ -7292,31 +7619,39 @@
                         // Eg: mapping a value to a Client File ID, or a colour, or a number.
                         // This means we first calculate the value, then validate it in the context of the desired type.
                         case EValueType.Mapping:
-                            value = GetMappingValue(field.value, data);
-                            if (value != null) {
-                                if (type == "number") {
-                                    if (typeof value == "string" && value != "" && value != null && value != undefined) {
-                                        value = Number(value);
-                                    }
-                                    else if (typeof value != "number") {
-                                        value = null;
-                                    }
-                                }
-                                else if (type == "string") {
-                                    if (typeof value == "number") {
-                                        value = String(value);
+                            {
+                                const mapTrace = _getMappingTrace(field.value, data);
+                                value = mapTrace.result;
+                                if (value != null) {
+                                    traceType = "mapping";
+                                    if (mapTrace.attrPath != null) {
+                                        tracePart1 = encodeEffective(exports.PathUtils.Wrap(mapTrace.attrPath));
+                                        tracePart2 = encodeEffective(String(mapTrace.eValue));
                                     }
-                                    else if (typeof value == "object") {
-                                        if (isColor(value)) {
-                                            value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                                    if (type == "number") {
+                                        if (typeof value == "string" && value != "" && value != null && value != undefined) {
+                                            value = Number(value);
                                         }
-                                        else {
+                                        else if (typeof value != "number") {
                                             value = null;
                                         }
                                     }
-                                }
-                                else if (type == "color") {
-                                    value = assertColor(typeof value === "number" ? String(value) : value);
+                                    else if (type == "string") {
+                                        if (typeof value == "number") {
+                                            value = String(value);
+                                        }
+                                        else if (typeof value == "object") {
+                                            if (isColor(value)) {
+                                                value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                                            }
+                                            else {
+                                                value = null;
+                                            }
+                                        }
+                                    }
+                                    else if (type == "color") {
+                                        value = assertColor(typeof value === "number" ? String(value) : value);
+                                    }
                                 }
                             }
                             break;
@@ -7340,11 +7675,34 @@
                     }
                 }
                 if (value != null) {
+                    if (traceType != null) {
+                        if (tracePart1 != null && tracePart2 != null) {
+                            computedEffective = `f${i}:${traceType}:${tracePart1}:${tracePart2}`;
+                        }
+                        else if (tracePart1 != null) {
+                            computedEffective = `f${i}:${traceType}:${tracePart1}`;
+                        }
+                        else {
+                            computedEffective = `f${i}:${traceType}`;
+                        }
+                    }
                     break;
                 }
             }
-            // Return the value or default.
-            return value != null ? value : defaultValue;
+            return {
+                value: value != null ? value : defaultValue,
+                effective: value != null ? computedEffective : null
+            };
+        }
+        Calculator.TraceCalculate = TraceCalculate;
+        /**
+         * Calculates a value-type 'T' based on given set of fields.
+         * The supplied data + tags are fed into the calculation.
+         * When a value fails to be calculated, the 'defaultValue' is returned.
+         * If no 'defaultValue' is provided, then 'null' is returned.
+         */
+        function Calculate(params) {
+            return TraceCalculate(params).value;
         }
         Calculator.Calculate = Calculate;
         /**
@@ -7356,13 +7714,7 @@
          * @returns
          */
         function GetValue(fields, entity = {}, tags = []) {
-            return Calculate({
-                fields: fields,
-                data: entity,
-                defaultValue: null,
-                tags: tags,
-                type: "any"
-            });
+            return TraceGetValue(fields, entity, tags).value;
         }
         Calculator.GetValue = GetValue;
         /**
@@ -7373,13 +7725,7 @@
          * @param tags
          */
         function GetColor(fields, entity = {}, tags = []) {
-            return Calculate({
-                fields: fields,
-                data: entity,
-                defaultValue: null,
-                tags: tags,
-                type: "color"
-            });
+            return TraceGetColor(fields, entity, tags).value;
         }
         Calculator.GetColor = GetColor;
         /**
@@ -7391,13 +7737,7 @@
          * @returns
          */
         function GetNumber(fields, entity = {}, tags = []) {
-            return Calculate({
-                fields: fields,
-                data: entity,
-                defaultValue: null,
-                tags: tags,
-                type: "number"
-            });
+            return TraceGetNumber(fields, entity, tags).value;
         }
         Calculator.GetNumber = GetNumber;
         /**
@@ -7409,15 +7749,61 @@
          * @returns
          */
         function GetString(fields, entity = {}, tags = []) {
-            return Calculate({
-                fields: fields,
+            return TraceGetString(fields, entity, tags).value;
+        }
+        Calculator.GetString = GetString;
+        /**
+         * Like GetValue, but also returns 'effective' describing how the value was derived.
+         */
+        function TraceGetValue(fields, entity = {}, tags = []) {
+            return TraceCalculate({
+                fields,
                 data: entity,
                 defaultValue: null,
-                tags: tags,
+                tags,
+                type: "any"
+            });
+        }
+        Calculator.TraceGetValue = TraceGetValue;
+        /**
+         * Like GetColor, but also returns 'effective' describing how the color was derived.
+         */
+        function TraceGetColor(fields, entity = {}, tags = []) {
+            return TraceCalculate({
+                fields,
+                data: entity,
+                defaultValue: null,
+                tags,
+                type: "color"
+            });
+        }
+        Calculator.TraceGetColor = TraceGetColor;
+        /**
+         * Like GetNumber, but also returns 'effective' describing how the number was derived.
+         */
+        function TraceGetNumber(fields, entity = {}, tags = []) {
+            return TraceCalculate({
+                fields,
+                data: entity,
+                defaultValue: null,
+                tags,
+                type: "number"
+            });
+        }
+        Calculator.TraceGetNumber = TraceGetNumber;
+        /**
+         * Like GetString, but also returns 'effective' describing how the string was derived.
+         */
+        function TraceGetString(fields, entity = {}, tags = []) {
+            return TraceCalculate({
+                fields,
+                data: entity,
+                defaultValue: null,
+                tags,
                 type: "string"
             });
         }
-        Calculator.GetString = GetString;
+        Calculator.TraceGetString = TraceGetString;
         /**
          * Calculates a mapping value. This can return any value type.
          * It is intended to be parsed and validated within a value-type context. Eg: GetColor, GetNumber, GetString.
@@ -7426,114 +7812,7 @@
          * @returns
          */
         function GetMappingValue(value, entity) {
-            const attrPaths = parseLegacyPath(value.field);
-            for (let i = 0; i < attrPaths.length; i++) {
-                const attrPath = attrPaths[i];
-                let eValue = exports.Entity.GetValue({
-                    entity: entity,
-                    path: attrPath
-                });
-                let isValueNum = !isNaN(+eValue);
-                if (eValue == null) {
-                    isValueNum = false;
-                }
-                for (let i = 0; i < value.values.length; i++) {
-                    const option = value.values[i];
-                    const fieldValues = Array.isArray(option.fieldValue) ? option.fieldValue : [option.fieldValue];
-                    // Check each field value in the array.
-                    for (let j = 0; j < fieldValues.length; j++) {
-                        let mapValue = fieldValues[j];
-                        // If mapValue is prefixed with "JS:", we evaluate it as JavaScript.
-                        // This lets us do things like JS:Boolean("${}") as a quick way to map 'existence' to a target value.
-                        if (typeof mapValue === "string" && mapValue.startsWith("JS:")) {
-                            try {
-                                let jsEval = mapValue.replace("JS:", "").trim();
-                                const attrPathStr = exports.PathUtils.Wrap(attrPath);
-                                jsEval = jsEval.replace("${}", "${" + attrPathStr + "}");
-                                jsEval = exports.BruceVariable.SwapValues({
-                                    str: jsEval,
-                                    entity: entity
-                                });
-                                // https://rollupjs.org/guide/en/#avoiding-eval
-                                // This stops eval warning.
-                                const eval2 = eval;
-                                mapValue = eval2(jsEval);
-                                // We currently expect eval to return a validity bool.
-                                // So it either matches and we return it, or it doesn't and we continue.
-                                if (mapValue) {
-                                    return option.appliedValue;
-                                }
-                                else {
-                                    continue;
-                                }
-                            }
-                            catch (exception) {
-                                const e = exception;
-                                let suppress = false;
-                                if (e && typeof e == "object") {
-                                    const msg = e.message;
-                                    suppress = !!msg && (msg.includes("Unexpected end") || msg.includes("got end of script"));
-                                }
-                                if (!suppress) {
-                                    console.error(e);
-                                }
-                                // Eval failed, therefor not a valid mapping-row.
-                                continue;
-                            }
-                        }
-                        let isMapValueNum = !isNaN(+mapValue);
-                        if (isMapValueNum == null) {
-                            isMapValueNum = false;
-                        }
-                        if (isValueNum && (isMapValueNum || (typeof mapValue === "string" && mapValue.includes("-")))) {
-                            if (+mapValue == +eValue) {
-                                return option.appliedValue;
-                            }
-                            const mapSplit = mapValue.split("-");
-                            if (mapSplit.length == 2) {
-                                const min = mapSplit[0];
-                                const max = mapSplit[1];
-                                if (min != "") {
-                                    if (+eValue < +min) {
-                                        continue;
-                                    }
-                                }
-                                if (max != "") {
-                                    if (+eValue > +max) {
-                                        continue;
-                                    }
-                                }
-                                if (min == "" && max == "") {
-                                    continue;
-                                }
-                                return option.appliedValue;
-                            }
-                        }
-                        else {
-                            if (mapValue == eValue) {
-                                return option.appliedValue;
-                            }
-                            // Case where Entity value is a boolean but the mapping value is a string.
-                            // Common as mapping value is typically a user-entered string.
-                            else if (typeof eValue === "boolean" && typeof mapValue === "string") {
-                                const eValueStr = eValue ? "true" : "false";
-                                if (mapValue.toLowerCase() == eValueStr) {
-                                    return option.appliedValue;
-                                }
-                            }
-                            // Handling possible case where the opposite is true.
-                            // Have not seen this happen yet, but preparing for any future cases.
-                            else if (typeof mapValue === "boolean" && typeof eValue === "string") {
-                                const mapValueStr = mapValue ? "true" : "false";
-                                if (mapValueStr == eValue.toLowerCase()) {
-                                    return option.appliedValue;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return null;
+            return _getMappingTrace(value, entity).result;
         }
         Calculator.GetMappingValue = GetMappingValue;
         /**
@@ -7546,47 +7825,7 @@
          * @returns
          */
         function GetGradientValue(value, entity, defaultToMin) {
-            const min = +value.points[0].position;
-            const max = +value.points[value.points.length - 1].position;
-            const attrPaths = parseLegacyPath(value.field);
-            for (let i = 0; i < attrPaths.length; i++) {
-                const attrPath = attrPaths[i];
-                let eValue = exports.Entity.GetValue({
-                    entity: entity,
-                    path: attrPath
-                });
-                if (typeof eValue == "string") {
-                    eValue = Number(eValue);
-                }
-                if ((!eValue && eValue != 0) || isNaN(eValue)) {
-                    continue;
-                }
-                if (eValue >= max) {
-                    return exports.Color.ColorFromStr(value.points[value.points.length - 1].color);
-                }
-                else if (eValue <= min) {
-                    return exports.Color.ColorFromStr(value.points[0].color);
-                }
-                for (let i = 0; i < value.points.length - 1; i++) {
-                    const pointA = value.points[i];
-                    const pointB = value.points[i + 1];
-                    if (eValue >= pointA.position && eValue <= pointB.position) {
-                        if (pointA.position == pointB.position) {
-                            return exports.Color.ColorFromStr(pointA.color);
-                        }
-                        const distance = (eValue - pointA.position) / (pointB.position - pointA.position);
-                        const colorA = exports.Color.ColorFromStr(pointA.color);
-                        const colorB = exports.Color.ColorFromStr(pointB.color);
-                        return {
-                            red: colorA.red + (colorB.red - colorA.red) * distance,
-                            green: colorA.green + (colorB.green - colorA.green) * distance,
-                            blue: colorA.blue + (colorB.blue - colorA.blue) * distance,
-                            alpha: colorA.alpha + (colorB.alpha - colorA.alpha) * distance
-                        };
-                    }
-                }
-            }
-            return exports.Color.ColorFromStr(value.points[0].color);
+            return _getGradientTrace(value, entity, defaultToMin).result;
         }
         Calculator.GetGradientValue = GetGradientValue;
         /**
@@ -18678,7 +18917,7 @@
     })(exports.UrlUtils || (exports.UrlUtils = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.53";
+    const VERSION = "7.1.55";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;