bruce-models 7.1.54 → 7.1.55

package/dist/lib/calculator/calculator.js

@@ -77,12 +77,234 @@ var Calculator;
         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 = entity_1.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 = path_utils_1.PathUtils.Wrap(attrPath);
+                            jsEval = jsEval.replace("${}", "${" + attrPathStr + "}");
+                            jsEval = bruce_variable_1.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 = entity_1.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: color_1.Color.ColorFromStr(value.points[value.points.length - 1].color), attrPath, eValue };
+            }
+            else if (eValue <= min) {
+                return { result: color_1.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: color_1.Color.ColorFromStr(pointA.color), attrPath, eValue };
+                    }
+                    const distance = (eValue - pointA.position) / (pointB.position - pointA.position);
+                    const colorA = color_1.Color.ColorFromStr(pointA.color);
+                    const colorB = color_1.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: color_1.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!
@@ -90,7 +312,7 @@ var Calculator;
             defaultValue = null;
         }
         if (fields == null) {
-            return defaultValue;
+            return { value: defaultValue, effective: null };
         }
         if (data == null || typeof data != "object") {
             data = {};
@@ -135,22 +357,21 @@ var Calculator;
             }
             return false;
         };
-        // Calculate the value.
         let value = null;
+        let computedEffective = 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.
-                // EDIT: commented out because the risk is low.
-                // field = JSON.parse(JSON.stringify(field));
-            }
+            // 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) {
@@ -184,6 +405,8 @@ var Calculator;
                             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})`;
@@ -193,10 +416,17 @@ var Calculator;
                         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(path_utils_1.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:
@@ -205,6 +435,7 @@ var Calculator;
                         }
                         value = color_1.Color.RandomColor();
                         value = assertColor(value);
+                        traceType = "random";
                         if (value && type == "string") {
                             value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
                         }
@@ -213,12 +444,14 @@ var Calculator;
                         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 = color_1.Color.ColorFromStr(tag.Color);
                                 value = assertColor(value);
                                 if (value) {
+                                    traceType = "tag";
+                                    tracePart1 = encodeEffective(tag.Color);
                                     break;
                                 }
                             }
@@ -232,31 +465,37 @@ var Calculator;
                     // 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;
@@ -264,31 +503,39 @@ var Calculator;
                     // 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(path_utils_1.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;
@@ -312,11 +559,34 @@ var Calculator;
                 }
             }
             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;
     /**
@@ -328,13 +598,7 @@ var Calculator;
      * @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;
     /**
@@ -345,13 +609,7 @@ var Calculator;
      * @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;
     /**
@@ -363,13 +621,7 @@ var Calculator;
      * @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;
     /**
@@ -381,15 +633,61 @@ var Calculator;
      * @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,
+            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: tags,
+            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.
@@ -398,114 +696,7 @@ var Calculator;
      * @returns
      */
     function GetMappingValue(value, entity) {
-        const attrPaths = parseLegacyPath(value.field);
-        for (let i = 0; i < attrPaths.length; i++) {
-            const attrPath = attrPaths[i];
-            let eValue = entity_1.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 = path_utils_1.PathUtils.Wrap(attrPath);
-                            jsEval = jsEval.replace("${}", "${" + attrPathStr + "}");
-                            jsEval = bruce_variable_1.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;
     /**
@@ -518,47 +709,7 @@ var Calculator;
      * @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 = entity_1.Entity.GetValue({
-                entity: entity,
-                path: attrPath
-            });
-            if (typeof eValue == "string") {
-                eValue = Number(eValue);
-            }
-            if ((!eValue && eValue != 0) || isNaN(eValue)) {
-                continue;
-            }
-            if (eValue >= max) {
-                return color_1.Color.ColorFromStr(value.points[value.points.length - 1].color);
-            }
-            else if (eValue <= min) {
-                return color_1.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 color_1.Color.ColorFromStr(pointA.color);
-                    }
-                    const distance = (eValue - pointA.position) / (pointB.position - pointA.position);
-                    const colorA = color_1.Color.ColorFromStr(pointA.color);
-                    const colorB = color_1.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 color_1.Color.ColorFromStr(value.points[0].color);
+        return _getGradientTrace(value, entity, defaultToMin).result;
     }
     Calculator.GetGradientValue = GetGradientValue;
     /**