bruce-models 7.1.113 → 7.1.114

package/dist/bruce-models.umd.js

@@ -8217,6 +8217,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 +19614,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,
@@ -24718,7 +24798,7 @@
     }
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.113";
+    const VERSION = "7.1.114";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;