@hestia-earth/ui-components 0.41.35 → 0.41.36

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

@@ -6,7 +6,7 @@ import { FormsModule, NG_VALUE_ACCESSOR, UntypedFormBuilder, Validators, Reactiv
 import { NgClass, DecimalPipe, NgTemplateOutlet, KeyValuePipe, DOCUMENT, PlatformLocation, NgStyle, UpperCasePipe, JsonPipe, DatePipe, AsyncPipe, formatDate as formatDate$1 } from '@angular/common';
 import * as i1$1 from '@ng-bootstrap/ng-bootstrap';
 import { NgbTooltip, NgbDropdown, NgbDropdownMenu, NgbDropdownToggle, NgbActiveModal, NgbHighlight, NgbModal, NgbDropdownItem, NgbTypeahead, NgbPopover, NgbTooltipModule, NgbDropdownModule, NgbPopoverModule } from '@ng-bootstrap/ng-bootstrap';
-import { ReplaySubject, of, mergeMap, shareReplay, delay, map, catchError, distinctUntilChanged, timer, take, first, Subject, combineLatest, filter, tap, pipe, fromEvent, startWith, merge, skip, switchMap, EMPTY, throttleTime, animationFrameScheduler, debounceTime, lastValueFrom, skipUntil, zip, forkJoin, from, reduce, firstValueFrom, mergeAll, toArray, distinct, groupBy } from 'rxjs';
+import { ReplaySubject, of, mergeMap, shareReplay, delay, map, catchError, distinctUntilChanged, timer, take, first, Subject, combineLatest, filter, tap, pipe, fromEvent, startWith, merge, skip, switchMap, EMPTY, throttleTime, animationFrameScheduler, debounceTime, lastValueFrom, skipUntil, zip, mergeAll, groupBy, toArray, forkJoin, from, reduce, firstValueFrom, distinct } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
 import get from 'lodash.get';
 import { SCHEMA_VERSION, SchemaType, NodeType, TermTermType, productTermTermType, nestedSearchableKeys, SiteSiteType, EmissionMethodTier, isExpandable, sortKeysByType, isTypeNode, BlankNodesKey, impactAssessmentTermTermType, measurementTermTermType, emissionTermTermType, inputTermTermType, CycleFunctionalUnit, NonBlankNodesKey, jsonldPath, isTypeValid, isTypeBlankNode, typeToSchemaType, infrastructureTermTermType, managementTermTermType } from '@hestia-earth/schema';
@@ -2872,6 +2872,7 @@ const icons = [
     'greenhouse',
     'guide',
     'guide-overlay',
+    'heart',
     'help',
     'help-circle',
     'history',
@@ -2912,6 +2913,8 @@ const icons = [
     'private-eye',
     'private-eye-crossed',
     'private-lock',
+    'private-lock-filled',
+    'private-unlocked',
     'profile-checkmark',
     'profile-circle',
     'profile-gear',
@@ -7055,8 +7058,50 @@ class HeNodeService {
                 .pipe(catchError(() => of('')))
             : this.http.get(url, { params }).pipe(catchError(() => of({})));
     }
-    getContributions$(node) {
-        return this.http.get(`${this.nodeUrl(node)}/contributions`);
+    getContributions$({ dataState, ...impactAssessment }) {
+        return this.http.get(`${this.nodeUrl(impactAssessment)}/contributions`).pipe(mergeMap(contributions => isEmpty(contributions) ? this.getContributionsFromLog$(impactAssessment) : of(contributions)), catchError(() => this.getContributionsFromLog$(impactAssessment)));
+    }
+    getContributionsFromLog$(impactAssessment) {
+        return this.getLog$({ ...impactAssessment, dataState: DataState.recalculated }).pipe(map(value => (value ? parseLines(value) : [])), mergeAll(), filter(({ data }) => data.logger === 'hestia_earth.models' && data.level === Level.debug), filter(({ data: { message } }) => !!message), map(({ data: { message } }) => parseMessage(message)), filter(message => 'node' in message), map(data => ({
+            modelId: data.model,
+            impactTermId: data['key/term'] || data.term || data.indicator,
+            blankNodeTermId: data.node,
+            coefficient: +data.coefficient
+        })), filter(log => !!log.impactTermId && !!log.blankNodeTermId && !isNaN(log.coefficient)), groupBy(log => [log.impactTermId, log.blankNodeTermId, log.modelId].join('/')), mergeMap(group => group.pipe(toArray())), map((logs) => {
+            const log = logs[0];
+            const coefficient = sum(logs.map(l => l.coefficient));
+            return {
+                ...log,
+                coefficient
+            };
+        }), toArray(), map((logs) => {
+            const emissionsResourceUse = impactAssessment.emissionsResourceUse || [];
+            const impacts = impactAssessment.impacts || [];
+            const result = {
+                emissionsResourceUse: {},
+                impacts: {}
+            };
+            logs.forEach(log => {
+                emissionsResourceUse.forEach((entry, index) => {
+                    if (entry.term?.['@id'] === log.blankNodeTermId) {
+                        const key = index.toString();
+                        result.emissionsResourceUse[key] = result.emissionsResourceUse[key] || {};
+                        result.emissionsResourceUse[key][log.impactTermId] =
+                            result.emissionsResourceUse[key][log.impactTermId] || {};
+                        result.emissionsResourceUse[key][log.impactTermId][log.modelId] = toPrecision((entry.value || 0) * log.coefficient, 5);
+                    }
+                });
+                impacts.forEach((entry, index) => {
+                    if (entry.term?.['@id'] === log.blankNodeTermId) {
+                        const key = index.toString();
+                        result.impacts[key] = result.impacts[key] || {};
+                        result.impacts[key][log.impactTermId] = result.impacts[key][log.impactTermId] || {};
+                        result.impacts[key][log.impactTermId][log.modelId] = toPrecision((entry.value || 0) * log.coefficient, 5);
+                    }
+                });
+            });
+            return result;
+        }));
     }
     getErrorLog$({ dataState, aggregated, ...node }) {
         return this.http.get(`${this.nodeUrl(node)}/log/error`, {
@@ -7696,7 +7741,7 @@ const parseLogMultipleValue = (values) => values
     .map(v => (v.filter(Boolean).length === 2 ? v.join(':') : null))
     .filter(Boolean)
     .join('_');
-const parseLog$3 = (log) => ['value' in log, 'coefficient' in log, 'node' in log || 'operation' in log].every(Boolean)
+const parseLog$1 = (log) => ['value' in log, 'coefficient' in log, 'node' in log || 'operation' in log].every(Boolean)
     ? {
         [log.node || log.operation]: parseLogMultipleValue([
             ['value', log.value],
@@ -7766,7 +7811,7 @@ const groupLog = (group, { logger, term, model, key, should_run, should_merge, r
     else if (!isOrchestrator) {
         data.logs = {
             ...(data.logs || {}),
-            ...parseLog$3(log)
+            ...parseLog$1(log)
         };
     }
     if (typeof should_merge !== 'undefined') {
@@ -8515,8 +8560,8 @@ const filterLogValueArray = (value) => {
             ? null
             : values;
 };
-const parseLog$2 = (key, value) => parseLogCompleteness(key, value) || { key, value: filterLogValueArray(value) };
-const parseLogs = (logs) => Object.entries(logs).map(([key, value]) => parseLog$2(key, value));
+const parseLog = (key, value) => parseLogCompleteness(key, value) || { key, value: filterLogValueArray(value) };
+const parseLogs = (logs) => Object.entries(logs).map(([key, value]) => parseLog(key, value));
 class NodeLogsModelsLogsComponent {
     constructor() {
         this.logs = input.required(...(ngDevMode ? [{ debugName: "logs" }] : []));
@@ -8528,7 +8573,7 @@ class NodeLogsModelsLogsComponent {
         this.requirementKeys = computed(() => requirementKeys(this.requirements()), ...(ngDevMode ? [{ debugName: "requirementKeys" }] : []));
         this.missingLookups = computed(() => this.logs().missingLookups ?? [], ...(ngDevMode ? [{ debugName: "missingLookups" }] : []));
         this.allLogs = computed(() => [
-            ...requirementKeys(this.requirements()).map(key => parseLog$2(key, this.requirements()[key])),
+            ...requirementKeys(this.requirements()).map(key => parseLog(key, this.requirements()[key])),
             ...parseLogs(this.logs()?.logs ?? {})
         ].filter(v => v.value !== null), ...(ngDevMode ? [{ debugName: "allLogs" }] : []));
     }
@@ -13747,24 +13792,9 @@ const searchParams = (should) => ({
         }
     }
 });
-const parseLog$1 = (data) => ({
-    indicator: data['key/term'] || data.term || data.indicator,
-    contributor: data.node,
-    coefficient: +data.coefficient,
-    modelId: data.model || 'Unknown',
-    weightedValue: +data.value * +data.coefficient,
-    value: +data.value
-});
 const defaultIndicatorsModelId = 'defaultIndicatorsModelId';
 const defaultIndicatorsModelName = 'Default Indicators (multi-model)';
 const warnings = (logs, terms) => [!logs.every(log => terms[log.indicator] && terms[log.contributor]) && 'missing-terms'].filter(Boolean);
-const filterLog = (indicators, log) => [
-    !!log.indicator,
-    !!log.contributor,
-    !isNaN(log.weightedValue),
-    log.coefficient > 0,
-    indicators.some(eru => eru.term['@id'] === log.indicator)
-].every(Boolean);
 const parseLogValues = (impactAssessment, values) => {
     const log = values[0];
     const { weightedTotal, total } = values.reduce((prev, curr) => ({
@@ -13804,7 +13834,40 @@ const parseLogValues = (impactAssessment, values) => {
     const inputs = Object.values(inputsObj);
     return { ...log, weightedValue: weightedTotal, value: total, inputs };
 };
-const parseNodeLogs$ = (impactAssessment, indicators, lines) => from(lines).pipe(filter(({ data }) => data.logger === 'hestia_earth.models' && data.level === Level.debug), filter(({ data: { message } }) => !!message), map(({ data: { message } }) => parseMessage(message)), filter(message => 'node' in message), map(data => parseLog$1(data)), filter(log => filterLog(indicators, log)), groupBy(log => [log.indicator, log.contributor, log.modelId].join('/')), mergeMap(group => group.pipe(toArray())), map(data => parseLogValues(impactAssessment, data)), toArray());
+const processContributions$1 = (record, nodes) => Object.entries(record || {}).flatMap(([index, contributions]) => {
+    const indicator = nodes[+index];
+    return indicator
+        ? Object.entries(contributions).flatMap(([impactTermId, modelContr]) => Object.entries(modelContr).map(([modelId, weightedValue]) => {
+            const contributor = indicator.term['@id'];
+            const value = indicator.value || 0;
+            const coefficient = value !== 0 ? weightedValue / value : 0;
+            // only get contributions with positive coefficient
+            return coefficient > 0
+                ? {
+                    indicator: impactTermId,
+                    contributor,
+                    coefficient,
+                    modelId,
+                    weightedValue,
+                    value
+                }
+                : null;
+        }))
+        : null;
+});
+const parseContributions$1 = (impactAssessment, contributions) => {
+    const allLogs = [
+        ...processContributions$1(contributions.emissionsResourceUse, impactAssessment.emissionsResourceUse || []),
+        ...processContributions$1(contributions.impacts, impactAssessment.impacts || [])
+    ].filter(Boolean);
+    const grouped = allLogs.reduce((acc, log) => {
+        const key = [log.indicator, log.contributor, log.modelId].join('/');
+        acc[key] = acc[key] || [];
+        acc[key].push(log);
+        return acc;
+    }, {});
+    return Object.values(grouped).map(logs => parseLogValues(impactAssessment, logs));
+};
 class ImpactAssessmentsGraphComponent {
     constructor() {
         this.searchService = inject(HeSearchService);
@@ -13830,32 +13893,19 @@ class ImpactAssessmentsGraphComponent {
             ...(this.selectedImpactAssessment()?.impacts ?? [])
         ], ...(ngDevMode ? [{ debugName: "indicators" }] : []));
         this.nodeLogsResource = rxResource({
-            params: () => ({ selectedImpactAssessment: this.selectedImpactAssessment() }),
-            stream: ({ params: { selectedImpactAssessment } }) => isEmpty(selectedImpactAssessment)
-                ? of([])
-                : this.nodeService
-                    .getLog$({
-                    ...selectedImpactAssessment,
-                    dataState: DataState.recalculated
-                })
-                    .pipe(map(value => (value ? parseLines(value) : [])))
-        });
-        this.parsedNodeLogsResource = rxResource({
             params: () => ({
-                isRecalculated: this.isRecalculated(),
-                logs: this.nodeLogsResource.value(),
-                indicators: this.indicators(),
-                impactAssessment: this.selectedImpactAssessment()
+                selectedImpactAssessment: this.selectedImpactAssessment(),
+                isRecalculated: this.isRecalculated()
             }),
-            stream: ({ params: { isRecalculated, logs, indicators, impactAssessment } }) => [!!logs?.length, isRecalculated, !!indicators?.length].every(Boolean)
-                ? parseNodeLogs$(impactAssessment, indicators, logs).pipe(catchError(err => {
+            stream: ({ params: { selectedImpactAssessment, isRecalculated } }) => !selectedImpactAssessment || !isRecalculated
+                ? of([])
+                : this.nodeService.getContributions$(selectedImpactAssessment).pipe(map(contributions => parseContributions$1(selectedImpactAssessment, contributions)), catchError(err => {
                     console.error(err);
                     this.error.set(err.toString());
                     return of([]);
                 }))
-                : of([])
         });
-        this.nodeLogs = computed(() => this.parsedNodeLogsResource.value() ?? [], ...(ngDevMode ? [{ debugName: "nodeLogs" }] : []));
+        this.nodeLogs = computed(() => this.nodeLogsResource.value() ?? [], ...(ngDevMode ? [{ debugName: "nodeLogs" }] : []));
         this.logTermIds = computed(() => unique(this.nodeLogs()
             .flatMap(l => [l.contributor, l.indicator, ...l.inputs.map(i => i.id)])
             .filter(termId => !this.initialTerms()?.[termId])), ...(ngDevMode ? [{ debugName: "logTermIds" }] : []));
@@ -13888,7 +13938,7 @@ class ImpactAssessmentsGraphComponent {
             (this.selectedModelId() === defaultIndicatorsModelId
                 ? getDefaultModelId(log.indicator)
                 : this.selectedModelId())), ...(ngDevMode ? [{ debugName: "chartData" }] : []));
-        this.loading = computed(() => [this.parsedNodeLogsResource.isLoading(), this.allTermsResource.isLoading()].some(Boolean), ...(ngDevMode ? [{ debugName: "loading" }] : []));
+        this.loading = computed(() => [this.nodeLogsResource.isLoading(), this.allTermsResource.isLoading()].some(Boolean), ...(ngDevMode ? [{ debugName: "loading" }] : []));
         this.showChart = computed(() => [!isEmpty(this.chartData()), !isEmpty(this.allTerms()), !this.loading(), !this.error(), !this.showWarnings()].every(Boolean), ...(ngDevMode ? [{ debugName: "showChart" }] : []));
         effect(() => {
             const defaultId = this.filteredImpactAssessments()?.[0]?.['@id'];
@@ -13934,24 +13984,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
                 }]
         }] });
 
-const parseLog = (data) => ({
-    modelId: data.model,
-    impactTermId: data['key/term'] || data.term || data.indicator,
-    blankNodeTermId: data.node,
-    coefficient: +data.coefficient,
-    value: +data.value * +data.coefficient
-});
 const filterTermTypes = [TermTermType.emission, TermTermType.characterisedIndicator];
-const csvHeaders = [
-    'Impact',
-    'Impact Unit',
-    'Method',
-    'Emission',
-    'Value',
-    'Inputs',
-    'Inputs value',
-    'Functional Unit'
-];
 const logsTotalValue = (logs, includeNegativeValues) => sum((includeNegativeValues ? logs : logs.filter(curr => curr.value >= 0)).map(v => v.value));
 const valueRatio = (value, total) => (total === 0 ? 0 : toPrecision((value * 100) / total, 2));
 const chartLabel = (value, total) => {
@@ -13963,15 +13996,50 @@ const chartBreakdownLabel = (logs, total, maxValues) => {
     return values.map(({ blankNodeTermId, value }) => `${blankNodeTermId}: ${chartLabel(value, total)}`).join('</br>');
 };
 const logToCsv = (logs, impact) => [
-    csvHeaders.join(','),
+    ['Impact', 'Impact Unit', 'Method', 'Emission', 'Value', 'Inputs', 'Functional Unit'].join(','),
     ...logs
         .sort((a, b) => a.impactTermId.localeCompare(b.impactTermId))
-        .flatMap(({ impactTermId, impactTermUnits, modelId, blankNodeTermId, value, inputs }) => [
-        [impactTermId, impactTermUnits, modelId, blankNodeTermId, value, '', ''],
-        ...inputs.map(v => [impactTermId, impactTermUnits, modelId, blankNodeTermId, '', v.name, v.value])
-    ])
-        .map(v => [...v, impact.product?.term?.units].join(','))
+        .map(({ impactTermId, impactTermUnits, modelId, blankNodeTermId, value, inputs }) => [
+        impactTermId,
+        impactTermUnits,
+        modelId,
+        blankNodeTermId,
+        value,
+        inputs.join(';'),
+        impact.product?.term?.units
+    ].join(','))
 ].join('\n');
+const processContributions = (record, nodes, impacts) => Object.entries(record || {}).flatMap(([index, impactContr]) => {
+    const indicator = nodes[+index];
+    return indicator
+        ? Object.entries(impactContr).flatMap(([impactTermId, modelContr]) => {
+            const impact = impacts?.find(v => v.term['@id'] === impactTermId);
+            return (impact &&
+                Object.entries(modelContr).map(([modelId, value]) => {
+                    const inputs = (indicator.inputs || []).map(v => v['@id']);
+                    return {
+                        modelId,
+                        impactTermId,
+                        impactTermUnits: impact.term?.units,
+                        blankNodeTermId: indicator.term['@id'],
+                        value: toPrecision(value, 3),
+                        inputs
+                    };
+                }));
+        })
+        : null;
+});
+const parseContributions = (impactAssessment, contributions) => [
+    ...processContributions(contributions.emissionsResourceUse, impactAssessment.emissionsResourceUse || [], impactAssessment?.impacts || []),
+    ...processContributions(contributions.impacts, impactAssessment.impacts || [], impactAssessment?.endpoints || [])
+].filter(Boolean);
+const groupLogsById = (logs) => Object.values(logs.reduce((prev, log) => {
+    const key = log.blankNodeTermId;
+    prev[key] = prev[key] || { ...log, value: 0 };
+    prev[key].value += log.value;
+    prev[key].inputs = unique([...prev[key].inputs, ...(log.inputs || [])]);
+    return prev;
+}, {}));
 class ImpactAssessmentsIndicatorBreakdownChartComponent {
     constructor() {
         this.searchService = inject(HeSearchService);
@@ -13985,42 +14053,16 @@ class ImpactAssessmentsIndicatorBreakdownChartComponent {
         this.selectedCategory = signal(undefined, ...(ngDevMode ? [{ debugName: "selectedCategory" }] : []));
         this.logsResource = rxResource({
             params: () => ({
-                impactAssessment: this.impactAssessment(),
-                impacts: this.impacts()
+                impactAssessment: this.impactAssessment()
             }),
-            stream: ({ params: { impactAssessment, impacts } }) => impactAssessment
-                ? this.nodeService.getLog$({ ...impactAssessment, dataState: DataState.recalculated }).pipe(map(value => (value ? parseLines(value) : [])), mergeAll(), filter(({ data }) => data.logger === 'hestia_earth.models' && data.level === Level.debug), filter(({ data: { message } }) => !!message), map(({ data: { message } }) => parseMessage(message)), filter(message => 'node' in message), map(parseLog), filter(log => !!log.impactTermId && !!log.blankNodeTermId && !isNaN(log.value)), groupBy(log => [log.impactTermId, log.blankNodeTermId, log.modelId].join('/')), mergeMap(group => group.pipe(toArray())), map((values) => {
-                    const log = values[0];
-                    const total = logsTotalValue(values, true);
-                    const blankNodes = [
-                        ...(impactAssessment?.emissionsResourceUse ?? []),
-                        ...(impactAssessment?.impacts ?? [])
-                    ].filter(v => v.term['@id'] === log.blankNodeTermId);
-                    const inputs = blankNodes
-                        .filter(v => v.inputs?.length)
-                        .map(v => ({
-                        name: v.inputs.map(i => i['@id']).join(';'),
-                        value: toPrecision(v.value * log.coefficient, 3)
-                    }));
-                    const inputsValue = inputs.reduce((prev, curr) => prev + curr.value, 0);
-                    const impact = impacts?.find(v => v.term['@id'] === log.impactTermId);
-                    // logs might exist but impact was not added => skip logs
-                    return impact
-                        ? {
-                            ...log,
-                            impactTermUnits: impact.term?.units,
-                            value: toPrecision(total, 3),
-                            inputs,
-                            inputsValue
-                        }
-                        : undefined;
-                }), filter(log => !!log), toArray())
-                : of([])
+            stream: ({ params: { impactAssessment } }) => this.nodeService
+                .getContributions$(impactAssessment)
+                .pipe(map(contributions => parseContributions(impactAssessment, contributions)))
         });
         this.logs = computed(() => (this.logsResource.value() ?? [])
             .filter(({ impactTermId, modelId }) => impactTermId === this.selectedTermId() && (!this.selectedMethodId() || modelId === this.selectedMethodId()))
             .sort((a, b) => b.value - a.value), ...(ngDevMode ? [{ debugName: "logs" }] : []));
-        this.nonZeroLogs = computed(() => this.logs().filter(log => log.value !== 0), ...(ngDevMode ? [{ debugName: "nonZeroLogs" }] : []));
+        this.nonZeroLogs = computed(() => groupLogsById(this.logs()).filter(log => log.value !== 0), ...(ngDevMode ? [{ debugName: "nonZeroLogs" }] : []));
         this.emissions = toSignal(this.searchService
             .search$({
             fields: ['@type', '@id', 'name'],
@@ -14046,10 +14088,6 @@ class ImpactAssessmentsIndicatorBreakdownChartComponent {
             .filter(Boolean)
             .filter(value => this.logs().some(log => log.modelId === value['@id']))), ...(ngDevMode ? [{ debugName: "methods" }] : []));
         this.selectedMethod = computed(() => this.methods().find(term => term['@id'] == this.selectedMethodId()), ...(ngDevMode ? [{ debugName: "selectedMethod" }] : []));
-        this.impacts = computed(() => [
-            ...(this.impactAssessment()?.impacts || []),
-            ...(this.impactAssessment()?.endpoints || [])
-        ], ...(ngDevMode ? [{ debugName: "impacts" }] : []));
         this.noData = computed(() => this.nonZeroLogs()?.length === 0, ...(ngDevMode ? [{ debugName: "noData" }] : []));
         this.values = computed(() => this.nonZeroLogs().map((value, index) => ({
             ...value,
@@ -14291,8 +14329,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
 var View$1;
 (function (View) {
     View["table"] = "Table";
-    View["chart"] = "Chart";
     View["breakdown"] = "Breakdown";
+    View["chart"] = "Compare";
     View["logs"] = "Recalculations logs";
 })(View$1 || (View$1 = {}));
 const viewIcon$1 = {