bruce-models 4.9.9 → 5.0.0

package/dist/bruce-models.es5.js

@@ -4147,61 +4147,228 @@ var Calculator;
         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
+     * 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 GetValue(fields, entity, tags) {
-        if (!(fields === null || fields === void 0 ? void 0 : fields.length)) {
-            return null;
+    function Calculate(params) {
+        let { fields, tags, data, defaultValue, type } = params;
+        if (fields == null) {
+            return defaultValue;
+        }
+        if (data == null || typeof data != "object") {
+            data = {};
         }
-        if (!tags) {
+        if (tags == null || !Array.isArray(tags)) {
             tags = [];
         }
-        if (!entity) {
-            entity = {};
+        if (type == null) {
+            type = "any";
+        }
+        // Normalize fields to be an array of options.
+        let fieldsArr = [];
+        if (Array.isArray(fields)) {
+            fieldsArr = fields;
         }
-        for (let i = 0; i < fields.length; i++) {
-            const field = fields[i];
-            let value;
+        else {
+            fieldsArr = [fields];
+        }
+        // Indicator for old data.
+        // When a range is provided in older data, it is expected that invalid/failed mappings should default to the minimum value.
+        // We are deprecating this logic.
+        // The first step of deprecation is to avoid using this logic when multiple calculations are provided.
+        // TODO: When we've reviewed all existing uses, we can remove this logic entirely and just update the needed style records.
+        let shouldRangesDefaultToMin = true;
+        // This reduce totals the number of mappings and gradients.
+        // >1 means we should not default to min as there are multiple calculations.
+        if (fieldsArr.reduce((acc, field) => acc += (field.type == EValueType.Mapping || field.type == EValueType.Gradient) ? 1 : 0, 0) > 1) {
+            shouldRangesDefaultToMin = false;
+        }
+        const assertColor = (color) => {
+            if (color && typeof color == "string") {
+                color = Color.ColorFromStr(color);
+            }
+            if (color && typeof color == "object" && !isNaN(color.red) && color.red != null) {
+                return color;
+            }
+            return null;
+        };
+        const isColor = (value) => {
+            if (value && typeof value == "object" && !isNaN(value.red) && value.red != null) {
+                return true;
+            }
+            return false;
+        };
+        // Calculate the value.
+        let value = null;
+        for (let i = 0; i < fieldsArr.length; i++) {
+            let field = fieldsArr[i];
+            if (field) {
+                // Dereference.
+                // We do this because we'll be modifying the field to fix bad data.
+                field = JSON.parse(JSON.stringify(field));
+            }
+            // Bad data has it set to 'color' but expects the input to be a number.
+            if (type == "number" && field.type == EValueType.Color) {
+                field.type = EValueType.Input;
+            }
             switch (field.type) {
                 case EValueType.Color:
+                    if (type === "number") {
+                        break;
+                    }
                     value = field.value;
-                    if (value) {
-                        value = Color.ColorFromStr(value);
+                    value = assertColor(value);
+                    if (value && type == "string") {
+                        value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
                     }
                     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);
+                    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})`;
+                    }
                     break;
                 case EValueType.RandomColor:
+                    if (type === "number") {
+                        break;
+                    }
                     value = Color.RandomColor();
+                    value = assertColor(value);
+                    if (value && type == "string") {
+                        value = `rgba(${value.red},${value.green},${value.blue},${value.alpha})`;
+                    }
                     break;
                 case EValueType.TagColor:
+                    if (type === "number") {
+                        break;
+                    }
                     for (let i = 0; i < tags.length; i++) {
                         const tag = tags[i];
                         if (tag.Color) {
                             value = Color.ColorFromStr(tag.Color);
-                            break;
+                            value = assertColor(value);
+                            if (value) {
+                                break;
+                            }
+                        }
+                    }
+                    if (value && type == "string") {
+                        const cColor = value;
+                        value = `rgba(${cColor.red},${cColor.green},${cColor.blue},${cColor.alpha})`;
+                    }
+                    break;
+                // Input can be an arbitrary value.
+                // 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})`;
+                                }
+                                else {
+                                    value = null;
+                                }
+                            }
+                        }
+                        else if (type == "color") {
+                            value = assertColor(value);
+                        }
+                    }
+                    break;
+                // Mapping can be an arbitrary value.
+                // 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);
+                            }
+                            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;
             }
-            if (value || value == 0) {
-                return value;
+            // Extra layer of validation.
+            // This is a backup in case some branch above failed to convert into the right type.
+            if (type == "number") {
+                if (typeof value !== "number" || isNaN(value)) {
+                    value = null;
+                }
+            }
+            else if (type == "color") {
+                if (typeof value !== "object" || !value) {
+                    value = null;
+                }
+            }
+            else if (type == "string") {
+                if (typeof value !== "string" || !value) {
+                    value = null;
+                }
+            }
+            if (value != null) {
+                break;
             }
         }
-        return null;
+        // Return the value or default.
+        return value != null ? value : defaultValue;
+    }
+    Calculator.Calculate = Calculate;
+    /**
+     * Calculates the value of arbitrary field options.
+     * The context calling this should validate results and parse stuff if needed.
+     * @param fields
+     * @param entity
+     * @param tags
+     * @returns
+     */
+    function GetValue(fields, entity = {}, tags = []) {
+        return Calculate({
+            fields: fields,
+            data: entity,
+            defaultValue: null,
+            tags: tags,
+            type: "any"
+        });
     }
     Calculator.GetValue = GetValue;
     /**
@@ -4211,53 +4378,14 @@ var Calculator;
      * @param entity
      * @param tags
      */
