@hestia-earth/ui-components 0.0.1

package/esm2015/common/toast.service.js

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+let toastId = 0;
+export class ToastService {
+    constructor() {
+        this.toasts = new ReplaySubject(1);
+    }
+    success(message, duration = 3000) {
+        this.toasts.next({
+            id: ++toastId,
+            message,
+            duration,
+            color: 'success',
+            showRawMessage: true
+        });
+    }
+    error(message, showRawMessage = true, duration = 3000) {
+        this.toasts.next({
+            id: ++toastId,
+            message: (`${message}` || '').trim(),
+            duration,
+            color: 'danger',
+            showRawMessage
+        });
+    }
+}
+ToastService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ToastService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToastService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/common/unit-converter/unit-converter.component.js

@@ -0,0 +1,73 @@
+import { Component, Input } from '@angular/core';
+import { ConvertUnits, converters, convertValue, isNumber, isBoolean } from '@hestia-earth/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../clipboard/clipboard.component";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+import * as i4 from "../keys.pipe";
+const parsePropertyValue = (value) => isNumber(value) ? +value : (isBoolean(value) ? value.toString() === 'true' : value);
+const parseResult = (value) => isNaN(value) ? '' : `${value}`.replace(',', '.');
+export class UnitConverterComponent {
+    constructor() {
+        this.value = 1;
+        this.ConvertUnits = ConvertUnits;
+        this.result = '';
+        this.arguments = [];
+    }
+    ngOnInit() {
+        return this.updateValue();
+    }
+    get args() {
+        var _a;
+        return (((_a = this.term) === null || _a === void 0 ? void 0 : _a.defaultProperties) || []).reduce((prev, prop) => {
+            var _a, _b;
+            return (Object.assign(Object.assign({}, prev), { [(_b = (_a = prop.term) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()]: parsePropertyValue(prop.value) }));
+        }, {});
+    }
+    get units() {
+        return this.fromUnits ?
+            Object.values(ConvertUnits).filter(v => v in converters[this.fromUnits]) :
+            [];
+    }
+    requireArgs(keys) {
+        const args = this.args;
+        this.arguments = keys.map(key => ({ key, value: args[key] || '' }));
+    }
+    updateUnits() {
+        let requiredKeys = [];
+        if (this.fromUnits === ConvertUnits.kg || this.toUnits === ConvertUnits.kg) {
+            requiredKeys = ['density'];
+        }
+        this.requireArgs(requiredKeys);
+        return this.updateValue();
+    }
+    updateValue() {
+        if (!this.fromUnits || !this.toUnits) {
+            return;
+        }
+        const args = Object.assign(Object.assign({}, this.args), this.arguments.reduce((prev, { key, value }) => (Object.assign(Object.assign({}, prev), { [key]: value })), {}));
+        try {
+            this.result = parseResult(convertValue(this.value, this.fromUnits, this.toUnits, args));
+        }
+        catch (_) { }
+    }
+}
+UnitConverterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: UnitConverterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+UnitConverterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: UnitConverterComponent, selector: "he-unit-converter", inputs: { term: "term", value: "value", fromUnits: "fromUnits", toUnits: "toUnits" }, ngImport: i0, template: "<div class=\"columns mb-0\">\n  <div class=\"column\">\n    <label class=\"label has-text-white\" for=\"value\">Value</label>\n  </div>\n  <div class=\"column\">\n    <label class=\"label has-text-white\" for=\"result\">Convert To</label>\n  </div>\n</div>\n\n<div class=\"columns\">\n  <div class=\"column\">\n    <div class=\"field has-addons\">\n      <div class=\"control\">\n        <input type=\"number\" class=\"input\" [(ngModel)]=\"value\" name=\"value\" id=\"value\"\n          (input)=\"updateValue()\"\n        >\n      </div>\n      <div class=\"control is-expanded\">\n        <div class=\"select is-fullwidth\">\n          <select [(ngModel)]=\"fromUnits\" name=\"fromUnits\" id=\"fromUnits\"\n            (change)=\"updateUnits()\"\n          >\n            <option [value]=\"undefined\">Unit</option>\n            <option *ngFor=\"let unit of ConvertUnits | keys\" [value]=\"unit.value\">{{unit.key}}</option>\n          </select>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"column\">\n    <div class=\"field has-addons\">\n      <div class=\"control\">\n        <input type=\"string\" class=\"input\" [value]=\"result\" name=\"result\" id=\"result\" readonly>\n      </div>\n      <div class=\"control\">\n        <div class=\"select is-fullwidth\">\n          <select [(ngModel)]=\"toUnits\" name=\"toUnits\" id=\"toUnits\"\n            (change)=\"updateUnits()\"\n          >\n            <option [value]=\"undefined\">Unit</option>\n            <option *ngFor=\"let unit of units\" [value]=\"unit\">{{unit}}</option>\n          </select>\n        </div>\n      </div>\n      <div class=\"control\">\n        <he-clipboard clipboardClass=\"button is-white px-2\"\n          [value]=\"result\" [disabled]=\"!result\" [hideText]=\"true\"\n        ></he-clipboard>\n      </div>\n    </div>\n  </div>\n</div>\n\n<div class=\"field is-horizontal\" *ngFor=\"let arg of arguments\">\n  <div class=\"field-label is-normal\">\n    <label class=\"label has-text-white\" [for]=\"arg.key\">\n      <span class=\"is-capitalized\">{{arg.key}}</span>\n      <span class=\"has-text-danger pl-1\">*</span>\n    </label>\n  </div>\n  <div class=\"field-body\">\n    <div class=\"field\">\n      <div class=\"control\">\n        <input type=\"string\" class=\"input is-small\"\n          [(ngModel)]=\"arg.value\" [id]=\"arg.key\"\n          (input)=\"updateValue()\"\n          placeholder=\"Required for conversion\"\n        >\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".select{min-width:85px}\n"], components: [{ type: i1.ClipboardComponent, selector: "he-clipboard", inputs: ["value", "disabled", "hideText", "icon", "size", "rotate", "clipboardClass"] }], directives: [{ type: i2.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i2.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "keys": i4.KeysPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: UnitConverterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'he-unit-converter',
+                    templateUrl: './unit-converter.component.html',
+                    styleUrls: ['./unit-converter.component.scss']
+                }]
+        }], propDecorators: { term: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], fromUnits: [{
+                type: Input
+            }], toUnits: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unit-converter.component.js","sourceRoot":"","sources":["../../../../src/common/unit-converter/unit-converter.component.ts","../../../../src/common/unit-converter/unit-converter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit } from '@angular/core';\nimport { Term } from '@hestia-earth/schema';\nimport { IConvertArgs, ConvertUnits, converters, convertValue, isNumber, isBoolean } from '@hestia-earth/utils';\n\nconst parsePropertyValue = (value: any) =>\n  isNumber(value) ? +value : (\n    isBoolean(value) ? value.toString() === 'true' : value\n  );\n\nconst parseResult = (value: number) => isNaN(value) ? '' : `${value}`.replace(',', '.');\n\ninterface IArg {\n  key: string;\n  value: any;\n}\n\n@Component({\n  selector: 'he-unit-converter',\n  templateUrl: './unit-converter.component.html',\n  styleUrls: ['./unit-converter.component.scss']\n})\nexport class UnitConverterComponent implements OnInit {\n  @Input()\n  private term?: Term;\n\n  @Input()\n  public value = 1;\n  @Input()\n  public fromUnits?: ConvertUnits;\n  @Input()\n  public toUnits?: ConvertUnits;\n\n  public ConvertUnits = ConvertUnits;\n  public result = '';\n  public arguments: IArg[] = [];\n\n  ngOnInit() {\n    return this.updateValue();\n  }\n\n  private get args() {\n    return (this.term?.defaultProperties || []).reduce((prev, prop) => ({\n      ...prev,\n      [prop.term?.name?.toLowerCase()!]: parsePropertyValue(prop.value)\n    }), {} as IConvertArgs);\n  }\n\n  public get units() {\n    return this.fromUnits ?\n      Object.values(ConvertUnits).filter(v => v in converters[this.fromUnits!]) :\n      [];\n  }\n\n  private requireArgs(keys: (keyof IConvertArgs)[]) {\n    const args = this.args;\n    this.arguments = keys.map(key => ({ key, value: args[key] || '' }));\n  }\n\n  public updateUnits() {\n    let requiredKeys: (keyof IConvertArgs)[] = [];\n    if (this.fromUnits === ConvertUnits.kg || this.toUnits === ConvertUnits.kg) {\n      requiredKeys = ['density'];\n    }\n    this.requireArgs(requiredKeys);\n    return this.updateValue();\n  }\n\n  public updateValue() {\n    if (!this.fromUnits || !this.toUnits) {\n      return;\n    }\n\n    const args = {\n      ...this.args,\n      ...this.arguments.reduce((prev, { key, value }) => ({ ...prev, [key]: value }), {})\n    };\n    try {\n      this.result = parseResult(convertValue(this.value, this.fromUnits, this.toUnits, args));\n    }\n    catch (_) {}\n  }\n}\n","<div class=\"columns mb-0\">\n  <div class=\"column\">\n    <label class=\"label has-text-white\" for=\"value\">Value</label>\n  </div>\n  <div class=\"column\">\n    <label class=\"label has-text-white\" for=\"result\">Convert To</label>\n  </div>\n</div>\n\n<div class=\"columns\">\n  <div class=\"column\">\n    <div class=\"field has-addons\">\n      <div class=\"control\">\n        <input type=\"number\" class=\"input\" [(ngModel)]=\"value\" name=\"value\" id=\"value\"\n          (input)=\"updateValue()\"\n        >\n      </div>\n      <div class=\"control is-expanded\">\n        <div class=\"select is-fullwidth\">\n          <select [(ngModel)]=\"fromUnits\" name=\"fromUnits\" id=\"fromUnits\"\n            (change)=\"updateUnits()\"\n          >\n            <option [value]=\"undefined\">Unit</option>\n            <option *ngFor=\"let unit of ConvertUnits | keys\" [value]=\"unit.value\">{{unit.key}}</option>\n          </select>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"column\">\n    <div class=\"field has-addons\">\n      <div class=\"control\">\n        <input type=\"string\" class=\"input\" [value]=\"result\" name=\"result\" id=\"result\" readonly>\n      </div>\n      <div class=\"control\">\n        <div class=\"select is-fullwidth\">\n          <select [(ngModel)]=\"toUnits\" name=\"toUnits\" id=\"toUnits\"\n            (change)=\"updateUnits()\"\n          >\n            <option [value]=\"undefined\">Unit</option>\n            <option *ngFor=\"let unit of units\" [value]=\"unit\">{{unit}}</option>\n          </select>\n        </div>\n      </div>\n      <div class=\"control\">\n        <he-clipboard clipboardClass=\"button is-white px-2\"\n          [value]=\"result\" [disabled]=\"!result\" [hideText]=\"true\"\n        ></he-clipboard>\n      </div>\n    </div>\n  </div>\n</div>\n\n<div class=\"field is-horizontal\" *ngFor=\"let arg of arguments\">\n  <div class=\"field-label is-normal\">\n    <label class=\"label has-text-white\" [for]=\"arg.key\">\n      <span class=\"is-capitalized\">{{arg.key}}</span>\n      <span class=\"has-text-danger pl-1\">*</span>\n    </label>\n  </div>\n  <div class=\"field-body\">\n    <div class=\"field\">\n      <div class=\"control\">\n        <input type=\"string\" class=\"input is-small\"\n          [(ngModel)]=\"arg.value\" [id]=\"arg.key\"\n          (input)=\"updateValue()\"\n          placeholder=\"Required for conversion\"\n        >\n      </div>\n    </div>\n  </div>\n</div>\n"]}

