@hestia-earth/ui-components 0.23.23 → 0.24.0-0

package/common/node-utils.d.ts

@@ -1,4 +1,24 @@
-import { Term, ICycleJSONLD, ISiteJSONLD, IImpactAssessmentJSONLD, EmissionMethodTier, ITermJSONLD, Completeness, Infrastructure, Emission, Measurement, Practice, Product, Input, Property, Indicator } from '@hestia-earth/schema';
+import { Term, ICycleJSONLD, ISiteJSONLD, IImpactAssessmentJSONLD, EmissionMethodTier, ITermJSONLD, Completeness, Emission, Measurement, Practice, Product, Input, Property, Indicator, Animal, Management, Transformation } from '@hestia-earth/schema';
+export type blankNode = Animal | Emission | Input | Product | Property | Practice | Indicator | Measurement | Management;
+export type blankNodesKey = 'animals' | 'emissions' | 'emissionsResourceUse' | 'endpoints' | 'impacts' | 'inputs' | 'management' | 'measurements' | 'products' | 'practices';
+export declare enum BlankNodesKey {
+    animals = "animals",
+    emissions = "emissions",
+    emissionsResourceUse = "emissionsResourceUse",
+    endpoints = "endpoints",
+    impacts = "impacts",
+    inputs = "inputs",
+    management = "management",
+    measurements = "measurements",
+    products = "products",
+    practices = "practices"
+}
+export declare const filterBlankNode: (filterTerm: string) => ({ term }: blankNode) => boolean;
+export type nonBlankNode = Completeness;
+export type nonBlankNodesKey = 'completeness';
+export declare enum NonBlankNodesKey {
+    completeness = "completeness"
+}
 export declare const ignoreKeys: string[];
 export declare const isValidKey: (key: string) => boolean;
 export declare const isMethodModelAllowed: (filterMethod?: Term) => (node: Indicator) => boolean;
@@ -9,7 +29,6 @@ export declare enum NodeKeyState {
     deleted = "deleted",
     unchanged = "unchanged"
 }