-    function GetColor(fields, entity, tags) {
-        if (!(fields === null || fields === void 0 ? void 0 : fields.length)) {
-            return null;
-        }
-        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.RandomColor();
-                    break;
-                case EValueType.TagColor:
-                    for (let i = 0; i < tags.length; i++) {
-                        const tag = tags[i];
-                        if (tag.Color) {
-                            value = Color.ColorFromStr(tag.Color);
-                            break;
-                        }
-                    }
-                    break;
-            }
-            if (typeof value === "string") {
-                value = Color.ColorFromStr(value);
-            }
-            if (value && typeof value === "object" && (value.red || value.red == 0)) {
-                return value;
-            }
-        }
-        return null;
+    function GetColor(fields, entity = {}, tags = []) {
+        return Calculate({
+            fields: fields,
+            data: entity,
+            defaultValue: null,
+            tags: tags,
+            type: "color"
+        });
     }
     Calculator.GetColor = GetColor;
     /**
@@ -4268,39 +4396,14 @@ var Calculator;
      * @param tags
      * @returns
      */
-    function GetNumber(fields, entity, tags) {
-        if (!(fields === null || fields === void 0 ? void 0 : fields.length)) {
-            return null;
-        }
-        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;
+    function GetNumber(fields, entity = {}, tags = []) {
+        return Calculate({
+            fields: fields,
+            data: entity,
+            defaultValue: null,
+            tags: tags,
+            type: "number"
+        });
     }
     Calculator.GetNumber = GetNumber;
     /**
@@ -4311,68 +4414,14 @@ var Calculator;
      * @param tags
      * @returns
      */
-    function GetString(fields, entity, tags) {
-        if (!(fields === null || fields === void 0 ? void 0 : fields.length)) {
-            return null;
-        }
-        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:
-                    {
-                        const tmp = GetGradientValue(field.value, entity);
-                        // This avoids null turning into "null".
-                        if (tmp) {
-                            value = String(tmp);
-                        }
-                    }
-                    break;
-                case EValueType.Color:
-                case EValueType.Input:
-                    {
-                        const tmp = GetInputValue(field.value, entity);
-                        // This avoids null turning into "null".
-                        if (tmp) {
-                            value = String(tmp);
-                        }
-                    }
-                    break;
-                case EValueType.Mapping:
-                    {
-                        const tmp = GetMappingValue(field.value, entity);
-                        // This avoids null turning into "null".
-                        if (tmp) {
-                            value = String(tmp);
-                        }
-                    }
-                    break;
-                case EValueType.RandomColor:
-                    // Would be nice to randomize based on an attribute or entity ID instead of pure random.
-                    var color = 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;
+    function GetString(fields, entity = {}, tags = []) {
+        return Calculate({
+            fields: fields,
+            data: entity,
+            defaultValue: null,
+            tags: tags,
+            type: "string"
+        });
     }
     Calculator.GetString = GetString;
     /**
@@ -4440,9 +4489,11 @@ var Calculator;
      * It is intended to be parsed and validated within a value-type context. Eg: GetColor, GetNumber, GetString.
      * @param value
      * @param entity
+     * @param defaultToMin if a value fails to be calculated, should we default to the minimum value?
+     * Default is true for backwards compatibility.
      * @returns
      */
-    function GetGradientValue(value, entity) {
+    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);
@@ -14417,7 +14468,7 @@ var DataSource;
 })(DataSource || (DataSource = {}));
 
 // This is updated with the package.json version on build.
-const VERSION = "4.9.9";
+const VERSION = "5.0.0";
 
 export { VERSION, AnnDocument, CustomForm, AbstractApi, Api, BruceApi, GlobalApi, GuardianApi, ApiGetters, Calculator, Bounds, BruceEvent, CacheControl, Camera, Cartes, Carto, Color, DelayQueue, Geometry, UTC, BruceVariable, LRUCache, GeoJson, EntityAttachmentType, EntityAttachment, EntityComment, EntityLink, EntityLod, EntityLodCategory, EntityRelationType, EntityRelation, EntitySource, EntityTag, EntityType, Entity, EntityCoords, EntityTypeVisualSettings, EntityAttribute, EntityHistoricData, EntityTableView, Comment, ClientFile, ProgramKey, ZoomControl, MenuItem, ProjectViewBookmark, ProjectView, ProjectViewLegacyTile, ProjectViewTile, ProjectViewLegacy, ProjectViewLegacyBookmark, PendingAction, MessageBroker, HostingLocation, Style, Tileset, Permission, Session, UserGroup, User, Account, AccountInvite, AccountFeatures, AccountLimits, EncryptUtils, MathUtils, ObjectUtils, PathUtils, UrlUtils, DataLab, ImportAssembly, ImportCad, ImportCsv, ImportJson, ImportGeoJson, ImportKml, ImportedFile, Markup, Uploader, Plugin, ENVIRONMENT, DataSource };
 //# sourceMappingURL=bruce-models.es5.js.map