@hestia-earth/ui-components 0.43.33 → 0.43.34

package/fesm2022/hestia-earth-ui-components.mjs

@@ -7334,16 +7334,16 @@ const groupLog = (group, { logger, term, model, key, should_run, should_merge, r
 };
 const groupLogSubValue = (group, log, key) => {
     const id = log[key];
-    const data = groupLog(group[id] || {}, log);
-    group[id] = data;
-    if (subValueKeys.includes(key)) {
-        // add value to the same term/model on parent group
-        Object.entries(group[id]).map(([term, models]) => Object.keys(models).map(model => {
-            if (typeof group?.[term]?.[model] === 'object') {
-                group[term][model][key] = unique([...(group[term][model][key] || []), id]);
-            }
-        }));
-    }
+    group[id] = groupLog(group[id] || {}, log);
+    return group;
+};
+// add each subValue to the same term/model on the parent group
+const linkSubValues = (group, subValues) => {
+    subValues.forEach(([key, id]) => Object.entries(group[id]).forEach(([term, models]) => Object.keys(models).forEach(model => {
+        if (typeof group?.[term]?.[model] === 'object') {
+            group[term][model][key] = unique([...(group[term][model][key] || []), id]);
+        }
+    })));
     return group;
 };
 const csvValue = (value) => (value || '').replace('[', '').replace(']', '');
@@ -7353,50 +7353,64 @@ const parseLogMessage = (message) => {
         // Split on a comma (and optional space) ONLY if it's followed by "key="
         // \w+ matches alphanumeric characters and underscores (standard log keys)
         const pairs = data.message.split(/,\s*(?=\w+=)/);
-        return pairs.reduce((prev, parts) => {
-            // Use indexOf instead of split('=') just in case your values ever contain an '='
-            const firstEqualsIndex = parts.indexOf('=');
-            if (firstEqualsIndex === -1)
-                return prev;
-            const key = parts.substring(0, firstEqualsIndex).trim();
-            const value = parts.substring(firstEqualsIndex + 1).trim();
-            const val = csvValue(value);
-            return {
-                ...prev,
-                ...(key && val ? { [key]: val } : {})
-            };
-        }, { logger: data.logger });
+        return Object.fromEntries([
+            ['logger', data.logger],
+            ...pairs
+                // Use indexOf instead of split('=') just in case your values ever contain an '='
+                .map((parts) => [parts, parts.indexOf('=')])
+                .filter(([, index]) => index !== -1)
+                .map(([parts, index]) => [parts.substring(0, index).trim(), csvValue(parts.substring(index + 1).trim())])
+                .filter(([key, value]) => key && value)
+        ]);
     }
     catch {
         // make sure it works even if one log is malformed
         return {};
     }
 };
-const groupLogsByModel = (data = '', groupBySubValue = false, groupByAnimal = false) => data
-    .trim()
-    .split('\n')
-    .map(parseLogMessage)
-    .filter(v => [hasValue(v?.model), ['term', 'key', 'animalId'].some(k => hasValue(v?.[k]))].every(Boolean))
-    .reduce((group, log) => {
-    const subValue = subValueKeys.find(v => !!log[v] && log[v] != noValue);
-    return subValue && groupBySubValue && !log.cycle
-        ? groupLogSubValue(group, log, subValue)
-        : groupLog(group, log, groupByAnimal);
-}, {});
+const subValueOf = (log, groupBySubValue) => {
+    const key = groupBySubValue && !log.cycle ? subValueKeys.find(v => !!log[v] && log[v] != noValue) : undefined;
+    return key ? [key, log[key]] : undefined;
+};
+const groupLogsByModel = (data = '', groupBySubValue = false, groupByAnimal = false) => {
+    const logs = data
+        .trim()
+        .split('\n')
+        .map(parseLogMessage)
+        .filter(v => [hasValue(v?.model), ['term', 'key', 'animalId'].some(k => hasValue(v?.[k]))].every(Boolean));
+    const subValues = logs.map(log => subValueOf(log, groupBySubValue));
+    const group = logs.reduce((prev, log, index) => subValues[index] ? groupLogSubValue(prev, log, subValues[index][0]) : groupLog(prev, log, groupByAnimal), {});
+    const uniqueSubValues = [...new Map(subValues.filter(Boolean).map(v => [v.join('.'), v])).values()];
+    return linkSubValues(group, uniqueSubValues);
+};
 const logNodeFor = (node) => ({
     '@type': node['@type'],
     '@id': node['@id'],
     dataState: node.aggregated && node['@type'] !== NodeType.ImpactAssessment ? DataState.original : DataState.recalculated,
     dataVersion: node.dataVersion
 });
+const logsCacheSize = 3;
+const logsCacheKey = ({ '@type': type, '@id': id, dataState, dataVersion }, groupByAnimal) => [type, id, dataState, dataVersion, groupByAnimal].join('/');
+/**
+ * Store `value` as the most recent entry, dropping the oldest ones beyond `size`.
+ */
+const lruSet = (cache, key, value, size) => new Map([...[...cache].filter(([k]) => k !== key), [key, value]].slice(-size));
 class NodeLogsModelsService {
     constructor() {
         this.nodeService = inject(HeNodeService);
+        // parsing a large text log takes seconds, so keep the last few parsed logs for components showing the same node
+        this.logsCache = new Map();
     }
     getNodeLogs$(node, groupByAnimal = false) {
-        return this.nodeService
-            .getLog$(logNodeFor(node))
-            .pipe(map(logs => logs ? groupLogsByModel(logs, node['@type'] === NodeType.Cycle, groupByAnimal) : {}));
+        const key = logsCacheKey(logNodeFor(node), groupByAnimal);
+        const logs$ = this.logsCache.get(key) ?? this.fetchNodeLogs$(node, groupByAnimal, key);
+        this.logsCache = lruSet(this.logsCache, key, logs$, logsCacheSize);
+        return logs$;
+    }
+    fetchNodeLogs$(node, groupByAnimal, key) {
+        return this.nodeService.getLog$(logNodeFor(node)).pipe(map(logs => logs ? groupLogsByModel(logs, node['@type'] === NodeType.Cycle, groupByAnimal) : {}), 
+        // a failed request also ends up empty: do not keep it, so the next component retries
+        tap(logs => isEmpty(logs) && this.logsCache.delete(key)), shareReplay(1));
     }
     /**
      * Fetch the new `.jlog` (JSON) recalculation logs, following the representation of the node.