@hestia-earth/ui-components 0.42.10 → 0.42.11

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

@@ -9362,6 +9362,10 @@ const identitySpec = (type, nodeType, nodeKey) => {
     const properties = [...new Set([...(def.properties || []), ...parentFields])].filter((field) => !excludedIdentityFields.includes(field) && !relations.includes(field.split('.')[0]));
     return { def, properties, relations };
 };
+// some node keys distinguish blank nodes by their recorded `model` (e.g. an Indicator's `methodModel.@id`
+// is a uniqueness field): models that ran in parallel for the same term's value are then separate rows
+// (one per model), not extra model columns on a single row
+const modelIsUniquenessField = (spec) => spec.properties.includes('methodModel.@id');
 const isPresent = (value) => value !== undefined && value !== null && value !== '';
 // the joined uniqueness-field ids of each item in a relation (e.g. an emission's `inputs[].@id`)
 const relationItemIds = (items, fields) => Array.isArray(items)
@@ -9671,7 +9675,10 @@ const mapValueModel = (models, valueModelId, condition, update) => models.map(mo
  * When the value came from the original (no model, no config), the row shows no model.
  */
 // eslint-disable-next-line complexity -- orchestrates the value-model resolution (delegated to helpers)
-const valueModelRuns = (entry, value, originalValue, nodeType, termId, nodeKey, config) => {
+const valueModelRuns = (entry, value, originalValue, nodeType, termId, nodeKey, config, 
+// when the recorded `model` is a uniqueness field, parallel siblings are their own rows (see
+// `parallelSiblingRows`), so they are dropped from this value row's models
+splitParallelModels = false) => {
     const valueModelId = blankNodeModelId(value);
     const isRecalculated = isRecalculatedValue(value, originalValue);
     const hasOriginal = !!originalValue && typeof originalValue.value !== 'undefined';
@@ -9685,9 +9692,21 @@ const valueModelRuns = (entry, value, originalValue, nodeType, termId, nodeKey,
     const isValueLog = (log) => !isBackgroundLog(log) && !isSubRowOrchestrator(log?.orchestrator?.value, subRowValues);
     const valueLog = selectValueLog(logs, valueModelId, isValueLog, isRecalculated);
     const valueOrchestrator = valueLog?.orchestrator?.value;
-    const rawLogModels = valueLog
-        ? jLogModelRuns(logs.filter((log) => log?.orchestrator?.value === valueOrchestrator && !isBackgroundLog(log)), nodeType, termId, false)
-        : [];
+    const matchesValueOrchestrator = (log) => log?.orchestrator?.value === valueOrchestrator && !isBackgroundLog(log);
+    // keep the parallel grouping (a nested `logs` array): parallel siblings are independent, so a model
+    // that did not run failed rather than being "skipped" by a sibling that ran (a higher-tier hierarchy
+    // model). `jLogModelColumns` applies the pre-group success state to each parallel sibling; flatten the
+    // resulting columns back to the flat run list this function returns
+    const valueLogSteps = (entry?.logs || [])
+        .map((step) => Array.isArray(step) ? step.filter(matchesValueOrchestrator) : matchesValueOrchestrator(step) ? step : undefined)
+        .filter((step) => (Array.isArray(step) ? step.length > 0 : !!step));
+    const allLogModels = valueLog ? flattenColumns(jLogModelColumns(valueLogSteps, nodeType, termId, false)) : [];
+    // when models are split into their own rows, this value row keeps only its own model (parallel siblings
+    // become separate rows); otherwise parallel siblings stay as fallback/sibling columns on this row
+    const siblingIds = splitParallelModels
+        ? new Set(parallelSiblingLogs(entry, valueModelId).map((log) => log.model))
+        : new Set();
+    const rawLogModels = allLogModels.filter(model => !siblingIds.has(model.methodId));
     // the recorded value model (the blank node `methodModel`, e.g. `hestiaAggregatedData`) can differ from
     // the single orchestrator model in the logs (e.g. `linkedImpactAssessment`); relabel that run to the
     // recorded model so it shows under the expected name, but keep the orchestrator run's logs and its
@@ -9778,6 +9797,22 @@ const allSubRows = (entry, value, originalValue, nodeType, type, termId, getTerm
     ];
 };
 const flattenColumns = (columns) => columns.flatMap(column => (Array.isArray(column) ? column : [column]));
+// the distinct models (other than the value's own `model`) that ran in parallel with it - a nested
+// `logs` group holding more than one model. When `model` is a uniqueness field each becomes its own row,
+// so they are split off the value row (a sibling that did not win is its own failed/separate run, not a
+// fallback column). Keeps the first log per model.
+const parallelSiblingLogs = (entry, valueModelId) => {
+    const parallelGroups = (entry?.logs || []).filter((step) => Array.isArray(step) && new Set(step.filter((e) => !!e?.model).map((e) => e.model)).size > 1);
+    const byModel = new Map();
+    parallelGroups
+        .flat()
+        .filter((log) => !!log?.model && log.model !== valueModelId)
+        .forEach((log) => {
+        if (!byModel.has(log.model))
+            byModel.set(log.model, log);
+    });
+    return [...byModel.values()];
+};
 // a `<key>-failed` entry has no value: its identity/sub-rows are empty and the models that tried are
 // errors; parallel models (a nested `logs` array) are kept grouped (`modelColumns`) so they stack in one
 // column, while `models` stays flat for the status checks
@@ -9807,7 +9842,7 @@ const valueBlankNodeContent = (entry, value, originalValue, termId, { nodeType,
         subRows: allSubRows(entry, value, originalValue, nodeType, type, termId, getTerm || defaultGetTerm),
         isRecalculated: isRecalculatedValue(value, originalValue),
         recalculated: value ? [value] : [],
-        models: valueModelRuns(entry, value, originalValue, nodeType, termId, nodeKey, config)
+        models: valueModelRuns(entry, value, originalValue, nodeType, termId, nodeKey, config, modelIsUniquenessField(spec))
     };
 };
 const buildBlankNode = (entry, value, originalValue, index, term, isFailed, context) => {
@@ -9829,6 +9864,42 @@ const buildBlankNode = (entry, value, originalValue, index, term, isFailed, cont
             : valueBlankNodeContent(entry, value, originalValue, termId, context))
     };
 };
+// a parallel model that ran for a term's value but did not produce its own blank node (e.g. it failed,
+// while a sibling set the value). When `model` is a uniqueness field it is shown as its own row -
+// distinguished by its `methodModel`, with no value and a single model column carrying its status
+const buildParallelSiblingRow = (log, term, index, context) => {
+    const termId = term['@id'];
+    const run = toModelRun(log, jLogModelStatus(log, false, false), context.nodeType, termId);
+    // carry the model as a `methodModel` Term so the row is distinguished by a methodModel link (like a
+    // value row), resolved through the same `getTerm` the component uses for names; it has no `value`, so
+    // it contributes nothing to the group's combined value
+    const methodModel = context.getTerm?.(log.model) ?? { '@type': NodeType.Term, '@id': log.model };
+    const syntheticValue = { '@type': context.type, term, methodModel };
+    return {
+        index,
+        term,
+        termId,
+        type: context.type,
+        originalValue: null,
+        isOriginal: false,
+        isRequired: true,
+        isFailed: false,
+        original: [],
+        recalculatedValue: null,
+        identity: { 'methodModel.@id': log.model },
+        identityLabel: '',
+        identitySegments: [],
+        isRecalculated: false,
+        recalculated: [syntheticValue],
+        subRows: [],
+        models: [run],
+        modelColumns: [run],
+        // `allSucceeded` is recomputed by `withDisplayValues` at the end of the pipeline
+        allSucceeded: false,
+        canOpen: false,
+        isOpen: false
+    };
+};
 /**
  * Group the `.jlog` logs for one node key into rows, one per term, keeping every blank node distinct.
  *
@@ -9853,15 +9924,36 @@ const groupJLogByTerm = (jlog, nodeKey, recalculatedValues = [], originalValues
         const key = identityKey(blankNodeIdentity(value, spec));
         return (originalValues || []).find(original => original.term?.['@id'] === value.term?.['@id'] && identityKey(blankNodeIdentity(original, spec)) === key);
     };
+    // each recalculated blank node, attaching its `.jlog` logs when present (a node may exist without logs,
+    // e.g. a value provided in the original)
+    const valueEntries = (recalculatedValues || [])
+        .map((value, index) => ({ value, index, term: value?.term }))
+        .filter(({ term }) => !!term?.['@id']);
+    const valueNodes = valueEntries.map(({ value, index, term }) => buildBlankNode(keyLogs[index] || {}, value, matchOriginal(value), index, term, false, context));
+    // when the recorded `model` is a uniqueness field, models that ran in parallel for a term's value but
+    // produced no blank node (e.g. a sibling that failed while another set the value) are shown as their
+    // own rows - skipping any model already represented by a value row for that term (avoiding duplicates)
+    const seenModelsByTerm = new Map();
+    valueEntries.forEach(({ value, term }) => {
+        const set = seenModelsByTerm.get(term['@id']) ?? new Set();
+        const modelId = blankNodeModelId(value);
+        if (modelId)
+            set.add(modelId);
+        seenModelsByTerm.set(term['@id'], set);
+    });
+    let siblingIndex = recalculatedValues?.length ?? 0;
+    const siblingNodes = modelIsUniquenessField(spec)
+        ? valueEntries.flatMap(({ value, index, term }) => parallelSiblingLogs(keyLogs[index] || {}, blankNodeModelId(value)).flatMap(log => {
+            const seen = seenModelsByTerm.get(term['@id']);
+            if (seen?.has(log.model))
+                return [];
+            seen?.add(log.model);
+            return [buildParallelSiblingRow(log, term, siblingIndex++, context)];
+        }))
+        : [];
     const blankNodes = [
-        // list every blank node, attaching its `.jlog` logs when present (a node may exist without logs,
-        // e.g. a value provided in the original)
-        ...(recalculatedValues || []).map((value, index) => {
-            const term = value?.term;
-            return term?.['@id']
-                ? buildBlankNode(keyLogs[index] || {}, value, matchOriginal(value), index, term, false, context)
-                : null;
-        }),
+        ...valueNodes,
+        ...siblingNodes,
         ...Object.entries(failedLogs).map(([termId, entry], i) => buildBlankNode(entry, undefined, undefined, -1 - i, getTerm(termId), true, context))
     ].filter(Boolean);
     return orderGroups(groupBlankNodesByTerm(blankNodes).map(withCollapsible).map(withRowLabels).map(withDisplayValues), nodeKey);
@@ -10089,7 +10181,9 @@ class NodeJLogModelsComponent {
             if (!this.isBlankNodes()) {
                 return groupJLogByField(this.scopedJlog(), this.nodeKey(), this.originalValues(), this.recalculatedValues(), this.nodeType());
             }
-            const groups = groupJLogByTerm(this.scopedJlog(), this.nodeKey(), this.recalculatedValues(), this.originalValues(), this.nodeType(), id => this.failedTerms()[id] || { '@type': NodeType.Term, '@id': id, name: termTypeLabel(id) }, this.config());
+            const groups = groupJLogByTerm(this.scopedJlog(), this.nodeKey(), this.recalculatedValues(), this.originalValues(), this.nodeType(), id => this.failedTerms()[id] ||
+                this.methodsById()?.[id] ||
+                { '@type': NodeType.Term, '@id': id, name: termTypeLabel(id) }, this.config());
             // a combined node key (e.g. `emissionsResourceUse`) holds several term types; keep only the requested
             // ones (like the legacy `computeTerms`), keeping terms whose type is not yet resolved
             const termTypes = this.filterTermTypes();