-export type blankNode = Completeness | Infrastructure | Input | Emission | Measurement | Practice | Product | Property;
 export declare const isState: (node: blankNode, key: string, state: NodeKeyState) => any;
 export interface IGroupedNode<T> {
     node: T;
@@ -58,4 +77,4 @@ export declare const grouppedKeys: <T>(values: {
 }[];
 export declare const methodTierOrder: (methodTier: EmissionMethodTier) => number;
 export declare const grouppedValueKeys: string[];
-export declare const groupNodesByTerm: <T extends ISiteJSONLD | ICycleJSONLD | IImpactAssessmentJSONLD, R>(nodes: T[], key: 'endpoints' | 'impacts' | 'emissionsResourceUse' | 'inputs' | 'products' | 'practices' | 'emissions' | 'measurements' | 'animals', originalValues?: T[], includeNode?: (_node: any) => boolean) => IGroupedNodes<R>;
+export declare const groupNodesByTerm: <T extends ISiteJSONLD | Transformation | Animal | ICycleJSONLD | IImpactAssessmentJSONLD, R>(nodes: T[], key: blankNodesKey, originalValues?: T[], includeNode?: (_node: any) => boolean) => IGroupedNodes<R>;

package/cycles/cycles-completeness/cycles-completeness.component.d.ts

@@ -1,35 +1,101 @@
-import { OnChanges, SimpleChanges } from '@angular/core';
 import { DataState } from '@hestia-earth/api';
-import { ICycleJSONLD } from '@hestia-earth/schema';
+import { ICycleJSONLD, NodeType } from '@hestia-earth/schema';
+import { HeNodeStoreService } from '../../node/node-store.service';
+import { NonBlankNodesKey } from '../../common/node-utils';
 import * as i0 from "@angular/core";
 declare enum View {
-    table = "table",
-    logs = "logs"
+    table = "Table view",
+    logs = "Recalculations logs"
 }
-export declare class CyclesCompletenessComponent implements OnChanges {
-    originalValues: ICycleJSONLD[];
-    cycles: ICycleJSONLD[];
-    dataState?: DataState;
-    baseUrl: string;
-    defaultLabel: (node?: any) => any;
-    keyToLabel: (key: string) => string;
-    getCompleteness: (cycle: any) => any;
-    headerKeys: string[];
-    showDownload: boolean;
-    View: typeof View;
-    selectedView: View;
-    selectedIndex: number;
-    ngOnChanges(changes: SimpleChanges): void;
-    trackById(_index: number, item: ICycleJSONLD): string;
-    get completenessKeys(): string[];
-    get isOriginal(): boolean;
-    private updateSelectedIndex;
-    selectIndex({ target: { value } }: {
+export declare class CyclesCompletenessComponent {
+    private nodeStoreService;
+    protected _dataState: import("@angular/core").WritableSignal<DataState>;
+    set dataState(value: DataState);
+    protected baseUrl: string;
+    protected defaultLabel: (node?: any) => any;
+    protected keyToLabel: (key: string) => string;
+    protected getCompleteness: (cycle: any) => any;
+    protected headerKeys: string[];
+    protected showDownload: boolean;
+    protected nodeKey: NonBlankNodesKey;
+    protected View: typeof View;
+    protected viewIcon: {
+        "Table view": string;
+        "Recalculations logs": string;
+    };
+    private showView;
+    protected views: import("@angular/core").Signal<View[]>;
+    protected selectedView: import("@angular/core").WritableSignal<View>;
+    private originalCycles;
+    private _allCycles;
+    protected cycles: import("@angular/core").Signal<ICycleJSONLD[]>;
+    private selectedIndex;
+    private ogirinalSelectedCycle;
+    private selectedCycle;
+    protected selectedLogsKey: import("@angular/core").Signal<any>;
+    protected selectedOriginalValues: import("@angular/core").Signal<any>;
+    protected selectedRecalculatedValues: import("@angular/core").Signal<any>;
+    protected selectedNode: import("@angular/core").Signal<{
+        '@type': NodeType;
+        type: NodeType;
+        dataState: DataState;
+        description?: string;
+        treatment?: string;
+        commercialPracticeTreatment?: boolean;
+        endDate?: string;
+        startDate?: string;
+        startDateDefinition?: import("@hestia-earth/schema").CycleStartDateDefinition;
+        cycleDuration?: number;
+        site?: import("@hestia-earth/schema").ISiteJSONLD;
+        otherSites?: import("@hestia-earth/schema").ISiteJSONLD[];
+        siteDuration?: number;
+        otherSitesDuration?: number[];
+        functionalUnit?: import("@hestia-earth/schema").CycleFunctionalUnit;
+        functionalUnitDetails?: string;
+        numberOfCycles?: number;
+        numberOfReplications?: number;
+        sampleWeight?: number;
+        harvestedArea?: number;
+        defaultMethodClassification?: import("@hestia-earth/schema").CycleDefaultMethodClassification;
+        defaultMethodClassificationDescription?: string;
+        defaultSource?: import("@hestia-earth/schema").ISourceJSONLD;
+        completeness?: import("@hestia-earth/schema").Completeness;
+        practices?: import("@hestia-earth/schema").Practice[];
+        animals?: import("@hestia-earth/schema").Animal[];
+        inputs?: import("@hestia-earth/schema").Input[];
+        products?: import("@hestia-earth/schema").Product[];
+        transformations?: import("@hestia-earth/schema").Transformation[];
+        emissions?: import("@hestia-earth/schema").Emission[];
+        dataPrivate?: boolean;
+        originalId?: string;
+        schemaVersion?: string;
+        added?: string[];
+        addedVersion?: string[];
+        updated?: string[];
+        updatedVersion?: string[];
+        aggregated?: boolean;
+        aggregatedVersion?: string;
+        aggregatedQualityScore?: number;
+        aggregatedQualityScoreMax?: number;
+        aggregatedCycles?: ICycleJSONLD[];
+        aggregatedSources?: import("@hestia-earth/schema").ISourceJSONLD[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        '@context': string | (string | import("@hestia-earth/schema").IContext)[];
+        '@id': string;
+        name: string;
+    }>;
+    protected hasData: import("@angular/core").Signal<number>;
+    protected isOriginal: import("@angular/core").Signal<boolean>;
+    protected completenessKeys: import("@angular/core").Signal<string[]>;
+    constructor(nodeStoreService: HeNodeStoreService);
+    protected trackById(_index: number, item: ICycleJSONLD): string;
+    protected selectIndex({ target: { value } }: {
         target: {
             value: any;
         };
     }): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CyclesCompletenessComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CyclesCompletenessComponent, "he-cycles-completeness", never, { "originalValues": { "alias": "originalValues"; "required": false; }; "cycles": { "alias": "cycles"; "required": false; }; "dataState": { "alias": "dataState"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CyclesCompletenessComponent, "he-cycles-completeness", never, { "dataState": { "alias": "dataState"; "required": false; }; }, {}, never, never, false, never>;
 }
 export {};

package/cycles/cycles-functional-unit-measure/cycles-functional-unit-measure.component.d.ts

@@ -1,8 +1,10 @@
 import { ICycleJSONLD, CycleFunctionalUnit } from '@hestia-earth/schema';
 import * as i0 from "@angular/core";
 export declare class CyclesFunctionalUnitMeasureComponent {
-    cycle?: ICycleJSONLD;
-    CycleFunctionalUnit: typeof CycleFunctionalUnit;
+    private _cycle;
+    set cycle(value: ICycleJSONLD);
+    protected functionalUnit: import("@angular/core").Signal<CycleFunctionalUnit>;
+    protected CycleFunctionalUnit: typeof CycleFunctionalUnit;
     static ɵfac: i0.ɵɵFactoryDeclaration<CyclesFunctionalUnitMeasureComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CyclesFunctionalUnitMeasureComponent, "he-cycles-functional-unit-measure", never, { "cycle": { "alias": "cycle"; "required": false; }; }, {}, never, never, false, never>;
 }

package/cycles/cycles-nodes/cycles-nodes.component.d.ts

@@ -0,0 +1,193 @@
+import { DataState } from '@hestia-earth/api';
+import { ICycleJSONLD, Input as HestiaInput, Product, NodeType, Animal, Emission, Practice, TermTermType, EmissionMethodTier, Term, Transformation } from '@hestia-earth/schema';
+import { BlankNodesKey, blankNode } from '../../common/node-utils';
+import { HeNodeStoreService } from '../../node/node-store.service';
+import { IGroupedKeys } from '../../common/node-utils';
+import * as i0 from "@angular/core";
+declare enum View {
+    table = "Table view",
+    chart = "Chart view",
+    timeline = "Operations Timeline",
+    logs = "Recalculations logs"
+}
+type groupedEmissions = {
+    [methodTier in EmissionMethodTier]: IGroupedKeys<Emission>[];
+};
+export declare enum CycleNodesKeyGroup {
+    animals = "animals",
+    transformations = "transformations"
+}
+type groupedNode = Animal | Transformation;
+export declare class CyclesNodesComponent {
+    private nodeStoreService;
+    protected _dataState: import("@angular/core").WritableSignal<DataState>;
+    set dataState(value: DataState);
+    protected BlankNodesKey: typeof BlankNodesKey;
+    protected firstNodeKey: import("@angular/core").Signal<BlankNodesKey>;
+    protected selectedNodeKey: import("@angular/core").WritableSignal<BlankNodesKey>;
+    protected _nodeKeys: import("@angular/core").WritableSignal<BlankNodesKey[]>;
+    set nodeKeys(value: BlankNodesKey[]);
+    protected selectedGroupTerm: import("@angular/core").WritableSignal<Term>;
+    protected _nodeKeyGroup: import("@angular/core").WritableSignal<CycleNodesKeyGroup>;
+    set nodeKeyGroup(value: CycleNodesKeyGroup);
+    protected baseUrl: string;
+    protected propertyValue: (value: string | number | (string | number)[], termId?: string) => number;
+    protected defaultLabel: (node?: any) => any;
+    protected showDownload: boolean;
+    protected headerKeys: import("@angular/core").Signal<string[]>;
+    protected View: typeof View;
+    protected viewIcon: {
+        "Table view": string;
+        "Chart view": string;
+        "Operations Timeline": string;
+        "Recalculations logs": string;
+    };
+    private showView;
+    protected views: import("@angular/core").Signal<View[]>;
+    protected selectedView: import("@angular/core").WritableSignal<View>;
+    private _allNodes;
+    private originalNodes;
+    private currentNodes;
+    protected originalCycles: import("@angular/core").Signal<ICycleJSONLD[] | groupedNode[]>;
+    protected cycles: import("@angular/core").Signal<ICycleJSONLD[] | groupedNode[]>;
+    private selectedIndex;
+    private ogirinalSelectedCycle;
+    private selectedCycle;
+    protected selectedLogsKey: import("@angular/core").Signal<any>;
+    protected selectedOriginalValues: import("@angular/core").Signal<any>;
+    protected selectedRecalculatedValues: import("@angular/core").Signal<any>;
+    protected selectedNode: import("@angular/core").Signal<{
+        '@type': NodeType;
+        type: NodeType;
+        dataState: DataState;
+        description?: string;
+        treatment?: string;
+        commercialPracticeTreatment?: boolean;
+        endDate?: string;
+        startDate?: string;
+        startDateDefinition?: import("@hestia-earth/schema").CycleStartDateDefinition;
+        cycleDuration?: number;
+        site?: import("@hestia-earth/schema").ISiteJSONLD;
+        otherSites?: import("@hestia-earth/schema").ISiteJSONLD[];
+        siteDuration?: number;
+        otherSitesDuration?: number[];
+        functionalUnit?: import("@hestia-earth/schema").CycleFunctionalUnit;
+        functionalUnitDetails?: string;
+        numberOfCycles?: number;
+        numberOfReplications?: number;
+        sampleWeight?: number;
+        harvestedArea?: number;
+        defaultMethodClassification?: import("@hestia-earth/schema").CycleDefaultMethodClassification;
+        defaultMethodClassificationDescription?: string;
+        defaultSource?: import("@hestia-earth/schema").ISourceJSONLD;
+        completeness?: import("@hestia-earth/schema").Completeness;
+        practices?: Practice[];
+        animals?: Animal[];
+        inputs?: HestiaInput[];
+        products?: Product[];
+        transformations?: Transformation[];
+        emissions?: Emission[];
+        dataPrivate?: boolean;
+        originalId?: string;
+        schemaVersion?: string;
+        added?: string[];
+        addedVersion?: string[];
+        updated?: string[];
+        updatedVersion?: string[];
+        aggregated?: boolean;
+        aggregatedVersion?: string;
+        aggregatedQualityScore?: number;
+        aggregatedQualityScoreMax?: number;
+        aggregatedCycles?: ICycleJSONLD[];
+        aggregatedSources?: import("@hestia-earth/schema").ISourceJSONLD[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        '@context': string | (string | import("@hestia-earth/schema").IContext)[];
+        '@id': string;
+        name: string;
+    } | {
+        '@type': NodeType;
+        type: NodeType;
+        dataState: DataState;
+        transformationId?: string;
+        term?: Term;
+        description?: string;
+        startDate?: string;
+        endDate?: string;
+        transformationDuration?: number;
+        previousTransformationId?: string;
+        transformedShare?: number;
+        site?: import("@hestia-earth/schema").Site;
+        inputs?: HestiaInput[];
+        emissions?: Emission[];
+        products?: Product[];
+        practices?: Practice[];
+        schemaVersion?: string;
+        added?: string[];
+        addedVersion?: string[];
+        updated?: string[];
+        updatedVersion?: string[];
+        id?: string;
+    } | {
+        '@type': NodeType;
+        type: NodeType;
+        dataState: DataState;
+        term?: Term;
+        description?: string;
+        referencePeriod?: import("@hestia-earth/schema").AnimalReferencePeriod;
+        value?: number;
+        sd?: number;
+        min?: number;
+        max?: number;
+        statsDefinition?: import("@hestia-earth/schema").AnimalStatsDefinition;
+        observations?: number;
+        price?: number;
+        currency?: string;
+        methodClassification?: import("@hestia-earth/schema").AnimalMethodClassification;
+        methodClassificationDescription?: string;
+        source?: import("@hestia-earth/schema").Source;
+        properties?: import("@hestia-earth/schema").Property[];
+        inputs?: HestiaInput[];
+        practices?: Practice[];
+        schemaVersion?: string;
+        added?: string[];
+        addedVersion?: string[];
+        updated?: string[];
+        updatedVersion?: string[];
+        aggregated?: string[];
+        aggregatedVersion?: string[];
+        id?: string;
+    }>;
+    private isOriginal;
+    private originalValues;
+    protected showSwitchToRecalculated: import("@angular/core").Signal<boolean>;
+    protected timelineValues: import("@angular/core").Signal<blankNode[]>;
+    private enableTimeline;
+    protected isNodeKeyAllowed: import("@angular/core").Signal<boolean>;
+    private groupedNodes;
+    protected groupNodeTerms: import("@angular/core").Signal<Term[]>;
+    protected isGroupNode: import("@angular/core").Signal<boolean>;
+    protected isEmission: import("@angular/core").Signal<boolean>;
+    protected data: import("@angular/core").Signal<groupedEmissions | {
+        [k: string]: IGroupedKeys<Product>[];
+    }>;
+    protected dataKeys: import("@angular/core").Signal<string[]>;
+    protected hasData: import("@angular/core").Signal<boolean>;
+    protected filterTermTypes: import("@angular/core").Signal<TermTermType[]>;
+    protected filterTerm: import("@angular/core").WritableSignal<string>;
+    protected csvFilename: import("@angular/core").Signal<string>;
+    constructor(nodeStoreService: HeNodeStoreService);
+    private groupNodesByKey;
+    private groupEmissions;
+    protected trackById(_index: number, item: ICycleJSONLD): string;
+    protected togglePopover(popover: any, context: any): any;
+    protected filterByTerm(term: string): void;
+    protected selectIndex({ target: { value } }: {
+        target: {
+            value: any;
+        };
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CyclesNodesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CyclesNodesComponent, "he-cycles-nodes", never, { "dataState": { "alias": "dataState"; "required": false; }; "nodeKeys": { "alias": "nodeKeys"; "required": false; }; "nodeKeyGroup": { "alias": "nodeKeyGroup"; "required": false; }; }, {}, never, never, false, never>;
+}
+export {};

package/cycles/cycles-nodes-timeline/cycles-nodes-timeline.component.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import { DataState } from '@hestia-earth/api';
+import { TermTermType } from '@hestia-earth/schema';
+import { blankNode } from '../../common/node-utils';
+import * as i0 from "@angular/core";
+export declare class CyclesNodesTimelineComponent {
+    private el;
+    private _recalculatedValues;
+    set recalculatedValues(value: blankNode[]);
+    protected _dataState: import("@angular/core").WritableSignal<DataState>;
+    set dataState(value: DataState);
+    protected now: Date;
+    protected TermTermType: typeof TermTermType;
+    protected blankNodes: import("@angular/core").Signal<blankNode[]>;
+    constructor(el: ElementRef);
+    trackByBlankNode(_index: number, { term }: blankNode): any;
+    get lineWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CyclesNodesTimelineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CyclesNodesTimelineComponent, "he-cycles-nodes-timeline", never, { "recalculatedValues": { "alias": "recalculatedValues"; "required": false; }; "dataState": { "alias": "dataState"; "required": false; }; }, {}, never, never, false, never>;
+}

package/cycles/cycles.module.d.ts

@@ -1,24 +1,17 @@
 import * as i0 from "@angular/core";
-import * as i1 from "./cycles-activity/cycles-activity.component";
-import * as i2 from "./cycles-activity-logs/cycles-activity-logs.component";
-import * as i3 from "./cycles-animals/cycles-animals.component";
-import * as i4 from "./cycles-completeness/cycles-completeness.component";
-import * as i5 from "./cycles-completeness-logs/cycles-completeness-logs.component";
-import * as i6 from "./cycles-emissions/cycles-emissions.component";
-import * as i7 from "./cycles-emissions-chart/cycles-emissions-chart.component";
-import * as i8 from "./cycles-emissions-logs/cycles-emissions-logs.component";
-import * as i9 from "./cycles-functional-unit-measure/cycles-functional-unit-measure.component";
-import * as i10 from "./cycles-practices/cycles-practices.component";
-import * as i11 from "./cycles-practices-logs/cycles-practices-logs.component";
-import * as i12 from "./cycles-practices-timeline/cycles-practices-timeline.component";
-import * as i13 from "./cycles-result/cycles-result.component";
-import * as i14 from "@angular/common";
-import * as i15 from "@angular/forms";
-import * as i16 from "../common/common.module";
-import * as i17 from "../node/node.module";
-import * as i18 from "../terms/terms.module";
+import * as i1 from "./cycles-completeness/cycles-completeness.component";
+import * as i2 from "./cycles-emissions-chart/cycles-emissions-chart.component";
+import * as i3 from "./cycles-functional-unit-measure/cycles-functional-unit-measure.component";
+import * as i4 from "./cycles-nodes/cycles-nodes.component";
+import * as i5 from "./cycles-nodes-timeline/cycles-nodes-timeline.component";
+import * as i6 from "./cycles-result/cycles-result.component";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/forms";
+import * as i9 from "../common/common.module";
+import * as i10 from "../node/node.module";
+import * as i11 from "../terms/terms.module";
 export declare class HeCyclesModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<HeCyclesModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<HeCyclesModule, [typeof i1.CyclesActivityComponent, typeof i2.CyclesActivityLogsComponent, typeof i3.CyclesAnimalsComponent, typeof i4.CyclesCompletenessComponent, typeof i5.CyclesCompletenessLogsComponent, typeof i6.CyclesEmissionsComponent, typeof i7.CyclesEmissionsChartComponent, typeof i8.CyclesEmissionsLogsComponent, typeof i9.CyclesFunctionalUnitMeasureComponent, typeof i10.CyclesPracticesComponent, typeof i11.CyclesPracticesLogsComponent, typeof i12.CyclesPracticesTimelineComponent, typeof i13.CyclesResultComponent], [typeof i14.CommonModule, typeof i15.FormsModule, typeof i16.HeCommonModule, typeof i17.HeNodeModule, typeof i18.HeTermsModule], [typeof i1.CyclesActivityComponent, typeof i2.CyclesActivityLogsComponent, typeof i3.CyclesAnimalsComponent, typeof i4.CyclesCompletenessComponent, typeof i5.CyclesCompletenessLogsComponent, typeof i6.CyclesEmissionsComponent, typeof i7.CyclesEmissionsChartComponent, typeof i8.CyclesEmissionsLogsComponent, typeof i9.CyclesFunctionalUnitMeasureComponent, typeof i10.CyclesPracticesComponent, typeof i11.CyclesPracticesLogsComponent, typeof i12.CyclesPracticesTimelineComponent, typeof i13.CyclesResultComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeCyclesModule, [typeof i1.CyclesCompletenessComponent, typeof i2.CyclesEmissionsChartComponent, typeof i3.CyclesFunctionalUnitMeasureComponent, typeof i4.CyclesNodesComponent, typeof i5.CyclesNodesTimelineComponent, typeof i6.CyclesResultComponent], [typeof i7.CommonModule, typeof i8.FormsModule, typeof i9.HeCommonModule, typeof i10.HeNodeModule, typeof i11.HeTermsModule], [typeof i1.CyclesCompletenessComponent, typeof i2.CyclesEmissionsChartComponent, typeof i3.CyclesFunctionalUnitMeasureComponent, typeof i4.CyclesNodesComponent, typeof i5.CyclesNodesTimelineComponent, typeof i6.CyclesResultComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<HeCyclesModule>;
 }

package/cycles/index.d.ts

@@ -1,15 +1,8 @@
 export * from './cycles.model';
 export * from './cycles.module';
-export { CyclesActivityComponent } from './cycles-activity/cycles-activity.component';
-export { CyclesActivityLogsComponent } from './cycles-activity-logs/cycles-activity-logs.component';
-export { CyclesAnimalsComponent } from './cycles-animals/cycles-animals.component';
 export { CyclesCompletenessComponent } from './cycles-completeness/cycles-completeness.component';
-export { CyclesCompletenessLogsComponent } from './cycles-completeness-logs/cycles-completeness-logs.component';
 export { CyclesEmissionsChartComponent } from './cycles-emissions-chart/cycles-emissions-chart.component';
-export { CyclesEmissionsLogsComponent } from './cycles-emissions-logs/cycles-emissions-logs.component';
-export { CyclesEmissionsComponent } from './cycles-emissions/cycles-emissions.component';
 export { CyclesFunctionalUnitMeasureComponent } from './cycles-functional-unit-measure/cycles-functional-unit-measure.component';
-export { CyclesPracticesComponent } from './cycles-practices/cycles-practices.component';
-export { CyclesPracticesLogsComponent } from './cycles-practices-logs/cycles-practices-logs.component';
-export { CyclesPracticesTimelineComponent } from './cycles-practices-timeline/cycles-practices-timeline.component';
+export { CyclesNodesComponent, CycleNodesKeyGroup } from './cycles-nodes/cycles-nodes.component';
+export { CyclesNodesTimelineComponent } from './cycles-nodes-timeline/cycles-nodes-timeline.component';
 export { CyclesResultComponent } from './cycles-result/cycles-result.component';

package/engine/engine.service.d.ts

@@ -102,7 +102,7 @@ export declare class HeEngineService {
     private init;
     private loadModels;
     private get models$();
-    models(includeEcoinvent?: boolean): Promise<IModel[]>;
+    allModels$(includeEcoinvent?: boolean): Observable<IModel[]>;
     model$(model: Partial<IModel>): Observable<IModel>;
     nodeModel$(node: Partial<blankNode>, key?: string): Observable<IModel>;
     model(model: Partial<IModel>): Promise<IModel>;
@@ -115,6 +115,7 @@ export declare class HeEngineService {
     getTermIds$(params: ICalculationsRequirementsParams): Observable<string[]>;
     getTermIds(params: ICalculationsRequirementsParams): Promise<any[] | string[]>;
     orchestratorConfigUrl(type?: NodeType): string;
+    ochestratorConfig$(type: NodeType, id?: string): Observable<IOrchestratorConfig>;
     ochestratorConfig(type: NodeType, id?: string): Promise<IOrchestratorConfig>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HeEngineService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HeEngineService>;

package/esm2022/common/node-utils.mjs

@@ -2,6 +2,24 @@ import get from 'lodash.get';
 import { EmissionMethodTier } from '@hestia-earth/schema';
 import { propertyValue } from '@hestia-earth/utils/dist/term';
 import { getDefaultModelId } from '@hestia-earth/glossary';
+export var BlankNodesKey;
+(function (BlankNodesKey) {
+    BlankNodesKey["animals"] = "animals";
+    BlankNodesKey["emissions"] = "emissions";
+    BlankNodesKey["emissionsResourceUse"] = "emissionsResourceUse";
+    BlankNodesKey["endpoints"] = "endpoints";
+    BlankNodesKey["impacts"] = "impacts";
+    BlankNodesKey["inputs"] = "inputs";
+    BlankNodesKey["management"] = "management";
+    BlankNodesKey["measurements"] = "measurements";
+    BlankNodesKey["products"] = "products";
+    BlankNodesKey["practices"] = "practices";
+})(BlankNodesKey || (BlankNodesKey = {}));
+export const filterBlankNode = (filterTerm) => ({ term }) => !filterTerm || term?.name?.toLowerCase()?.includes(filterTerm.toLowerCase());
+export var NonBlankNodesKey;
+(function (NonBlankNodesKey) {
+    NonBlankNodesKey["completeness"] = "completeness";
+})(NonBlankNodesKey || (NonBlankNodesKey = {}));
 export const ignoreKeys = ['@type', 'type', 'added', 'updated', 'addedVersion', 'updatedVersion'];
 export const isValidKey = (key) => !ignoreKeys.includes(key);
 export const isMethodModelAllowed = (filterMethod) => (node) => node.methodModel?.['@id'] === (filterMethod ? filterMethod['@id'] : getDefaultModelId(node.term?.['@id']));
@@ -91,4 +109,4 @@ export const groupNodesByTerm = (nodes = [], key, originalValues = [], includeNo
     });
     return groups;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-utils.js","sourceRoot":"","sources":["../../../src/common/node-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import get from 'lodash.get';\nimport {\n  Term,\n  ICycleJSONLD,\n  ISiteJSONLD,\n  IImpactAssessmentJSONLD,\n  EmissionMethodTier,\n  ITermJSONLD,\n  Completeness,\n  Infrastructure,\n  Emission,\n  Measurement,\n  Practice,\n  Product,\n  Input,\n  Property,\n  Indicator\n} from '@hestia-earth/schema';\nimport { propertyValue } from '@hestia-earth/utils/dist/term';\nimport { getDefaultModelId } from '@hestia-earth/glossary';\n\nexport const ignoreKeys = ['@type', 'type', 'added', 'updated', 'addedVersion', 'updatedVersion'];\n\nexport const isValidKey = (key: string) => !ignoreKeys.includes(key);\n\nexport const isMethodModelAllowed = (filterMethod?: Term) => (node: Indicator) =>\n  node.methodModel?.['@id'] === (filterMethod ? filterMethod['@id'] : getDefaultModelId(node.term?.['@id']));\n\nexport enum NodeKeyState {\n  added = 'added',\n  updated = 'updated',\n  aggregated = 'aggregated',\n  deleted = 'deleted',\n  unchanged = 'unchanged'\n}\n\nexport type blankNode = Completeness | Infrastructure | Input | Emission | Measurement | Practice | Product | Property;\n\nexport const isState = (node: blankNode, key: string, state: NodeKeyState) =>\n  state in node! && (typeof node![state] === 'boolean' ? node![state] : node![state].includes(key));\n\nexport interface IGroupedNode<T> {\n  // store the node with the highest \"state\"\n  node: T;\n  nodes: T[];\n  index: number;\n  value: number[];\n  dates?: any[];\n  sd?: number[];\n  min?: number[];\n  max?: number[];\n  inputs?: any[];\n  depthUpper?: number[];\n  depthLower?: number[];\n  startDate?: string[];\n  endDate?: string[];\n}\n\nexport interface IGroupedNodesValues<T> {\n  [nodeId: string]: IGroupedNode<T>;\n}\n\nexport interface IGroupedNodesValue<T> {\n  term: ITermJSONLD;\n  methodTier?: EmissionMethodTier;\n  /**\n   * Enable ordering ny methodTier\n   */\n  methodTierOrder: number;\n  values: IGroupedNodesValues<T>;\n  originalValues: {\n    [nodeId: string]: {\n      value: number;\n    };\n  };\n}\n\nexport interface IGroupedNodes<T> {\n  [termId: string]: IGroupedNodesValue<T>;\n}\n\nexport interface IGroupedKeys<T> {\n  key: string;\n  value: IGroupedNodesValue<T>;\n}\n\nexport const grouppedKeys = <T>(values: { [key: string]: T }): { key: string; value: T }[] =>\n  Object.entries(values).map(([key, value]) => ({ key, value }));\n\nconst concatBlankNodeValue = (value: any, newValue: any) => {\n  const valueArray = Array.isArray(value) ? value : [value];\n  const newValueArray = Array.isArray(newValue) ? newValue : [newValue];\n  return [...valueArray, ...newValueArray];\n};\n\nexport const methodTierOrder = (methodTier: EmissionMethodTier) =>\n  [\n    EmissionMethodTier.measured,\n    EmissionMethodTier['tier 3'],\n    EmissionMethodTier['tier 2'],\n    EmissionMethodTier['tier 1'],\n    EmissionMethodTier.background,\n    EmissionMethodTier['not relevant']\n  ].indexOf(methodTier);\n\nexport const grouppedValueKeys = [\n  'dates',\n  'sd',\n  'min',\n  'max',\n  'inputs',\n  'depthUpper',\n  'depthLower',\n  'startDate',\n  'endDate',\n  'methodTier',\n  'methodModel',\n  'model',\n  'method'\n];\n\nconst isHigherState = (sourceNode: blankNode, newNode: blankNode) =>\n  !sourceNode ||\n  isState(newNode, 'value', NodeKeyState.updated) ||\n  (!isState(sourceNode, 'value', NodeKeyState.updated) && isState(newNode, 'value', NodeKeyState.added));\n\nconst groupNodeKey = ({ term }: any) => term?.name || term?.['@id'];\n\nexport const groupNodesByTerm = <T extends ICycleJSONLD | IImpactAssessmentJSONLD | ISiteJSONLD, R>(\n  nodes: T[] = [],\n  key:\n    | 'endpoints'\n    | 'impacts'\n    | 'emissionsResourceUse'\n    | 'inputs'\n    | 'products'\n    | 'practices'\n    | 'emissions'\n    | 'measurements'\n    | 'animals',\n  originalValues: T[] = [],\n  includeNode = (_node: any) => true\n): IGroupedNodes<R> => {\n  const groups: IGroupedNodes<R> = nodes.reduce(\n    (prev, node, index) =>\n      (node[key] || []).reduce((group, blankNode) => {\n        // skip node based on condition\n        if (!includeNode(blankNode)) {\n          return group;\n        }\n\n        const nodeId = node['@id'];\n        const groupedKey = groupNodeKey(blankNode);\n        group[groupedKey] = group[groupedKey] || {\n          term: blankNode.term,\n          methodTier: blankNode.methodTier,\n          methodTierOrder: methodTierOrder(blankNode.methodTier),\n          values: {},\n          originalValues: {}\n        };\n        group[groupedKey].values[nodeId] = group[groupedKey].values[nodeId] || { index, nodes: [], value: [] };\n        group[groupedKey].values[nodeId].node = isHigherState(group[groupedKey].values[nodeId].node, blankNode)\n          ? blankNode\n          : group[groupedKey].values[nodeId].node;\n        group[groupedKey].values[nodeId].nodes.push(blankNode);\n        group[groupedKey].values[nodeId].value = concatBlankNodeValue(\n          group[groupedKey].values[nodeId].value,\n          blankNode.value\n        );\n        grouppedValueKeys.forEach(arrayKey => {\n          const newValue = get(blankNode, arrayKey, []);\n          group[groupedKey].values[nodeId][arrayKey] = [\n            ...(group[groupedKey].values[nodeId][arrayKey] || []),\n            ...(Array.isArray(newValue) ? newValue : [newValue])\n          ];\n        });\n        return group;\n      }, prev),\n    {} as IGroupedNodes<R>\n  );\n\n  // compile original values\n  Object.values(groups).map(group => {\n    Object.keys(group.values).map(nodeId => {\n      const { index } = group.values[nodeId];\n      const termId = group.term['@id'];\n      const originalValue = get(originalValues, `[${index}].${key}`, []).filter(\n        (val: any) => val.term['@id'] === termId\n      );\n      if (originalValue.length > 0) {\n        const value = originalValue.reduce((array: any[], curr: any) => concatBlankNodeValue(array, curr.value), []);\n        group.originalValues[nodeId] = { value: propertyValue(value, termId) };\n      }\n    });\n  });\n\n  return groups;\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-utils.js","sourceRoot":"","sources":["../../../src/common/node-utils.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,YAAY,CAAC;AAC7B,OAAO,EAKL,kBAAkB,EAanB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAyB3D,MAAM,CAAN,IAAY,aAWX;AAXD,WAAY,aAAa;IACvB,oCAAmB,CAAA;IACnB,wCAAuB,CAAA;IACvB,8DAA6C,CAAA;IAC7C,wCAAuB,CAAA;IACvB,oCAAmB,CAAA;IACnB,kCAAiB,CAAA;IACjB,0CAAyB,CAAA;IACzB,8CAA6B,CAAA;IAC7B,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;AACzB,CAAC,EAXW,aAAa,KAAb,aAAa,QAWxB;AAED,MAAM,CAAC,MAAM,eAAe,GAC1B,CAAC,UAAkB,EAAE,EAAE,CACvB,CAAC,EAAE,IAAI,EAAa,EAAE,EAAE,CACtB,CAAC,UAAU,IAAI,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,QAAQ,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;AAKjF,MAAM,CAAN,IAAY,gBAEX;AAFD,WAAY,gBAAgB;IAC1B,iDAA6B,CAAA;AAC/B,CAAC,EAFW,gBAAgB,KAAhB,gBAAgB,QAE3B;AAED,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,CAAC,CAAC;AAElG,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAErE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,YAAmB,EAAE,EAAE,CAAC,CAAC,IAAe,EAAE,EAAE,CAC/E,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAE7G,MAAM,CAAN,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,+BAAe,CAAA;IACf,mCAAmB,CAAA;IACnB,yCAAyB,CAAA;IACzB,mCAAmB,CAAA;IACnB,uCAAuB,CAAA;AACzB,CAAC,EANW,YAAY,KAAZ,YAAY,QAMvB;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,IAAe,EAAE,GAAW,EAAE,KAAmB,EAAE,EAAE,CAC3E,KAAK,IAAI,IAAK,IAAI,CAAC,OAAO,IAAK,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,IAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;AA+CpG,MAAM,CAAC,MAAM,YAAY,GAAG,CAAI,MAA4B,EAA+B,EAAE,CAC3F,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AAEjE,MAAM,oBAAoB,GAAG,CAAC,KAAU,EAAE,QAAa,EAAE,EAAE;IACzD,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC1D,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtE,OAAO,CAAC,GAAG,UAAU,EAAE,GAAG,aAAa,CAAC,CAAC;AAC3C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,UAA8B,EAAE,EAAE,CAChE;IACE,kBAAkB,CAAC,QAAQ;IAC3B,kBAAkB,CAAC,QAAQ,CAAC;IAC5B,kBAAkB,CAAC,QAAQ,CAAC;IAC5B,kBAAkB,CAAC,QAAQ,CAAC;IAC5B,kBAAkB,CAAC,UAAU;IAC7B,kBAAkB,CAAC,cAAc,CAAC;CACnC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AAExB,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,OAAO;IACP,IAAI;IACJ,KAAK;IACL,KAAK;IACL,QAAQ;IACR,YAAY;IACZ,YAAY;IACZ,WAAW;IACX,SAAS;IACT,YAAY;IACZ,aAAa;IACb,OAAO;IACP,QAAQ;CACT,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,UAAqB,EAAE,OAAkB,EAAE,EAAE,CAClE,CAAC,UAAU;IACX,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC;IAC/C,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AAEzG,MAAM,YAAY,GAAG,CAAC,EAAE,IAAI,EAAO,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AAEpE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAI9B,QAAa,EAAE,EACf,GAAkB,EAClB,iBAAsB,EAAE,EACxB,cAAc,CAAC,KAAU,EAAE,EAAE,CAAC,IAAI,EAChB,EAAE;IACpB,MAAM,MAAM,GAAqB,KAAK,CAAC,MAAM,CAC3C,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CACpB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;QAC5C,+BAA+B;QAC/B,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE;YAC3B,OAAO,KAAK,CAAC;SACd;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,UAAU,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;QAC3C,KAAK,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI;YACvC,IAAI,EAAE,SAAS,CAAC,IAAI;YACpB,UAAU,EAAE,SAAS,CAAC,UAAU;YAChC,eAAe,EAAE,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC;YACtD,MAAM,EAAE,EAAE;YACV,cAAc,EAAE,EAAE;SACnB,CAAC;QACF,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;QACvG,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC;YACrG,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC;QAC1C,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvD,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,GAAG,oBAAoB,CAC3D,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EACtC,SAAS,CAAC,KAAK,CAChB,CAAC;QACF,iBAAiB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YACnC,MAAM,QAAQ,GAAG,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC9C,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,GAAG;gBAC3C,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;gBACrD,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;aACrD,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC,EAAE,IAAI,CAAC,EACV,EAAsB,CACvB,CAAC;IAEF,0BAA0B;IAC1B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACrC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACvC,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjC,MAAM,aAAa,GAAG,GAAG,CAAC,cAAc,EAAE,IAAI,KAAK,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,CACvE,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,MAAM,CACzC,CAAC;YACF,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC5B,MAAM,KAAK,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,KAAY,EAAE,IAAS,EAAE,EAAE,CAAC,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7G,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC;aACxE;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC","sourcesContent":["import get from 'lodash.get';\nimport {\n  Term,\n  ICycleJSONLD,\n  ISiteJSONLD,\n  IImpactAssessmentJSONLD,\n  EmissionMethodTier,\n  ITermJSONLD,\n  Completeness,\n  Emission,\n  Measurement,\n  Practice,\n  Product,\n  Input,\n  Property,\n  Indicator,\n  Animal,\n  Management,\n  Transformation\n} from '@hestia-earth/schema';\nimport { propertyValue } from '@hestia-earth/utils/dist/term';\nimport { getDefaultModelId } from '@hestia-earth/glossary';\n\nexport type blankNode =\n  | Animal\n  | Emission\n  | Input\n  | Product\n  | Property\n  | Practice\n  | Indicator\n  | Measurement\n  | Management;\n\nexport type blankNodesKey =\n  | 'animals'\n  | 'emissions'\n  | 'emissionsResourceUse'\n  | 'endpoints'\n  | 'impacts'\n  | 'inputs'\n  | 'management'\n  | 'measurements'\n  | 'products'\n  | 'practices';\n\nexport enum BlankNodesKey {\n  animals = 'animals',\n  emissions = 'emissions',\n  emissionsResourceUse = 'emissionsResourceUse',\n  endpoints = 'endpoints',\n  impacts = 'impacts',\n  inputs = 'inputs',\n  management = 'management',\n  measurements = 'measurements',\n  products = 'products',\n  practices = 'practices'\n}\n\nexport const filterBlankNode =\n  (filterTerm: string) =>\n  ({ term }: blankNode) =>\n    !filterTerm || term?.name?.toLowerCase()?.includes(filterTerm.toLowerCase());\n\nexport type nonBlankNode = Completeness;\nexport type nonBlankNodesKey = 'completeness';\n\nexport enum NonBlankNodesKey {\n  completeness = 'completeness'\n}\n\nexport const ignoreKeys = ['@type', 'type', 'added', 'updated', 'addedVersion', 'updatedVersion'];\n\nexport const isValidKey = (key: string) => !ignoreKeys.includes(key);\n\nexport const isMethodModelAllowed = (filterMethod?: Term) => (node: Indicator) =>\n  node.methodModel?.['@id'] === (filterMethod ? filterMethod['@id'] : getDefaultModelId(node.term?.['@id']));\n\nexport enum NodeKeyState {\n  added = 'added',\n  updated = 'updated',\n  aggregated = 'aggregated',\n  deleted = 'deleted',\n  unchanged = 'unchanged'\n}\n\nexport const isState = (node: blankNode, key: string, state: NodeKeyState) =>\n  state in node! && (typeof node![state] === 'boolean' ? node![state] : node![state].includes(key));\n\nexport interface IGroupedNode<T> {\n  // store the node with the highest \"state\"\n  node: T;\n  nodes: T[];\n  index: number;\n  value: number[];\n  dates?: any[];\n  sd?: number[];\n  min?: number[];\n  max?: number[];\n  inputs?: any[];\n  depthUpper?: number[];\n  depthLower?: number[];\n  startDate?: string[];\n  endDate?: string[];\n}\n\nexport interface IGroupedNodesValues<T> {\n  [nodeId: string]: IGroupedNode<T>;\n}\n\nexport interface IGroupedNodesValue<T> {\n  term: ITermJSONLD;\n  methodTier?: EmissionMethodTier;\n  /**\n   * Enable ordering ny methodTier\n   */\n  methodTierOrder: number;\n  values: IGroupedNodesValues<T>;\n  originalValues: {\n    [nodeId: string]: {\n      value: number;\n    };\n  };\n}\n\nexport interface IGroupedNodes<T> {\n  [termId: string]: IGroupedNodesValue<T>;\n}\n\nexport interface IGroupedKeys<T> {\n  key: string;\n  value: IGroupedNodesValue<T>;\n}\n\nexport const grouppedKeys = <T>(values: { [key: string]: T }): { key: string; value: T }[] =>\n  Object.entries(values).map(([key, value]) => ({ key, value }));\n\nconst concatBlankNodeValue = (value: any, newValue: any) => {\n  const valueArray = Array.isArray(value) ? value : [value];\n  const newValueArray = Array.isArray(newValue) ? newValue : [newValue];\n  return [...valueArray, ...newValueArray];\n};\n\nexport const methodTierOrder = (methodTier: EmissionMethodTier) =>\n  [\n    EmissionMethodTier.measured,\n    EmissionMethodTier['tier 3'],\n    EmissionMethodTier['tier 2'],\n    EmissionMethodTier['tier 1'],\n    EmissionMethodTier.background,\n    EmissionMethodTier['not relevant']\n  ].indexOf(methodTier);\n\nexport const grouppedValueKeys = [\n  'dates',\n  'sd',\n  'min',\n  'max',\n  'inputs',\n  'depthUpper',\n  'depthLower',\n  'startDate',\n  'endDate',\n  'methodTier',\n  'methodModel',\n  'model',\n  'method'\n];\n\nconst isHigherState = (sourceNode: blankNode, newNode: blankNode) =>\n  !sourceNode ||\n  isState(newNode, 'value', NodeKeyState.updated) ||\n  (!isState(sourceNode, 'value', NodeKeyState.updated) && isState(newNode, 'value', NodeKeyState.added));\n\nconst groupNodeKey = ({ term }: any) => term?.name || term?.['@id'];\n\nexport const groupNodesByTerm = <\n  T extends ICycleJSONLD | IImpactAssessmentJSONLD | ISiteJSONLD | Animal | Transformation,\n  R\n>(\n  nodes: T[] = [],\n  key: blankNodesKey,\n  originalValues: T[] = [],\n  includeNode = (_node: any) => true\n): IGroupedNodes<R> => {\n  const groups: IGroupedNodes<R> = nodes.reduce(\n    (prev, node, index) =>\n      (node[key] || []).reduce((group, blankNode) => {\n        // skip node based on condition\n        if (!includeNode(blankNode)) {\n          return group;\n        }\n\n        const nodeId = node['@id'];\n        const groupedKey = groupNodeKey(blankNode);\n        group[groupedKey] = group[groupedKey] || {\n          term: blankNode.term,\n          methodTier: blankNode.methodTier,\n          methodTierOrder: methodTierOrder(blankNode.methodTier),\n          values: {},\n          originalValues: {}\n        };\n        group[groupedKey].values[nodeId] = group[groupedKey].values[nodeId] || { index, nodes: [], value: [] };\n        group[groupedKey].values[nodeId].node = isHigherState(group[groupedKey].values[nodeId].node, blankNode)\n          ? blankNode\n          : group[groupedKey].values[nodeId].node;\n        group[groupedKey].values[nodeId].nodes.push(blankNode);\n        group[groupedKey].values[nodeId].value = concatBlankNodeValue(\n          group[groupedKey].values[nodeId].value,\n          blankNode.value\n        );\n        grouppedValueKeys.forEach(arrayKey => {\n          const newValue = get(blankNode, arrayKey, []);\n          group[groupedKey].values[nodeId][arrayKey] = [\n            ...(group[groupedKey].values[nodeId][arrayKey] || []),\n            ...(Array.isArray(newValue) ? newValue : [newValue])\n          ];\n        });\n        return group;\n      }, prev),\n    {} as IGroupedNodes<R>\n  );\n\n  // compile original values\n  Object.values(groups).map(group => {\n    Object.keys(group.values).map(nodeId => {\n      const { index } = group.values[nodeId];\n      const termId = group.term['@id'];\n      const originalValue = get(originalValues, `[${index}].${key}`, []).filter(\n        (val: any) => val.term['@id'] === termId\n      );\n      if (originalValue.length > 0) {\n        const value = originalValue.reduce((array: any[], curr: any) => concatBlankNodeValue(array, curr.value), []);\n        group.originalValues[nodeId] = { value: propertyValue(value, termId) };\n      }\n    });\n  });\n\n  return groups;\n};\n"]}