package/esm2015/common/utils.js

@@ -0,0 +1,245 @@
+const get = require('lodash.get');
+import { getColor } from 'random-material-color';
+import { NodeType, EmissionMethodTier } from '@hestia-earth/schema';
+import { fileToExt } from '@hestia-earth/api';
+export const gitHome = 'https://gitlab.com/hestia-earth';
+export const gitRawBaseUrl = 'https://glcdn.githack.com/hestia-earth';
+export const isChrome = () => window.navigator.userAgent.includes('Chrome');
+export const baseUrl = () => window.location.origin.includes('localhost') ?
+    'https://www-dev.hestia.earth' :
+    window.location.origin.includes('hestia.earth') ?
+        window.location.origin :
+        'https://www.hestia.earth';
+export const isExternal = () => baseUrl() !== window.location.origin;
+;
+export const loadScript = (src) => new Promise((resolve, reject) => {
+    if (!src || document.body.querySelectorAll('script[src="' + src + '"]').length > 0) {
+        return resolve({});
+    }
+    const script = document.createElement('script');
+    script.onload = resolve;
+    script.onerror = reject;
+    script.src = src;
+    document.body.appendChild(script);
+});
+const parseErrorStatus = (error) => ((error === null || error === void 0 ? void 0 : error.statusText) || '').toLowerCase().replace(/\s/g, '-');
+const parseErrorMessage = (error) => get(error, 'error.error', get(error, 'error.message', get(error, 'error', get(error, 'message', error))));
+export const handleAPIError = (error) => {
+    try {
+        error = parseErrorMessage(error);
+    }
+    catch (_) { }
+    throw error;
+};
+export const errorText = (error) => {
+    if (typeof error === 'string') {
+        return error;
+    }
+    const err = parseErrorMessage(error);
+    return parseErrorStatus(err) || err;
+};
+export const toFormData = (data, formData = new FormData()) => {
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            const value = data[key];
+            if (typeof value === 'object') {
+                formData.append(key, JSON.stringify(value));
+            }
+            else {
+                formData.append(key, value);
+            }
+        }
+    }
+    return formData;
+};
+export const filterParams = (obj) => {
+    const res = {};
+    Object.keys(obj).sort().forEach(key => {
+        const value = obj[key];
+        if (value && value !== 'undefined') {
+            res[key] = `${value}`;
+        }
+    });
+    return res;
+};
+export const toSearchParams = (params = {}) => {
+    const searchParams = new URLSearchParams();
+    Object.keys(params)
+        .filter(key => typeof params[key] !== 'undefined')
+        .forEach(key => searchParams.append(key, `${params[key]}`));
+    return searchParams;
+};
+export const waitFor = (variable, callback) => {
+    if (variable in window) {
+        return callback();
+    }
+    setTimeout(() => waitFor(variable, callback), 100);
+};
+export const bottom = (element) => element.offsetTop + element.getBoundingClientRect().height;
+export const isScrolledBelow = (element) => element ? window.scrollY > bottom(element) : false;
+export const scrollToEl = (id, retries = 0) => {
+    const el = document.getElementById(id);
+    setTimeout(() => el ? el.scrollIntoView() : (retries < 10 ? scrollToEl(id, retries + 1) : null), 100);
+};
+export const scrollTop = () => window.scrollTo(0, 0);
+export const animateCounter = (total, callback) => {
+    let animationDuration = 10;
+    const step = Math.pow(10, `${total}`.length - 1);
+    const maxSteps = parseInt(`${total / step}`, 10);
+    let current = 0;
+    const interval = setInterval(() => {
+        callback(current);
+        current += (step / animationDuration);
+        if (current > maxSteps * step) {
+            animationDuration = 100;
+        }
+        if (current > total) {
+            callback(total);
+            clearInterval(interval);
+        }
+    }, animationDuration);
+};
+export const safeJSONParse = (value, defaultValue) => {
+    try {
+        return typeof value === 'string' ? JSON.parse(value) : value;
+    }
+    catch (err) {
+        return defaultValue;
+    }
+};
+export const safeJSONStringify = (value) => typeof value === 'string' ? value : JSON.stringify(value);
+export const arrayValue = (values, isAverage) => (values || []).reduce((prev, curr) => prev + parseFloat(`${curr}`), 0) / (isAverage ? values.length : 1);
+export const propertyValue = (value, isAverage = false) => typeof value === 'undefined' || value === null ?
+    null :
+    (Array.isArray(value) ? arrayValue(value, isAverage) : parseFloat(`${value}`));
+export const dataValue = (data, index, property) => {
+    try {
+        return propertyValue(data[property][index].value);
+    }
+    catch (err) {
+        return null;
+    }
+};
+;
+;
+export const grouppedKeys = (value) => Object.keys(value).map(key => ({ key, value: value[key] }));
+const concatBlankNodeValue = (value, newValue) => {
+    const valueArray = Array.isArray(value) ? value : [value];
+    const newValueArray = Array.isArray(newValue) ? newValue : [newValue];
+    return [...valueArray, ...newValueArray];
+};
+const methodTierOrder = (methodTier) => [
+    EmissionMethodTier.measured,
+    EmissionMethodTier['tier 3'],
+    EmissionMethodTier['tier 2'],
+    EmissionMethodTier['tier 1'],
+    EmissionMethodTier.background
+].indexOf(methodTier);
+const isMethodModelAllowed = (node, filterMethod) => !filterMethod || !node['methodModel'] || node['methodModel']['@id'] === filterMethod['@id'];
+export const grouppedValueKeys = [
+    'dates', 'sd', 'min', 'max', 'inputs', 'depthUpper', 'depthLower', 'startDate', 'endDate',
+    'methodTier', 'methodModel'
+];
+export const groupNodesByTerm = (nodes = [], key, originalValues = [], filterMethod) => {
+    const groups = nodes.reduce((prev, node, index) => (node[key] || []).reduce((group, blankNode) => {
+        if (!isMethodModelAllowed(blankNode, filterMethod)) {
+            return group;
+        }
+        const nodeId = node['@id'];
+        const termId = blankNode.term['@id'];
+        group[termId] = group[termId] || {
+            term: blankNode.term,
+            methodTierOrder: methodTierOrder(blankNode.methodTier),
+            values: {},
+            originalValues: {}
+        };
+        group[termId].values[nodeId] = group[termId].values[nodeId] || { index, nodes: [], value: [] };
+        group[termId].values[nodeId].nodes.push(blankNode);
+        group[termId].values[nodeId].value = concatBlankNodeValue(group[termId].values[nodeId].value, blankNode.value);
+        grouppedValueKeys.forEach(arrayKey => {
+            const newValue = get(blankNode, arrayKey, []);
+            group[termId].values[nodeId][arrayKey] = [
+                ...(group[termId].values[nodeId][arrayKey] || []),
+                ...(Array.isArray(newValue) ? newValue : [newValue])
+            ];
+        });
+        return group;
+    }, prev), {});
+    // compile original values
+    Object.values(groups).map(group => {
+        Object.keys(group.values).map(nodeId => {
+            const { index } = group.values[nodeId];
+            const termId = group.term['@id'];
+            const originalValue = get(originalValues, `[${index}].${key}`, []).filter((val) => val.term['@id'] === termId);
+            if (originalValue.length > 0) {
+                const value = originalValue.reduce((array, curr) => concatBlankNodeValue(array, curr.value), []);
+                group.originalValues[nodeId] = { value: propertyValue(value) };
+            }
+        });
+    });
+    return groups;
+};
+export const sortByFn = (key, asc) => (a, b) => asc ? get(a, key, '').localeCompare(get(b, key, '')) : get(b, key, '').localeCompare(get(a, key, ''));
+export const ellipsis = (text = '', maxlength = 20) => text.length > maxlength ? `${text.substring(0, maxlength)}...` : text;
+const mapsQuery = 'https://www.google.com/maps/search/?api=1&query=';
+export const mapsUrl = (location) => location ? (location.lat && location.lng ?
+    `${mapsQuery}${location.lat},${location.lng}` :
+    (location.name ? `${mapsQuery}${encodeURI(location.name)}` : undefined)) : undefined;
+export const keyToLabel = (key) => `${key[0].toUpperCase()}${key.replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/([_])([a-zA-Z])/g, g => ` ${g[1].toUpperCase()}`)
+    .substring(1)}`;
+export const toDashCase = (value) => value ?
+    value
+        // handle dates followed by capital letter
+        .replace(/([\d]{4})([A-Z]{1})/g, g => `${g.substring(0, 4)}-${g[4].toLowerCase()}`)
+        // handle molecules
+        .replace(/([\d]{1}[A-Z]{1})/g, g => g.toLowerCase())
+        // handle all capital letters
+        .replace(/([A-Z])/g, g => `-${g[0].toLowerCase()}`)
+        // handle years
+        .replace(/([0-9]{4})/g, g => `-${g}`) :
+    null;
+export const nodeTypeToString = (type) => `${type.charAt(0).toLowerCase()}${type.substring(1)}`;
+export const parseNodeType = (type) => Object.values(NodeType).find(v => v.toString().toLowerCase() === (type || '').toLowerCase());
+const nodeDefaultLabel = {
+    [NodeType.ImpactAssessment]: ({ name, country, endDate, product }) => name ? name.replace(`${product === null || product === void 0 ? void 0 : product.name}, `, '') : [
+        product === null || product === void 0 ? void 0 : product.name,
+        country === null || country === void 0 ? void 0 : country.name,
+        endDate
+    ].filter(Boolean).join(', '),
+    [NodeType.Site]: ({ name, description }) => name || description
+};
+export const defaultLabel = (node) => node ? (node['@type'] in nodeDefaultLabel ? nodeDefaultLabel[node['@type']](node) : node.name) || node['@id'] || node.id : '';
+export const itemColor = (index) => getColor({ text: `${index}` });
+export const listColor = (_v, index) => itemColor(index);
+export const minutesBefore = (date, minutes = 1) => {
+    date.setMinutes(date.getMinutes() - minutes);
+    return date;
+};
+export const hoursBefore = (date, hours = 1) => {
+    date.setHours(date.getHours() - hours);
+    return date;
+};
+export const repeat = (times = 0) => (Array.from(Array(times), Math.random));
+export var DeltaDisplayType;
+(function (DeltaDisplayType) {
+    DeltaDisplayType["absolute"] = "absolute";
+    DeltaDisplayType["percent"] = "percent";
+})(DeltaDisplayType || (DeltaDisplayType = {}));
+const deltaPerType = {
+    [DeltaDisplayType.absolute]: (value, original) => value - original,
+    [DeltaDisplayType.percent]: (value, original) => ((value - original) / original) * 100
+};
+const roundValue = (value) => +(`${value}`.substring(0, 10));
+export const delta = (value, originalValue, displayType = DeltaDisplayType.percent) => {
+    const vvalue = roundValue(propertyValue(value));
+    const voriginalValue = roundValue(propertyValue(originalValue));
+    const diff = vvalue === voriginalValue ? 0 : deltaPerType[displayType](vvalue, voriginalValue);
+    return Number.isFinite(diff) ? (diff === -0 ? 0 : diff) : 0;
+};
+export const filenameWithoutExt = (filename = '') => {
+    const file = fileToExt(filename, '');
+    // remove last .
+    return file.endsWith('.') ? file.substring(0, file.length - 1) : file;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/common/utils.ts"],"names":[],"mappings":"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","sourcesContent":["const get = require('lodash.get');\nimport { getColor } from 'random-material-color';\nimport {\n  NodeType, Term, JSONLD, ICycleJSONLD, ISiteJSONLD, IImpactAssessmentJSONLD, EmissionMethodTier\n} from '@hestia-earth/schema';\nimport { fileToExt } from '@hestia-earth/api';\n\nexport const gitHome = 'https://gitlab.com/hestia-earth';\nexport const gitRawBaseUrl = 'https://glcdn.githack.com/hestia-earth';\n\nexport const isChrome = () => window.navigator.userAgent.includes('Chrome');\n\nexport const baseUrl = () =>\n  window.location.origin.includes('localhost') ?\n    'https://www-dev.hestia.earth' :\n    window.location.origin.includes('hestia.earth') ?\n      window.location.origin :\n      'https://www.hestia.earth';\n\nexport const isExternal = () => baseUrl() !== window.location.origin;;\n\nexport const loadScript = (src?: string) => new Promise<any>((resolve, reject) => {\n  if (!src || document.body.querySelectorAll('script[src=\"' + src + '\"]').length > 0) {\n    return resolve({});\n  }\n\n  const script = document.createElement('script');\n  script.onload = resolve;\n  script.onerror = reject;\n  script.src = src;\n  document.body.appendChild(script);\n});\n\nconst parseErrorStatus = (error: any) => (error?.statusText || '').toLowerCase().replace(/\\s/g, '-');\n\nconst parseErrorMessage = (error: any) =>\n  get(error, 'error.error', get(error, 'error.message', get(error, 'error', get(error, 'message', error))));\n\nexport const handleAPIError = (error: any) => {\n  try {\n    error = parseErrorMessage(error);\n  }\n  catch (_) { }\n  throw error;\n};\n\nexport const errorText = (error: any): string => {\n  if (typeof error === 'string') {\n    return error;\n  }\n  const err = parseErrorMessage(error);\n  return parseErrorStatus(err) || err;\n};\n\nexport const toFormData = (data: any, formData = new FormData()) => {\n  for (const key in data) {\n    if (data.hasOwnProperty(key)) {\n      const value = data[key];\n      if (typeof value === 'object') {\n        formData.append(key, JSON.stringify(value));\n      }\n      else {\n        formData.append(key, value);\n      }\n    }\n  }\n  return formData;\n};\n\nexport const filterParams = (obj: any) => {\n  const res: {\n    [x: string]: string;\n  } = {};\n  Object.keys(obj).sort().forEach(key => {\n    const value = obj[key];\n    if (value && value !== 'undefined') {\n      res[key] = `${value}`;\n    }\n  });\n  return res;\n};\n\nexport const toSearchParams = (params: any = {}) => {\n  const searchParams = new URLSearchParams();\n  Object.keys(params)\n    .filter(key => typeof params[key] !== 'undefined')\n    .forEach(key => searchParams.append(key, `${params[key]}`));\n  return searchParams;\n};\n\nexport const waitFor = (variable: string, callback: () => void) => {\n  if (variable in window) {\n    return callback();\n  }\n  setTimeout(() => waitFor(variable, callback), 100);\n};\n\nexport const bottom = (element: HTMLElement) => element.offsetTop + element.getBoundingClientRect().height;\n\nexport const isScrolledBelow = (element: HTMLElement) => element ? window.scrollY > bottom(element) : false;\n\nexport const scrollToEl = (id: string, retries = 0) => {\n  const el = document.getElementById(id);\n  setTimeout(() => el ? el.scrollIntoView() : (retries < 10 ? scrollToEl(id, retries + 1) : null), 100);\n};\n\nexport const scrollTop = () => window.scrollTo(0, 0);\n\nexport const animateCounter = (total: number, callback: (count: number) => void) => {\n  let animationDuration = 10;\n  const step = Math.pow(10, `${total}`.length - 1);\n  const maxSteps = parseInt(`${total / step}`, 10);\n  let current = 0;\n  const interval = setInterval(() => {\n    callback(current);\n    current += (step / animationDuration);\n    if (current > maxSteps * step) {\n      animationDuration = 100;\n    }\n    if (current > total) {\n      callback(total);\n      clearInterval(interval);\n    }\n  }, animationDuration);\n};\n\nexport const safeJSONParse = <T>(value: string, defaultValue?: any) => {\n  try {\n    return typeof value === 'string' ? JSON.parse(value) as T : value;\n  }\n  catch (err) {\n    return defaultValue;\n  }\n};\n\nexport const safeJSONStringify = (value: string) => typeof value === 'string' ? value : JSON.stringify(value);\n\nexport const arrayValue = (values: any[], isAverage: boolean) =>\n  (values || []).reduce((prev: number, curr) => prev + parseFloat(`${curr}`), 0) / (isAverage ? values.length : 1);\n\nexport const propertyValue = (value: string | number | ((string | number)[]), isAverage = false): number =>\n  typeof value === 'undefined' || value === null ?\n    null as any :\n    (\n      Array.isArray(value) ? arrayValue(value, isAverage) : parseFloat(`${value}`)\n    );\n\nexport const dataValue = (data: any, index: number, property: string) => {\n  try {\n    return propertyValue(data[property][index].value);\n  }\n  catch (err) {\n    return null;\n  }\n};\n\nexport interface IGroupedNode<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: Term;\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>(value: IGroupedNodes<T>): IGroupedKeys<T>[] =>\n  Object.keys(value).map(key => ({ key, value: value[key] }));\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\nconst methodTierOrder = (methodTier: EmissionMethodTier) => [\n  EmissionMethodTier.measured,\n  EmissionMethodTier['tier 3'],\n  EmissionMethodTier['tier 2'],\n  EmissionMethodTier['tier 1'],\n  EmissionMethodTier.background\n].indexOf(methodTier);\n\nconst isMethodModelAllowed = (node: any, filterMethod?: Term) =>\n  !filterMethod || !node['methodModel'] || node['methodModel']['@id'] === filterMethod['@id'];\n\nexport const grouppedValueKeys = [\n  'dates', 'sd', 'min', 'max', 'inputs', 'depthUpper', 'depthLower', 'startDate', 'endDate',\n  'methodTier', 'methodModel'\n];\n\nexport const groupNodesByTerm = <T extends ICycleJSONLD | IImpactAssessmentJSONLD | ISiteJSONLD, R>(\n  nodes: T[] = [],\n  key: 'impacts' | 'emissionsResourceUse' | 'inputs' | 'products' | 'emissions' | 'measurements',\n  originalValues: T[] = [],\n  filterMethod?: Term\n): IGroupedNodes<R> => {\n  const groups: IGroupedNodes<R> = nodes.reduce((prev, node, index) => (node[key] || []).reduce((group, blankNode) => {\n    if (!isMethodModelAllowed(blankNode, filterMethod)) {\n      return group;\n    }\n\n    const nodeId = node['@id'];\n    const termId = blankNode.term['@id'];\n    group[termId] = group[termId] || {\n      term: blankNode.term,\n      methodTierOrder: methodTierOrder(blankNode.methodTier),\n      values: {},\n      originalValues: {}\n    };\n    group[termId].values[nodeId] = group[termId].values[nodeId] || { index, nodes: [], value: [] };\n    group[termId].values[nodeId].nodes.push(blankNode);\n    group[termId].values[nodeId].value = concatBlankNodeValue(\n      group[termId].values[nodeId].value,\n      blankNode.value\n    );\n    grouppedValueKeys.forEach(arrayKey => {\n      const newValue = get(blankNode, arrayKey, []);\n      group[termId].values[nodeId][arrayKey] = [\n        ...(group[termId].values[nodeId][arrayKey] || []),\n        ...(Array.isArray(newValue) ? newValue : [newValue])\n      ];\n    });\n    return group;\n  }, prev), {} as IGroupedNodes<R>);\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((val: any) => val.term['@id'] === termId);\n      if (originalValue.length > 0) {\n        const value = originalValue.reduce((array: any[], curr: any) => concatBlankNodeValue(\n          array,\n          curr.value\n        ), []);\n        group.originalValues[nodeId] = { value: propertyValue(value) };\n      }\n    });\n  });\n\n  return groups;\n};\n\nexport const sortByFn = (key: string, asc: boolean) => <T>(a: T, b: T): number =>\n  asc ? get(a, key, '').localeCompare(get(b, key, '')) : get(b, key, '').localeCompare(get(a, key, ''));\n\nexport const ellipsis = (text = '', maxlength = 20) =>\n  text.length > maxlength ? `${text.substring(0, maxlength)}...` : text;\n\nconst mapsQuery = 'https://www.google.com/maps/search/?api=1&query=';\n\nexport const mapsUrl = (location?: { lat?: number; lng?: number; name?: string }) =>\n  location ? (\n    location.lat && location.lng ?\n      `${mapsQuery}${location.lat},${location.lng}` :\n      (location.name ? `${mapsQuery}${encodeURI(location.name)}` : undefined)\n  ) : undefined;\n\nexport const keyToLabel = (key: string) =>\n  `${key[0].toUpperCase()}${\n    key.replace(/([a-z])([A-Z])/g, '$1 $2')\n      .replace(/([_])([a-zA-Z])/g, g => ` ${g[1].toUpperCase()}`)\n      .substring(1)\n  }`;\n\nexport const toDashCase = (value?: string) =>\n  value ?\n    value\n      // handle dates followed by capital letter\n      .replace(/([\\d]{4})([A-Z]{1})/g, g => `${g.substring(0, 4)}-${g[4].toLowerCase()}`)\n      // handle molecules\n      .replace(/([\\d]{1}[A-Z]{1})/g, g => g.toLowerCase())\n      // handle all capital letters\n      .replace(/([A-Z])/g, g => `-${g[0].toLowerCase()}`)\n      // handle years\n      .replace(/([0-9]{4})/g, g => `-${g}`) :\n    null;\n\nexport const nodeTypeToString = (type: NodeType) => `${type.charAt(0).toLowerCase()}${type.substring(1)}`;\n\nexport const parseNodeType = (type: string) =>\n  Object.values(NodeType).find(v => v.toString().toLowerCase() === (type || '').toLowerCase());\n\nconst nodeDefaultLabel: {\n  [type in NodeType]?: (data: JSONLD<any>) => string;\n} = {\n  [NodeType.ImpactAssessment]: ({ name, country, endDate, product }: IImpactAssessmentJSONLD) =>\n    name ? name.replace(`${product?.name}, `, '') : [\n      product?.name,\n      country?.name,\n      endDate\n    ].filter(Boolean).join(', '),\n  [NodeType.Site]: ({ name, description }: ISiteJSONLD) => name || description!\n};\n\nexport const defaultLabel = (node?: any) =>\n  node ? (\n    node['@type'] in nodeDefaultLabel ? nodeDefaultLabel[node['@type']](node) : node.name\n  ) || node['@id'] || node.id : '';\n\nexport const itemColor = (index: number) => getColor({ text: `${index}` });\n\nexport const listColor = <T>(_v: T, index: number): string => itemColor(index);\n\nexport const minutesBefore = (date: Date, minutes = 1) => {\n  date.setMinutes(date.getMinutes() - minutes);\n  return date;\n};\n\nexport const hoursBefore = (date: Date, hours = 1) => {\n  date.setHours(date.getHours() - hours);\n  return date;\n};\n\nexport const repeat = (times = 0) => (Array.from(Array(times), Math.random));\n\nexport enum DeltaDisplayType {\n  absolute = 'absolute',\n  percent = 'percent'\n}\n\nconst deltaPerType: {\n  [type in DeltaDisplayType]: (value: number, original: number) => number;\n} = {\n  [DeltaDisplayType.absolute]: (value, original) => value - original,\n  [DeltaDisplayType.percent]: (value, original) => ((value - original) / original) * 100\n};\n\nconst roundValue = (value: any) => +(`${value}`.substring(0, 10));\n\nexport const delta = (value: any, originalValue: any, displayType = DeltaDisplayType.percent) => {\n  const vvalue = roundValue(propertyValue(value));\n  const voriginalValue = roundValue(propertyValue(originalValue));\n  const diff = vvalue === voriginalValue ? 0 : deltaPerType[displayType](vvalue, voriginalValue);\n  return Number.isFinite(diff) ? (diff === -0 ? 0 : diff) : 0;\n};\n\nexport const filenameWithoutExt = (filename = '') => {\n  const file = fileToExt(filename, '');\n  // remove last .\n  return file.endsWith('.') ? file.substring(0, file.length - 1) : file;\n};\n"]}

