bruce-models 2.3.6 → 2.3.8

package/dist/lib/calculator/calculator.js

@@ -1,342 +1,342 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Calculator = void 0;
-const color_1 = require("../common/color");
-const entity_1 = require("../entity/entity");
-const bruce_variable_1 = require("../common/bruce-variable");
-const path_utils_1 = require("../util/path-utils");
-/**
- * Example: ${Test.Test1}
- * Needs to become ["Test", "Test1"].
- * We need to cull this in admin-ui.
- * @param path
- * @returns Possible paths this legacy one could mean.
- */
-function parseLegacyPath(path) {
-    if (!path) {
-        return [];
-    }
-    const paths = [];
-    if (path.startsWith("${") && path.endsWith("}")) {
-        path = path.replace("${", "");
-        path = path.replace("}", "");
-    }
-    // Split by dots.
-    paths.push(path_utils_1.PathUtils.ParseLegacy(path));
-    // Take string as is.
-    paths.push([path]);
-    // Split by backslashes.
-    paths.push(path_utils_1.PathUtils.Parse(path));
-    return paths;
-}
-/**
- * Utility for calculating values from Bruce fields.
- * These fields are typically found in entity styles.
- */
-var Calculator;
-(function (Calculator) {
-    let EValueType;
-    (function (EValueType) {
-        EValueType[EValueType["Color"] = 0] = "Color";
-        EValueType[EValueType["Input"] = 1] = "Input";
-        EValueType[EValueType["Gradient"] = 2] = "Gradient";
-        EValueType[EValueType["Mapping"] = 3] = "Mapping";
-        EValueType[EValueType["TagColor"] = 4] = "TagColor";
-        EValueType[EValueType["RandomColor"] = 5] = "RandomColor";
-    })(EValueType = Calculator.EValueType || (Calculator.EValueType = {}));
-    /**
-     * Calculates the value of arbitrary field options.
-     * The context calling this should validate results and parse stuff if needed.
-     * @deprecated use specific calls: eg GetColor or GetNumber.
-     * @param fields
-     * @param entity
-     * @param tags
-     * @returns
-     */
-    function GetValue(fields, entity, tags) {
-        if (!tags) {
-            tags = [];
-        }
-        if (!entity) {
-            entity = {};
-        }
-        for (let i = 0; i < fields.length; i++) {
-            const field = fields[i];
-            let value;
-            switch (field.type) {
-                case EValueType.Color:
-                    value = field.value;
-                    if (value) {
-                        value = color_1.Color.ColorFromStr(value);
-                    }
-                    break;
-                case EValueType.Gradient:
-                    value = GetGradientValue(field.value, entity);
-                    break;
-                case EValueType.Input:
-                    value = GetInputValue(field.value, entity);
-                    break;
-                case EValueType.Mapping:
-                    value = GetMappingValue(field.value, entity);
-                    break;
-                case EValueType.RandomColor:
-                    value = color_1.Color.RandomColor();
-                    break;
-                case EValueType.TagColor:
-                    for (let i = 0; i < tags.length; i++) {
-                        const tag = tags[i];
-                        if (tag.Color) {
-                            value = color_1.Color.ColorFromStr(tag.Color);
-                            break;
-                        }
-                    }
-                    break;
-            }
-            if (value || value == 0) {
-                return value;
-            }
-        }
-        return null;
-    }
-    Calculator.GetValue = GetValue;
-    /**
-     * Calculates the value of arbitrary field options with assumption that desired result is a color.
-     * Will return null if a color is not found.
-     * @param fields
-     * @param entity
-     * @param tags
-     */
-    function GetColor(fields, entity, tags) {
-        if (!tags) {
-            tags = [];
-        }
-        if (!entity) {
-            entity = {};
-        }
-        for (let i = 0; i < fields.length; i++) {
-            const field = fields[i];
-            let value;
-            switch (field.type) {
-                case EValueType.Color:
-                    value = field.value;
-                    break;
-                case EValueType.Gradient:
-                    value = GetGradientValue(field.value, entity);
-                    break;
-                case EValueType.Input:
-                    value = GetInputValue(field.value, entity);
-                    break;
-                case EValueType.Mapping:
-                    value = GetMappingValue(field.value, entity);
-                    break;
-                case EValueType.RandomColor:
-                    value = color_1.Color.RandomColor();
-                    break;
-                case EValueType.TagColor:
-                    for (let i = 0; i < tags.length; i++) {
-                        const tag = tags[i];
-                        if (tag.Color) {
-                            value = color_1.Color.ColorFromStr(tag.Color);
-                            break;
-                        }
-                    }
-                    break;
-            }
-            if (typeof value === "string") {
-                value = color_1.Color.ColorFromStr(value);
-            }
-            if (value && typeof value === "object" && (value.red || value.red == 0)) {
-                return value;
-            }
-        }
-        return null;
-    }
-    Calculator.GetColor = GetColor;
-    function GetNumber(fields, entity, tags) {
-        if (!tags) {
-            tags = [];
-        }
-        if (!entity) {
-            entity = {};
-        }
-        for (let i = 0; i < fields.length; i++) {
-            const field = fields[i];
-            let value;
-            switch (field.type) {
-                case EValueType.Gradient:
-                    value = GetGradientValue(field.value, entity);
-                    break;
-                case EValueType.Color:
-                case EValueType.Input:
-                    value = GetInputValue(field.value, entity);
-                    break;
-                case EValueType.Mapping:
-                    value = GetMappingValue(field.value, entity);
-                    break;
-            }
-            if (value != "" && value != null && value != undefined) {
-                value = Number(value);
-            }
-            if (value || value == 0) {
-                return value;
-            }
-        }
-        return null;
-    }
-    Calculator.GetNumber = GetNumber;
-    function GetString(fields, entity, tags) {
-        if (!tags) {
-            tags = [];
-        }
-        if (!entity) {
-            entity = {};
-        }
-        for (let i = 0; i < fields.length; i++) {
-            const field = fields[i];
-            let value;
-            switch (field.type) {
-                case EValueType.Gradient:
-                    value = String(GetGradientValue(field.value, entity));
-                    break;
-                case EValueType.Color:
-                case EValueType.Input:
-                    value = String(GetInputValue(field.value, entity));
-                    break;
-                case EValueType.Mapping:
-                    value = String(GetMappingValue(field.value, entity));
-                    break;
-                case EValueType.RandomColor:
-                    var color = color_1.Color.RandomColor();
-                    value = `rgba(${color.red},${color.green},${color.blue},${color.alpha})`;
-                    break;
-                case EValueType.TagColor:
-                    for (let i = 0; i < tags.length; i++) {
-                        const tag = tags[i];
-                        if (tag.Color) {
-                            value = tag.Color;
-                            break;
-                        }
-                    }
-                    break;
-            }
-            if (value) {
-                return value;
-            }
-        }
-        return null;
-    }
-    Calculator.GetString = GetString;
-    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
-            });
-            const isValueNum = !isNaN(+eValue);
-            for (let i = 0; i < value.values.length; i++) {
-                const option = value.values[i];
-                const mapValue = option.fieldValue;
-                const isMapValueNum = !isNaN(+mapValue);
-                if (isValueNum && isMapValueNum) {
-                    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;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    Calculator.GetMappingValue = GetMappingValue;
-    function GetGradientValue(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
-            });
-            eValue = Math.min(Math.max(eValue, value.min), value.max);
-            if (eValue < value.points[0].position) {
-                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[value.points.length - 1].color);
-    }
-    Calculator.GetGradientValue = GetGradientValue;
-    function GetInputValue(value, entity) {
-        if (typeof value == "string") {
-            try {
-                value = bruce_variable_1.BruceVariable.SwapValues({
-                    str: value,
-                    entity: entity
-                });
-                // Check if it includes a math operation.
-                const MATH_REGEX = /(\d+\.?\d*|\.\d+)([+\-*/])(\d+\.?\d*|\.\d+)/;
-                if (MATH_REGEX.test(value)) {
-                    // https://rollupjs.org/guide/en/#avoiding-eval
-                    // This stops eval warning.
-                    const eval2 = eval;
-                    return eval2(value);
-                }
-            }
-            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);
-                }
-            }
-        }
-        return value;
-    }
-    Calculator.GetInputValue = GetInputValue;
-})(Calculator = exports.Calculator || (exports.Calculator = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Calculator = void 0;
+const color_1 = require("../common/color");
+const entity_1 = require("../entity/entity");
+const bruce_variable_1 = require("../common/bruce-variable");
+const path_utils_1 = require("../util/path-utils");
+/**
+ * Example: ${Test.Test1}
+ * Needs to become ["Test", "Test1"].
+ * We need to cull this in admin-ui.
+ * @param path
+ * @returns Possible paths this legacy one could mean.
+ */
+function parseLegacyPath(path) {
+    if (!path) {
+        return [];
+    }
+    const paths = [];
+    if (path.startsWith("${") && path.endsWith("}")) {
+        path = path.replace("${", "");
+        path = path.replace("}", "");
+    }
+    // Split by dots.
+    paths.push(path_utils_1.PathUtils.ParseLegacy(path));
+    // Take string as is.
+    paths.push([path]);
+    // Split by backslashes.
+    paths.push(path_utils_1.PathUtils.Parse(path));
+    return paths;
+}
+/**
+ * Utility for calculating values from Bruce fields.
+ * These fields are typically found in entity styles.
+ */
+var Calculator;
+(function (Calculator) {
+    let EValueType;
+    (function (EValueType) {
+        EValueType[EValueType["Color"] = 0] = "Color";
+        EValueType[EValueType["Input"] = 1] = "Input";
+        EValueType[EValueType["Gradient"] = 2] = "Gradient";
+        EValueType[EValueType["Mapping"] = 3] = "Mapping";
+        EValueType[EValueType["TagColor"] = 4] = "TagColor";
+        EValueType[EValueType["RandomColor"] = 5] = "RandomColor";
+    })(EValueType = Calculator.EValueType || (Calculator.EValueType = {}));
+    /**
+     * Calculates the value of arbitrary field options.
+     * The context calling this should validate results and parse stuff if needed.
+     * @deprecated use specific calls: eg GetColor or GetNumber.
+     * @param fields
+     * @param entity
+     * @param tags
+     * @returns
+     */
+    function GetValue(fields, entity, tags) {
+        if (!tags) {
+            tags = [];
+        }
+        if (!entity) {
+            entity = {};
+        }
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            let value;
+            switch (field.type) {
+                case EValueType.Color:
+                    value = field.value;
+                    if (value) {
+                        value = color_1.Color.ColorFromStr(value);
+                    }
+                    break;
+                case EValueType.Gradient:
+                    value = GetGradientValue(field.value, entity);
+                    break;
+                case EValueType.Input:
+                    value = GetInputValue(field.value, entity);
+                    break;
+                case EValueType.Mapping:
+                    value = GetMappingValue(field.value, entity);
+                    break;
+                case EValueType.RandomColor:
+                    value = color_1.Color.RandomColor();
+                    break;
+                case EValueType.TagColor:
+                    for (let i = 0; i < tags.length; i++) {
+                        const tag = tags[i];
+                        if (tag.Color) {
+                            value = color_1.Color.ColorFromStr(tag.Color);
+                            break;
+                        }
+                    }
+                    break;
+            }
+            if (value || value == 0) {
+                return value;
+            }
+        }
+        return null;
+    }
+    Calculator.GetValue = GetValue;
+    /**
+     * Calculates the value of arbitrary field options with assumption that desired result is a color.
+     * Will return null if a color is not found.
+     * @param fields
+     * @param entity
+     * @param tags
+     */
+    function GetColor(fields, entity, tags) {
+        if (!tags) {
+            tags = [];
+        }
+        if (!entity) {
+            entity = {};
+        }
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            let value;
+            switch (field.type) {
+                case EValueType.Color:
+                    value = field.value;
+                    break;
+                case EValueType.Gradient:
+                    value = GetGradientValue(field.value, entity);
+                    break;
+                case EValueType.Input:
+                    value = GetInputValue(field.value, entity);
+                    break;
+                case EValueType.Mapping:
+                    value = GetMappingValue(field.value, entity);
+                    break;
+                case EValueType.RandomColor:
+                    value = color_1.Color.RandomColor();
+                    break;
+                case EValueType.TagColor:
+                    for (let i = 0; i < tags.length; i++) {
+                        const tag = tags[i];
+                        if (tag.Color) {
+                            value = color_1.Color.ColorFromStr(tag.Color);
+                            break;
+                        }
+                    }
+                    break;
+            }
+            if (typeof value === "string") {
+                value = color_1.Color.ColorFromStr(value);
+            }
+            if (value && typeof value === "object" && (value.red || value.red == 0)) {
+                return value;
+            }
+        }
+        return null;
+    }
+    Calculator.GetColor = GetColor;
+    function GetNumber(fields, entity, tags) {
+        if (!tags) {
+            tags = [];
+        }
+        if (!entity) {
+            entity = {};
+        }
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            let value;
+            switch (field.type) {
+                case EValueType.Gradient:
+                    value = GetGradientValue(field.value, entity);
+                    break;
+                case EValueType.Color:
+                case EValueType.Input:
+                    value = GetInputValue(field.value, entity);
+                    break;
+                case EValueType.Mapping:
+                    value = GetMappingValue(field.value, entity);
+                    break;
+            }
+            if (value != "" && value != null && value != undefined) {
+                value = Number(value);
+            }
+            if (value || value == 0) {
+                return value;
+            }
+        }
+        return null;
+    }
+    Calculator.GetNumber = GetNumber;
+    function GetString(fields, entity, tags) {
+        if (!tags) {
+            tags = [];
+        }
+        if (!entity) {
+            entity = {};
+        }
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            let value;
+            switch (field.type) {
+                case EValueType.Gradient:
+                    value = String(GetGradientValue(field.value, entity));
+                    break;
+                case EValueType.Color:
+                case EValueType.Input:
+                    value = String(GetInputValue(field.value, entity));
+                    break;
+                case EValueType.Mapping:
+                    value = String(GetMappingValue(field.value, entity));
+                    break;
+                case EValueType.RandomColor:
+                    var color = color_1.Color.RandomColor();
+                    value = `rgba(${color.red},${color.green},${color.blue},${color.alpha})`;
+                    break;
+                case EValueType.TagColor:
+                    for (let i = 0; i < tags.length; i++) {
+                        const tag = tags[i];
+                        if (tag.Color) {
+                            value = tag.Color;
+                            break;
+                        }
+                    }
+                    break;
+            }
+            if (value) {
+                return value;
+            }
+        }
+        return null;
+    }
+    Calculator.GetString = GetString;
+    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
+            });
+            const isValueNum = !isNaN(+eValue);
+            for (let i = 0; i < value.values.length; i++) {
+                const option = value.values[i];
+                const mapValue = option.fieldValue;
+                const isMapValueNum = !isNaN(+mapValue);
+                if (isValueNum && isMapValueNum) {
+                    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;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    Calculator.GetMappingValue = GetMappingValue;
+    function GetGradientValue(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
+            });
+            eValue = Math.min(Math.max(eValue, value.min), value.max);
+            if (eValue < value.points[0].position) {
+                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[value.points.length - 1].color);
+    }
+    Calculator.GetGradientValue = GetGradientValue;
+    function GetInputValue(value, entity) {
+        if (typeof value == "string") {
+            try {
+                value = bruce_variable_1.BruceVariable.SwapValues({
+                    str: value,
+                    entity: entity
+                });
+                // Check if it includes a math operation.
+                const MATH_REGEX = /(\d+\.?\d*|\.\d+)([+\-*/])(\d+\.?\d*|\.\d+)/;
+                if (MATH_REGEX.test(value)) {
+                    // https://rollupjs.org/guide/en/#avoiding-eval
+                    // This stops eval warning.
+                    const eval2 = eval;
+                    return eval2(value);
+                }
+            }
+            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);
+                }
+            }
+        }
+        return value;
+    }
+    Calculator.GetInputValue = GetInputValue;
+})(Calculator = exports.Calculator || (exports.Calculator = {}));
 //# sourceMappingURL=calculator.js.map