bruce-models 7.1.113 → 7.1.115

package/dist/bruce-models.umd.js

@@ -7097,11 +7097,18 @@
         function Update(params) {
             var _a, _b, _c, _d, _e, _f, _g;
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, entity: data, entities, override, req: reqParams, migrated } = params;
+                let { api, entity: data, entities, override, req: reqParams, migrated, skipSourcePush } = params;
                 if (migrated == null || migrated == undefined) {
                     // Changed to default = true. 18th April 2025.
                     migrated = true;
                 }
+                let skipSourcePushParam = null;
+                if (skipSourcePush === true) {
+                    skipSourcePushParam = "true";
+                }
+                else if (Array.isArray(skipSourcePush) && skipSourcePush.length) {
+                    skipSourcePushParam = skipSourcePush.join(",");
+                }
                 // Bulk save. Always using a v3 endpoint as v1 did not have a bulk save.
                 if (entities === null || entities === void 0 ? void 0 : entities.length) {
                     // If the Entities don't have IDs, then they must have a Type ID.
@@ -7116,7 +7123,10 @@
                     if (!api) {
                         api = exports.ENVIRONMENT.Api().GetBruceApi();
                     }
-                    const reqUrl = `v3/entities`;
+                    let reqUrl = "v3/entities";
+                    if (skipSourcePushParam) {
+                        reqUrl += `?SkipSourcePush=${encodeURIComponent(skipSourcePushParam)}`;
+                    }
                     const reqBody = {
                         Items: entities,
                         Override: override
@@ -7176,6 +7186,9 @@
                     if (!migrated) {
                         reqUrl += "&hasMigrated=false";
                     }
+                    if (skipSourcePushParam) {
+                        reqUrl += `&SkipSourcePush=${encodeURIComponent(skipSourcePushParam)}`;
+                    }
                     const res = yield api.POST(reqUrl, data, exports.Api.PrepReqParams(reqParams));
                     api.Cache.RemoveByContains(GetContainsKey(data.Bruce.ID));
                     exports.EntityHistoricData.ClearCacheByEntityIds(api, [data.Bruce.ID]);
@@ -8217,6 +8230,79 @@
             // Fallback to min (static, no data path resolved).
             return { result: exports.Color.ColorFromStr(points[0].color), attrPath: null, eValue: null };
         }
+        /**
+         * Lists every attribute path a set of fields could read from an entity record.
+         * Returns null when the fields depend on more than attribute values (tags, or a function).
+         * @param fields
+         */
+        function GetFieldPaths(fields) {
+            var _a, _b;
+            if (fields == null) {
+                return [];
+            }
+            const fieldsArr = Array.isArray(fields) ? fields : [fields];
+            const paths = [];
+            const seen = new Set();
+            const add = (path) => {
+                if (!path.length || path.some(segment => !segment || segment.includes("\""))) {
+                    return;
+                }
+                const key = JSON.stringify(path);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    paths.push(path);
+                }
+            };
+            // Mirrors BruceVariable.SwapValues, which reads every ${...} with PathUtils.Parse.
+            // TODO: expand BruceVariable to include a util for this instead of duping logic.
+            const addVariables = (template) => {
+                if (typeof template != "string") {
+                    return;
+                }
+                const variableRegex = /\${([^}]*)}/g;
+                let match;
+                while ((match = variableRegex.exec(template)) != null) {
+                    const pathStr = match[1].trim();
+                    if (pathStr) {
+                        add(exports.PathUtils.Parse(pathStr));
+                    }
+                }
+            };
+            for (const field of fieldsArr) {
+                if (field == null) {
+                    continue;
+                }
+                if (field.value instanceof Function) {
+                    return null;
+                }
+                switch (field.type) {
+                    case EValueType.Color:
+                    case EValueType.Input:
+                        addVariables(field.value);
+                        break;
+                    case EValueType.Gradient:
+                        parseLegacyPath((_a = field.value) === null || _a === void 0 ? void 0 : _a.field).forEach(add);
+                        break;
+                    case EValueType.Mapping:
+                        {
+                            const mapping = field.value;
+                            parseLegacyPath(mapping === null || mapping === void 0 ? void 0 : mapping.field).forEach(add);
+                            // A JS: row can read other attributes besides the mapped one.
+                            for (const option of (_b = mapping === null || mapping === void 0 ? void 0 : mapping.values) !== null && _b !== void 0 ? _b : []) {
+                                const fieldValues = Array.isArray(option.fieldValue) ? option.fieldValue : [option.fieldValue];
+                                fieldValues.filter(v => typeof v == "string" && v.startsWith("JS:")).forEach(addVariables);
+                            }
+                        }
+                        break;
+                    case EValueType.RandomColor:
+                        break;
+                    default:
+                        return null;
+                }
+            }
+            return paths;
+        }
+        Calculator.GetFieldPaths = GetFieldPaths;
         /**
          * Like Calculate, but also returns an 'effective' key describing how the value
          * was derived. See ITraceResult for the key format.
@@ -19541,9 +19627,16 @@
                     if (plugin.IsLoginRequired) {
                         headers[api.GetSessionHeader()] = api.GetSessionId();
                     }
+                    // A refusal must not be cached and run as if it were the plugin's code.
                     fileContentProm = fetch(indexFileUrl, {
                         headers: headers
-                    }).then((res) => res.text());
+                    }).then((res) => {
+                        if (!res.ok) {
+                            api.Cache.Remove(GetIndexFileCacheKey(pluginId, indexFileUrl));
+                            throw new Error(`Failed to load plugin "${pluginId}" (${res.status}).`);
+                        }
+                        return res.text();
+                    });
                     api.SetCacheItem({
                         key: GetIndexFileCacheKey(pluginId, indexFileUrl),
                         value: fileContentProm,
@@ -22523,12 +22616,27 @@
     })(exports.PendingAction || (exports.PendingAction = {}));
 
     (function (Tracking) {
+        /**
+         * Columns a transaction summary can be grouped by.
+         * Guardian groups by App, Account, Type and Count when none are given.
+         */
+        let ETransactionGroupBy;
+        (function (ETransactionGroupBy) {
+            ETransactionGroupBy["App"] = "App";
+            ETransactionGroupBy["Account"] = "Account";
+            ETransactionGroupBy["User"] = "User";
+            ETransactionGroupBy["Environment"] = "Environment";
+            ETransactionGroupBy["Type"] = "Type";
+            ETransactionGroupBy["Count"] = "Count";
+            ETransactionGroupBy["Month"] = "Month";
+        })(ETransactionGroupBy = Tracking.ETransactionGroupBy || (Tracking.ETransactionGroupBy = {}));
         /**
          * Returns tracking data based on provided parameters.
          * @param params
          * @returns
          */
         function GetData(params) {
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 let { api, req } = params;
                 if (!api) {
@@ -22541,6 +22649,9 @@
                 if (params.cType) {
                     query.append("CType", params.cType);
                 }
+                if (params.tType) {
+                    query.append("TType", params.tType);
+                }
                 if (params.tCount) {
                     query.append("TCount", params.tCount);
                 }
@@ -22550,12 +22661,27 @@
                 if (params.app) {
                     query.append("App", params.app);
                 }
+                if (params.environment) {
+                    query.append("Environment", params.environment);
+                }
+                if (params.includeDeleted != null) {
+                    query.append("IncludeDeleted", String(params.includeDeleted));
+                }
                 if (params.year) {
                     query.append("Year", String(params.year));
                 }
                 if (params.month) {
                     query.append("Month", String(params.month));
                 }
+                if (params.fromYear) {
+                    query.append("FromYear", String(params.fromYear));
+                }
+                if (params.fromMonth) {
+                    query.append("FromMonth", String(params.fromMonth));
+                }
+                if ((_a = params.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
+                    query.append("GroupBy", params.groupBy.join(","));
+                }
                 return yield api.GET("tracking?" + query.toString(), exports.Api.PrepReqParams(req));
             });
         }
@@ -24718,7 +24844,7 @@
     }
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.113";
+    const VERSION = "7.1.115";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;