package/esm2015/cycles/cycles-activity/cycles-activity.component.js

@@ -0,0 +1,92 @@
+import { __awaiter } from "tslib";
+import { Component, Input } from '@angular/core';
+import { DataState } from '@hestia-earth/api';
+import { propertyValue, groupNodesByTerm, grouppedKeys } from '../../common/utils';
+import { baseUrl } from '../../common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@fortawesome/angular-fontawesome";
+import * as i2 from "../../node/node-link/node-link.component";
+import * as i3 from "../cycles-functional-unit-measure/cycles-functional-unit-measure.component";
+import * as i4 from "../../common/blank-node-state/blank-node-state.component";
+import * as i5 from "../../common/blank-node-state-notice/blank-node-state-notice.component";
+import * as i6 from "../cycles-suggest-form/cycles-suggest-form.component";
+import * as i7 from "../cycles-activity-logs/cycles-activity-logs.component";
+import * as i8 from "../../node/node-csv-export-confirm/node-csv-export-confirm.component";
+import * as i9 from "../../node/node-value-details/node-value-details.component";
+import * as i10 from "@angular/common";
+import * as i11 from "@ng-bootstrap/ng-bootstrap";
+import * as i12 from "../../common/ellipsis.pipe";
+import * as i13 from "../../common/default.pipe";
+import * as i14 from "../../common/precision.pipe";
+const orderBy = require('lodash.orderby');
+var View;
+(function (View) {
+    View["table"] = "table";
+    View["logs"] = "logs";
+})(View || (View = {}));
+export class CyclesActivityComponent {
+    constructor() {
+        this.originalValues = [];
+        this.cycles = [];
+        this.enableCompare = true;
+        this.baseUrl = baseUrl();
+        this.propertyValue = propertyValue;
+        this.showDownload = false;
+        this.View = View;
+        this.selectedView = View.table;
+        this.inputs = [];
+        this.products = [];
+    }
+    ngOnChanges(changes) {
+        if ('cycles' in changes) {
+            return this.update();
+        }
+        if ('dataState' in changes) {
+            this.selectedView = View.table;
+        }
+    }
+    trackById(_index, item) {
+        return item['@id'];
+    }
+    get isOriginal() {
+        return this.dataState === DataState.original;
+    }
+    update() {
+        const inputsPerCycle = groupNodesByTerm(this.cycles, 'inputs', this.originalValues);
+        this.inputs = orderBy(grouppedKeys(inputsPerCycle), ['key'], ['asc']);
+        const productsPerCycle = groupNodesByTerm(this.cycles, 'products', this.originalValues);
+        this.products = orderBy(grouppedKeys(productsPerCycle), ['key'], ['asc']);
+    }
+    togglePopover(popover, context) {
+        return popover.isOpen() ? popover.close() : popover.open(context);
+    }
+    // Add from suggestion
+    addCycle(cycle) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cycles = [
+                ...this.cycles,
+                cycle
+            ];
+            return this.update();
+        });
+    }
+}
+CyclesActivityComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CyclesActivityComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CyclesActivityComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: CyclesActivityComponent, selector: "he-cycles-activity", inputs: { originalValues: "originalValues", cycles: "cycles", dataState: "dataState", enableCompare: "enableCompare" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"inputs.length || products.length; else emptyTable\">\n  <div class=\"columns is-variable is-2 m-0\">\n    <div class=\"column is-hidden-mobile\"></div>\n    <div class=\"column is-narrow\">\n      <div class=\"field has-addons\">\n        <div class=\"control\">\n          <button class=\"button is-small\" [class.is-active]=\"selectedView === View.table\" (click)=\"selectedView = View.table\">\n            <span class=\"icon is-small\">\n              <fa-icon icon=\"list\" aria-hidden=\"true\"></fa-icon>\n            </span>\n            <span>Table view</span>\n          </button>\n        </div>\n        <div class=\"control\" *ngIf=\"!isOriginal && cycles.length === 1\">\n          <button class=\"button is-small\" [class.is-active]=\"selectedView === View.logs\" (click)=\"selectedView = View.logs\">\n            <span class=\"icon is-small\">\n              <fa-icon icon=\"calculator\" aria-hidden=\"true\"></fa-icon>\n            </span>\n            <span>Recalculations logs</span>\n          </button>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"px-3 pb-3\" [class.is-hidden]=\"selectedView !== View.table\">\n    <div class=\"has-text-right mb-2\">\n      <button class=\"button is-dark is-outlined is-small\" (click)=\"showDownload = true\">\n        <fa-icon icon=\"download\"></fa-icon>\n        <span class=\"pl-2\">Download (CSV)</span>\n      </button>\n    </div>\n\n    <div class=\"table-container data-table-container mb-1\">\n      <table class=\"table is-narrow data-table has-children-{{inputs.length + products.length}}\">\n        <thead>\n          <tr>\n            <th class=\"width-auto\"></th>\n            <th></th>\n            <th *ngFor=\"let product of products\"\n              [attr.title]=\"product.value.term.name\"\n            >\n              <he-node-link [node]=\"product.value.term\">\n                <span>{{product.value.term.name | ellipsis:30}}</span>\n              </he-node-link>\n            </th>\n            <th *ngFor=\"let input of inputs\"\n              [attr.title]=\"input.value.term.name\"\n            >\n              <he-node-link [node]=\"input.value.term\">\n                <span>{{input.value.term.name | ellipsis:30}}</span>\n              </he-node-link>\n            </th>\n          </tr>\n          <tr>\n            <th class=\"width-auto\"></th>\n            <th>\n              <a [href]=\"baseUrl + '/schema/Cycle#functionalUnit'\" target=\"_blank\">Functional unit</a>\n            </th>\n            <th *ngFor=\"let product of products\"\n              [attr.title]=\"product.value.term.units\"\n            >{{product.value.term.units}}</th>\n            <th *ngFor=\"let input of inputs\"\n              [attr.title]=\"input.value.term.units\"\n            >{{input.value.term.units}}</th>\n          </tr>\n        </thead>\n        <tbody>\n          <tr *ngFor=\"let cycle of cycles; trackBy: trackById; let i = index\">\n            <td class=\"width-auto\" [attr.title]=\"cycle.name\">\n              <he-node-link [node]=\"cycle\">\n                <span class=\"is-nowrap has-text-ellipsis\">{{i + 1}}. {{cycle.name || cycle.id}}</span>\n              </he-node-link>\n            </td>\n            <td>\n              <he-cycles-functional-unit-measure [cycle]=\"cycle\"></he-cycles-functional-unit-measure>\n            </td>\n            <td class=\"is-nowrap\" *ngFor=\"let product of products\">\n              <span *ngIf=\"product.value.values[cycle['@id']]; else emptyValue\"\n                class=\"trigger-popover\"\n                [ngbPopover]=\"details\" [autoClose]=\"'outside'\"\n                triggers=\"manual\" #p=\"ngbPopover\" placement=\"left\" container=\"body\"\n                (click)=\"togglePopover(p, { data: product.value.values[cycle['@id']], cycle: cycle, key: 'products' })\"\n              >\n                <span pointer>{{propertyValue(product.value.values[cycle['@id']].value) | precision:3 | default:'-'}}</span>\n                <he-blank-node-state class=\"ml-1\"\n                  [node]=\"product.value.values[cycle['@id']].nodes[0]\"\n                  key=\"value\"\n                ></he-blank-node-state>\n              </span>\n            </td>\n            <td class=\"is-nowrap\" *ngFor=\"let input of inputs\">\n              <span *ngIf=\"input.value.values[cycle['@id']]; else emptyValue\"\n                class=\"trigger-popover\"\n                [ngbPopover]=\"details\" [autoClose]=\"'outside'\"\n                triggers=\"manual\" #p=\"ngbPopover\" placement=\"left\" container=\"body\"\n                (click)=\"togglePopover(p, { data: input.value.values[cycle['@id']], cycle: cycle, key: 'inputs' })\"\n              >\n                <span pointer>{{propertyValue(input.value.values[cycle['@id']].value) | precision:3 | default:'-'}}</span>\n                <he-blank-node-state class=\"ml-1\"\n                  [node]=\"input.value.values[cycle['@id']].nodes[0]\"\n                  key=\"value\"\n                ></he-blank-node-state>\n              </span>\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n\n    <he-blank-node-state-notice [dataState]=\"dataState\"></he-blank-node-state-notice>\n\n    <he-cycles-suggest-form *ngIf=\"enableCompare\" [cycles]=\"cycles\" (cycleAdded)=\"addCycle($event)\"></he-cycles-suggest-form>\n  </div>\n\n  <he-cycles-activity-logs *ngIf=\"selectedView === View.logs && !isOriginal\"\n    [original]=\"originalValues[0]\"\n    [recalculated]=\"cycles[0]\"\n  ></he-cycles-activity-logs>\n</ng-container>\n\n<he-node-csv-export-confirm *ngIf=\"showDownload\"\n  [nodes]=\"cycles\" filename=\"cycle-inputs-products.csv\" [isUpload]=\"false\"\n  [headerKeys]=\"['cycle.id', 'cycle.@id', 'cycle.inputs.', 'cycle.products.']\"\n  (closed)=\"showDownload = false\"\n></he-node-csv-export-confirm>\n\n<ng-template #emptyTable>\n  <div class=\"panel-block\">\n    <span>No activity data</span>\n  </div>\n</ng-template>\n\n<ng-template #emptyValue>\n  <span>-</span>\n</ng-template>\n\n<ng-template #details let-node=\"cycle\" let-data=\"data\" let-key=\"key\">\n  <p><b>{{node.name}}</b></p>\n  <he-node-value-details\n    [data]=\"data\" [nodeType]=\"node['@type']\" [dataKey]=\"key\"\n  ></he-node-value-details>\n</ng-template>\n", styles: ["fa-icon{display:inline-block;width:10px}\n"], components: [{ type: i1.FaIconComponent, selector: "fa-icon", inputs: ["classes", "icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "transform", "a11yRole"] }, { type: i2.NodeLinkComponent, selector: "he-node-link", inputs: ["node", "showExternalLink"] }, { type: i3.CyclesFunctionalUnitMeasureComponent, selector: "he-cycles-functional-unit-measure", inputs: ["cycle"] }, { type: i4.BlankNodeStateComponent, selector: "he-blank-node-state", inputs: ["nodeType", "dataKey", "key", "node", "state"] }, { type: i5.BlankNodeStateNoticeComponent, selector: "he-blank-node-state-notice", inputs: ["dataState", "showDeleted"] }, { type: i6.CyclesSuggestFormComponent, selector: "he-cycles-suggest-form", inputs: ["cycles"], outputs: ["cycleAdded"] }, { type: i7.CyclesActivityLogsComponent, selector: "he-cycles-activity-logs", inputs: ["original", "recalculated"] }, { type: i8.NodeCsvExportConfirmComponent, selector: "he-node-csv-export-confirm", inputs: ["nodes", "filename", "headerKeys", "extension", "isUpload"], outputs: ["closed"] }, { type: i9.NodeValueDetailsComponent, selector: "he-node-value-details", inputs: ["data", "nodeType", "dataKey"] }], directives: [{ type: i10.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i10.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i11.NgbPopover, selector: "[ngbPopover]", inputs: ["animation", "autoClose", "placement", "triggers", "container", "disablePopover", "popoverClass", "openDelay", "closeDelay", "ngbPopover", "popoverTitle"], outputs: ["shown", "hidden"], exportAs: ["ngbPopover"] }], pipes: { "ellipsis": i12.EllipsisPipe, "default": i13.DefaultPipe, "precision": i14.PrecisionPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CyclesActivityComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'he-cycles-activity',
+                    templateUrl: './cycles-activity.component.html',
+                    styleUrls: ['./cycles-activity.component.scss']
+                }]
+        }], propDecorators: { originalValues: [{
+                type: Input
+            }], cycles: [{
+                type: Input
+            }], dataState: [{
+                type: Input
+            }], enableCompare: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cycles-activity.component.js","sourceRoot":"","sources":["../../../../src/cycles/cycles-activity/cycles-activity.component.ts","../../../../src/cycles/cycles-activity/cycles-activity.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnChanges, SimpleChanges } from '@angular/core';\nimport { DataState } from '@hestia-earth/api';\nimport { ICycleJSONLD, Input as HestiaInput, Product } from '@hestia-earth/schema';\nconst orderBy = require('lodash.orderby');\n\nimport { propertyValue, groupNodesByTerm, IGroupedKeys, grouppedKeys } from '../../common/utils';\nimport { baseUrl } from '../../common/utils';\n\nenum View {\n  table = 'table',\n  logs = 'logs'\n}\n\n@Component({\n  selector: 'he-cycles-activity',\n  templateUrl: './cycles-activity.component.html',\n  styleUrls: ['./cycles-activity.component.scss']\n})\nexport class CyclesActivityComponent implements OnChanges {\n  @Input()\n  public originalValues: ICycleJSONLD[] = [];\n  @Input()\n  public cycles: ICycleJSONLD[] = [];\n  @Input()\n  public dataState?: DataState;\n  @Input()\n  public enableCompare = true;\n\n  public baseUrl = baseUrl();\n  public propertyValue = propertyValue;\n  public showDownload = false;\n  public View = View;\n  public selectedView = View.table;\n\n  public inputs: IGroupedKeys<HestiaInput>[] = [];\n  public products: IGroupedKeys<Product>[] = [];\n\n  ngOnChanges(changes: SimpleChanges) {\n    if ('cycles' in changes) {\n      return this.update();\n    }\n    if ('dataState' in changes) {\n      this.selectedView = View.table;\n    }\n  }\n\n  public trackById(_index: number, item: ICycleJSONLD) {\n    return item['@id'];\n  }\n\n  public get isOriginal() {\n    return this.dataState === DataState.original;\n  }\n\n  private update() {\n    const inputsPerCycle = groupNodesByTerm<ICycleJSONLD, HestiaInput>(this.cycles, 'inputs', this.originalValues);\n    this.inputs = orderBy(grouppedKeys(inputsPerCycle), ['key'], ['asc']);\n    const productsPerCycle = groupNodesByTerm<ICycleJSONLD, Product>(this.cycles, 'products', this.originalValues);\n    this.products = orderBy(grouppedKeys(productsPerCycle), ['key'], ['asc']);\n  }\n\n  public togglePopover(popover: any, context: any) {\n    return popover.isOpen() ? popover.close() : popover.open(context);\n  }\n\n  // Add from suggestion\n\n  public async addCycle(cycle: ICycleJSONLD) {\n    this.cycles = [\n      ...this.cycles,\n      cycle\n    ];\n    return this.update();\n  }\n}\n","<ng-container *ngIf=\"inputs.length || products.length; else emptyTable\">\n  <div class=\"columns is-variable is-2 m-0\">\n    <div class=\"column is-hidden-mobile\"></div>\n    <div class=\"column is-narrow\">\n      <div class=\"field has-addons\">\n        <div class=\"control\">\n          <button class=\"button is-small\" [class.is-active]=\"selectedView === View.table\" (click)=\"selectedView = View.table\">\n            <span class=\"icon is-small\">\n              <fa-icon icon=\"list\" aria-hidden=\"true\"></fa-icon>\n            </span>\n            <span>Table view</span>\n          </button>\n        </div>\n        <div class=\"control\" *ngIf=\"!isOriginal && cycles.length === 1\">\n          <button class=\"button is-small\" [class.is-active]=\"selectedView === View.logs\" (click)=\"selectedView = View.logs\">\n            <span class=\"icon is-small\">\n              <fa-icon icon=\"calculator\" aria-hidden=\"true\"></fa-icon>\n            </span>\n            <span>Recalculations logs</span>\n          </button>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"px-3 pb-3\" [class.is-hidden]=\"selectedView !== View.table\">\n    <div class=\"has-text-right mb-2\">\n      <button class=\"button is-dark is-outlined is-small\" (click)=\"showDownload = true\">\n        <fa-icon icon=\"download\"></fa-icon>\n        <span class=\"pl-2\">Download (CSV)</span>\n      </button>\n    </div>\n\n    <div class=\"table-container data-table-container mb-1\">\n      <table class=\"table is-narrow data-table has-children-{{inputs.length + products.length}}\">\n        <thead>\n          <tr>\n            <th class=\"width-auto\"></th>\n            <th></th>\n            <th *ngFor=\"let product of products\"\n              [attr.title]=\"product.value.term.name\"\n            >\n              <he-node-link [node]=\"product.value.term\">\n                <span>{{product.value.term.name | ellipsis:30}}</span>\n              </he-node-link>\n            </th>\n            <th *ngFor=\"let input of inputs\"\n              [attr.title]=\"input.value.term.name\"\n            >\n              <he-node-link [node]=\"input.value.term\">\n                <span>{{input.value.term.name | ellipsis:30}}</span>\n              </he-node-link>\n            </th>\n          </tr>\n          <tr>\n            <th class=\"width-auto\"></th>\n            <th>\n              <a [href]=\"baseUrl + '/schema/Cycle#functionalUnit'\" target=\"_blank\">Functional unit</a>\n            </th>\n            <th *ngFor=\"let product of products\"\n              [attr.title]=\"product.value.term.units\"\n            >{{product.value.term.units}}</th>\n            <th *ngFor=\"let input of inputs\"\n              [attr.title]=\"input.value.term.units\"\n            >{{input.value.term.units}}</th>\n          </tr>\n        </thead>\n        <tbody>\n          <tr *ngFor=\"let cycle of cycles; trackBy: trackById; let i = index\">\n            <td class=\"width-auto\" [attr.title]=\"cycle.name\">\n              <he-node-link [node]=\"cycle\">\n                <span class=\"is-nowrap has-text-ellipsis\">{{i + 1}}. {{cycle.name || cycle.id}}</span>\n              </he-node-link>\n            </td>\n            <td>\n              <he-cycles-functional-unit-measure [cycle]=\"cycle\"></he-cycles-functional-unit-measure>\n            </td>\n            <td class=\"is-nowrap\" *ngFor=\"let product of products\">\n              <span *ngIf=\"product.value.values[cycle['@id']]; else emptyValue\"\n                class=\"trigger-popover\"\n                [ngbPopover]=\"details\" [autoClose]=\"'outside'\"\n                triggers=\"manual\" #p=\"ngbPopover\" placement=\"left\" container=\"body\"\n                (click)=\"togglePopover(p, { data: product.value.values[cycle['@id']], cycle: cycle, key: 'products' })\"\n              >\n                <span pointer>{{propertyValue(product.value.values[cycle['@id']].value) | precision:3 | default:'-'}}</span>\n                <he-blank-node-state class=\"ml-1\"\n                  [node]=\"product.value.values[cycle['@id']].nodes[0]\"\n                  key=\"value\"\n                ></he-blank-node-state>\n              </span>\n            </td>\n            <td class=\"is-nowrap\" *ngFor=\"let input of inputs\">\n              <span *ngIf=\"input.value.values[cycle['@id']]; else emptyValue\"\n                class=\"trigger-popover\"\n                [ngbPopover]=\"details\" [autoClose]=\"'outside'\"\n                triggers=\"manual\" #p=\"ngbPopover\" placement=\"left\" container=\"body\"\n                (click)=\"togglePopover(p, { data: input.value.values[cycle['@id']], cycle: cycle, key: 'inputs' })\"\n              >\n                <span pointer>{{propertyValue(input.value.values[cycle['@id']].value) | precision:3 | default:'-'}}</span>\n                <he-blank-node-state class=\"ml-1\"\n                  [node]=\"input.value.values[cycle['@id']].nodes[0]\"\n                  key=\"value\"\n                ></he-blank-node-state>\n              </span>\n            </td>\n          </tr>\n        </tbody>\n      </table>\n    </div>\n\n    <he-blank-node-state-notice [dataState]=\"dataState\"></he-blank-node-state-notice>\n\n    <he-cycles-suggest-form *ngIf=\"enableCompare\" [cycles]=\"cycles\" (cycleAdded)=\"addCycle($event)\"></he-cycles-suggest-form>\n  </div>\n\n  <he-cycles-activity-logs *ngIf=\"selectedView === View.logs && !isOriginal\"\n    [original]=\"originalValues[0]\"\n    [recalculated]=\"cycles[0]\"\n  ></he-cycles-activity-logs>\n</ng-container>\n\n<he-node-csv-export-confirm *ngIf=\"showDownload\"\n  [nodes]=\"cycles\" filename=\"cycle-inputs-products.csv\" [isUpload]=\"false\"\n  [headerKeys]=\"['cycle.id', 'cycle.@id', 'cycle.inputs.', 'cycle.products.']\"\n  (closed)=\"showDownload = false\"\n></he-node-csv-export-confirm>\n\n<ng-template #emptyTable>\n  <div class=\"panel-block\">\n    <span>No activity data</span>\n  </div>\n</ng-template>\n\n<ng-template #emptyValue>\n  <span>-</span>\n</ng-template>\n\n<ng-template #details let-node=\"cycle\" let-data=\"data\" let-key=\"key\">\n  <p><b>{{node.name}}</b></p>\n  <he-node-value-details\n    [data]=\"data\" [nodeType]=\"node['@type']\" [dataKey]=\"key\"\n  ></he-node-value-details>\n</ng-template>\n"]}