@hestia-earth/ui-components 0.0.1

package/esm2015/cycles/cycles-suggest-form/cycles-suggest-form.component.js

@@ -0,0 +1,83 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { NodeType } from '@hestia-earth/schema';
+import { of } from 'rxjs';
+import { debounceTime, distinctUntilChanged, switchMap, tap } from 'rxjs/operators';
+import { matchType, matchExactQuery, matchPhraseQuery, matchPhrasePrefixQuery, matchBoolPrefixQuery, matchAggregatedQuery } from '../../search/search.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../node/node.service";
+import * as i3 from "../../search/search.service";
+import * as i4 from "@fortawesome/angular-fontawesome";
+import * as i5 from "@ng-bootstrap/ng-bootstrap";
+import * as i6 from "@angular/common";
+const MIN_TYPEAHEAD_LENGTH = 1;
+export class CyclesSuggestFormComponent {
+    constructor(formBuilder, nodeService, searchService) {
+        this.formBuilder = formBuilder;
+        this.nodeService = nodeService;
+        this.searchService = searchService;
+        this.cycles = [];
+        this.cycleAdded = new EventEmitter();
+        this.form = this.formBuilder.group({
+            search: ['', Validators.required]
+        });
+        this.loading = false;
+        this.suggesting = false;
+        this.formatter = ({ '@id': id }) => id;
+        this.suggestCycle = (text$) => text$.pipe(debounceTime(300), distinctUntilChanged(), tap(() => this.suggesting = true), switchMap(term => this.suggest(term)), tap(() => this.suggesting = false));
+    }
+    suggest(term) {
+        return term.length < MIN_TYPEAHEAD_LENGTH ?
+            of([]) :
+            this.searchService.suggest(term, NodeType.Cycle, [], {
+                bool: {
+                    must: [
+                        matchType(NodeType.Cycle),
+                        matchAggregatedQuery
+                    ],
+                    must_not: this.cycles.map(({ '@id': id }) => matchExactQuery('@id', id)),
+                    should: [
+                        matchPhraseQuery(term, 100, '@id', 'name'),
+                        matchPhrasePrefixQuery(term, 20, '@id', 'name'),
+                        matchBoolPrefixQuery(term, 10, '@id', 'name')
+                    ],
+                    minimum_should_match: 1
+                }
+            }, 10, ['name', 'site.country.name', 'products.name', 'endDate']);
+    }
+    loadCycle(id) {
+        return this.nodeService.get({
+            '@type': NodeType.Cycle,
+            '@id': id
+        }, false);
+    }
+    submit() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.loading = true;
+            const { search: { '@id': id } } = this.form.value;
+            const cycle = yield this.loadCycle(id);
+            this.cycleAdded.emit(cycle);
+            (_a = this.form.get('search')) === null || _a === void 0 ? void 0 : _a.setValue('');
+            this.form.updateValueAndValidity();
+            this.loading = false;
+        });
+    }
+}
+CyclesSuggestFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CyclesSuggestFormComponent, deps: [{ token: i1.FormBuilder }, { token: i2.HeNodeService }, { token: i3.HeSearchService }], target: i0.ɵɵFactoryTarget.Component });
+CyclesSuggestFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: CyclesSuggestFormComponent, selector: "he-cycles-suggest-form", inputs: { cycles: "cycles" }, outputs: { cycleAdded: "cycleAdded" }, ngImport: i0, template: "<form class=\"mt-2\" [formGroup]=\"form\" (submit)=\"form.valid && submit()\">\n  <div class=\"field has-addons\">\n    <div class=\"control\">\n      <span class=\"button is-small is-static\">Compare with Aggregated Cycle</span>\n    </div>\n    <div class=\"control is-expanded\" [class.has-icons-right]=\"suggesting || loading\">\n      <input class=\"input is-small\"\n        placeholder=\"Search by name or id\"\n        formControlName=\"search\" name=\"search\"\n\n        [ngbTypeahead]=\"suggestCycle\"\n        [inputFormatter]=\"formatter\"\n        [resultTemplate]=\"suggestion\"\n        [focusFirst]=\"true\"\n      >\n      <span class=\"icon is-small is-right has-text-grey-dark\" [class.is-hidden]=\"!(suggesting || loading)\">\n        <fa-icon icon=\"spinner\" [pulse]=\"true\" size=\"sm\"></fa-icon>\n      </span>\n    </div>\n    <div class=\"control\">\n      <button class=\"button is-small\" type=\"submit\" [disabled]=\"suggesting || loading\">\n        <fa-icon icon=\"plus\"></fa-icon>\n      </button>\n    </div>\n  </div>\n</form>\n\n<ng-template #suggestion let-cycle=\"result\" let-t=\"term\">\n  <div class=\"is-block\">\n    <ngb-highlight [result]=\"cycle.name\" [term]=\"t\"></ngb-highlight>\n  </div>\n  <div class=\"columns is-flex\">\n    <div class=\"column\" *ngIf=\"cycle.site?.country?.name\">\n      <span class=\"pr-1 has-text-underline\">Country:</span>\n      <span class=\"is-inline-flex\"><ngb-highlight [result]=\"cycle.site.country.name\" [term]=\"t\"></ngb-highlight></span>\n    </div>\n    <!-- <div class=\"column\" *ngIf=\"impact.product\">\n      <span class=\"pr-1 has-text-underline\">Product:</span>\n      <span class=\"is-inline-flex\"><ngb-highlight [result]=\"impact.product.name\" [term]=\"t\"></ngb-highlight></span>\n    </div> -->\n    <div class=\"column\" *ngIf=\"cycle.endDate\">\n      <span class=\"pr-1 has-text-underline\">Date:</span>\n      <span class=\"is-inline-flex\"><ngb-highlight [result]=\"cycle.endDate\" [term]=\"t\"></ngb-highlight></span>\n    </div>\n  </div>\n</ng-template>\n", styles: [""], components: [{ type: i4.FaIconComponent, selector: "fa-icon", inputs: ["classes", "icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "transform", "a11yRole"] }, { type: i5.NgbHighlight, selector: "ngb-highlight", inputs: ["highlightClass", "result", "term"] }], directives: [{ type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i1.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: i5.NgbTypeahead, selector: "input[ngbTypeahead]", inputs: ["autocomplete", "placement", "container", "editable", "focusFirst", "showHint", "inputFormatter", "ngbTypeahead", "resultFormatter", "resultTemplate"], outputs: ["selectItem"], exportAs: ["ngbTypeahead"] }, { type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CyclesSuggestFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'he-cycles-suggest-form',
+                    templateUrl: './cycles-suggest-form.component.html',
+                    styleUrls: ['./cycles-suggest-form.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormBuilder }, { type: i2.HeNodeService }, { type: i3.HeSearchService }]; }, propDecorators: { cycles: [{
+                type: Input
+            }], cycleAdded: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cycles-suggest-form.component.js","sourceRoot":"","sources":["../../../../src/cycles/cycles-suggest-form/cycles-suggest-form.component.ts","../../../../src/cycles/cycles-suggest-form/cycles-suggest-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Output } from '@angular/core';\nimport { FormBuilder, Validators } from '@angular/forms';\nimport { ICycleJSONLD, NodeType } from '@hestia-earth/schema';\nimport { Observable, of } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, switchMap, tap } from 'rxjs/operators';\n\nimport { HeNodeService } from '../../node/node.service';\nimport { HeSearchService } from '../../search/search.service';\nimport {\n  matchType, matchExactQuery, matchPhraseQuery, matchPhrasePrefixQuery, matchBoolPrefixQuery, matchAggregatedQuery\n} from '../../search/search.model';\n\nconst MIN_TYPEAHEAD_LENGTH = 1;\n\n@Component({\n  selector: 'he-cycles-suggest-form',\n  templateUrl: './cycles-suggest-form.component.html',\n  styleUrls: ['./cycles-suggest-form.component.scss']\n})\nexport class CyclesSuggestFormComponent {\n  @Input()\n  private cycles: ICycleJSONLD[] = [];\n  @Output()\n  private cycleAdded = new EventEmitter<ICycleJSONLD>();\n\n  public form = this.formBuilder.group({\n    search: ['', Validators.required]\n  });\n  public loading = false;\n  public suggesting = false;\n  public formatter = ({ '@id': id }: any) => id;\n  public suggestCycle = (text$: Observable<string>) =>\n    text$.pipe(\n      debounceTime(300),\n      distinctUntilChanged(),\n      tap(() => this.suggesting = true),\n      switchMap(term => this.suggest(term)),\n      tap(() => this.suggesting = false)\n    );\n\n  constructor(\n    private formBuilder: FormBuilder,\n    private nodeService: HeNodeService,\n    private searchService: HeSearchService\n  ) { }\n\n  private suggest(term: string) {\n    return term.length < MIN_TYPEAHEAD_LENGTH ?\n      of([]) :\n      this.searchService.suggest(term, NodeType.Cycle, [], {\n        bool: {\n          must: [\n            matchType(NodeType.Cycle),\n            matchAggregatedQuery\n          ],\n          must_not: this.cycles.map(({ '@id': id }) => matchExactQuery('@id', id)),\n          should: [\n            matchPhraseQuery(term, 100, '@id', 'name'),\n            matchPhrasePrefixQuery(term, 20, '@id', 'name'),\n            matchBoolPrefixQuery(term, 10, '@id', 'name')\n          ],\n          minimum_should_match: 1\n        }\n      }, 10, ['name', 'site.country.name', 'products.name', 'endDate']);\n  }\n\n  private loadCycle(id: string) {\n    return this.nodeService.get<ICycleJSONLD>({\n      '@type': NodeType.Cycle,\n      '@id': id\n    }, false);\n  }\n\n  public async submit() {\n    this.loading = true;\n    const { search: { '@id': id } } = this.form.value;\n    const cycle = await this.loadCycle(id);\n    this.cycleAdded.emit(cycle);\n    this.form.get('search')?.setValue('');\n    this.form.updateValueAndValidity();\n    this.loading = false;\n  }\n}\n","<form class=\"mt-2\" [formGroup]=\"form\" (submit)=\"form.valid && submit()\">\n  <div class=\"field has-addons\">\n    <div class=\"control\">\n      <span class=\"button is-small is-static\">Compare with Aggregated Cycle</span>\n    </div>\n    <div class=\"control is-expanded\" [class.has-icons-right]=\"suggesting || loading\">\n      <input class=\"input is-small\"\n        placeholder=\"Search by name or id\"\n        formControlName=\"search\" name=\"search\"\n\n        [ngbTypeahead]=\"suggestCycle\"\n        [inputFormatter]=\"formatter\"\n        [resultTemplate]=\"suggestion\"\n        [focusFirst]=\"true\"\n      >\n      <span class=\"icon is-small is-right has-text-grey-dark\" [class.is-hidden]=\"!(suggesting || loading)\">\n        <fa-icon icon=\"spinner\" [pulse]=\"true\" size=\"sm\"></fa-icon>\n      </span>\n    </div>\n    <div class=\"control\">\n      <button class=\"button is-small\" type=\"submit\" [disabled]=\"suggesting || loading\">\n        <fa-icon icon=\"plus\"></fa-icon>\n      </button>\n    </div>\n  </div>\n</form>\n\n<ng-template #suggestion let-cycle=\"result\" let-t=\"term\">\n  <div class=\"is-block\">\n    <ngb-highlight [result]=\"cycle.name\" [term]=\"t\"></ngb-highlight>\n  </div>\n  <div class=\"columns is-flex\">\n    <div class=\"column\" *ngIf=\"cycle.site?.country?.name\">\n      <span class=\"pr-1 has-text-underline\">Country:</span>\n      <span class=\"is-inline-flex\"><ngb-highlight [result]=\"cycle.site.country.name\" [term]=\"t\"></ngb-highlight></span>\n    </div>\n    <!-- <div class=\"column\" *ngIf=\"impact.product\">\n      <span class=\"pr-1 has-text-underline\">Product:</span>\n      <span class=\"is-inline-flex\"><ngb-highlight [result]=\"impact.product.name\" [term]=\"t\"></ngb-highlight></span>\n    </div> -->\n    <div class=\"column\" *ngIf=\"cycle.endDate\">\n      <span class=\"pr-1 has-text-underline\">Date:</span>\n      <span class=\"is-inline-flex\"><ngb-highlight [result]=\"cycle.endDate\" [term]=\"t\"></ngb-highlight></span>\n    </div>\n  </div>\n</ng-template>\n"]}

package/esm2015/cycles/cycles.model.js

@@ -0,0 +1,2 @@
+export const primaryProduct = ({ products }) => (products || []).find(({ primary }) => primary);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3ljbGVzLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2N5Y2xlcy9jeWNsZXMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsRUFBRSxRQUFRLEVBQXlCLEVBQUUsRUFBRSxDQUFDLENBQUMsUUFBUSxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTm9kZVR5cGUsIElDeWNsZUpTT05MRCB9IGZyb20gJ0BoZXN0aWEtZWFydGgvc2NoZW1hJztcblxuZXhwb3J0IGludGVyZmFjZSBJQ3ljbGVKU09OTERFeHRlbmRlZCBleHRlbmRzIElDeWNsZUpTT05MRCB7XG4gIHJlbGF0ZWQ6IHtcbiAgICBbdHlwZSBpbiBOb2RlVHlwZV0/OiBzdHJpbmdbXTtcbiAgfTtcbn1cblxuZXhwb3J0IGNvbnN0IHByaW1hcnlQcm9kdWN0ID0gKHsgcHJvZHVjdHMgfTogUGFydGlhbDxJQ3ljbGVKU09OTEQ+KSA9PiAocHJvZHVjdHMgfHwgW10pLmZpbmQoKHsgcHJpbWFyeSB9KSA9PiBwcmltYXJ5KTtcbiJdfQ==

package/esm2015/cycles/cycles.module.js

@@ -0,0 +1,66 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { HeCommonModule } from '../common/common.module';
+import { HeNodeModule } from '../node/node.module';
+import { CyclesActivityComponent } from './cycles-activity/cycles-activity.component';
+import { CyclesActivityLogsComponent } from './cycles-activity-logs/cycles-activity-logs.component';
+import { CyclesCompletenessComponent } from './cycles-completeness/cycles-completeness.component';
+import { CyclesEmissionsChartComponent } from './cycles-emissions-chart/cycles-emissions-chart.component';
+import { CyclesEmissionsLogsComponent } from './cycles-emissions-logs/cycles-emissions-logs.component';
+import { CyclesEmissionsComponent } from './cycles-emissions/cycles-emissions.component';
+import { CyclesFunctionalUnitMeasureComponent } from './cycles-functional-unit-measure/cycles-functional-unit-measure.component';
+import { CyclesResultComponent } from './cycles-result/cycles-result.component';
+import { CyclesSuggestFormComponent } from './cycles-suggest-form/cycles-suggest-form.component';
+import * as i0 from "@angular/core";
+const components = [
+    CyclesActivityComponent,
+    CyclesActivityLogsComponent,
+    CyclesCompletenessComponent,
+    CyclesEmissionsComponent,
+    CyclesEmissionsChartComponent,
+    CyclesEmissionsLogsComponent,
+    CyclesFunctionalUnitMeasureComponent,
+    CyclesResultComponent,
+    CyclesSuggestFormComponent
+];
+export class HeCyclesModule {
+}
+HeCyclesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeCyclesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+HeCyclesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeCyclesModule, declarations: [CyclesActivityComponent,
+        CyclesActivityLogsComponent,
+        CyclesCompletenessComponent,
+        CyclesEmissionsComponent,
+        CyclesEmissionsChartComponent,
+        CyclesEmissionsLogsComponent,
+        CyclesFunctionalUnitMeasureComponent,
+        CyclesResultComponent,
+        CyclesSuggestFormComponent], imports: [CommonModule, FormsModule, ReactiveFormsModule,
+        HeCommonModule,
+        HeNodeModule], exports: [CyclesActivityComponent,
+        CyclesActivityLogsComponent,
+        CyclesCompletenessComponent,
+        CyclesEmissionsComponent,
+        CyclesEmissionsChartComponent,
+        CyclesEmissionsLogsComponent,
+        CyclesFunctionalUnitMeasureComponent,
+        CyclesResultComponent,
+        CyclesSuggestFormComponent] });
+HeCyclesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeCyclesModule, imports: [[
+            CommonModule, FormsModule, ReactiveFormsModule,
+            HeCommonModule,
+            HeNodeModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeCyclesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: components,
+                    exports: components,
+                    imports: [
+                        CommonModule, FormsModule, ReactiveFormsModule,
+                        HeCommonModule,
+                        HeNodeModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3ljbGVzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jeWNsZXMvY3ljbGVzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsV0FBVyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFbEUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUN0RixPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx1REFBdUQsQ0FBQztBQUNwRyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxxREFBcUQsQ0FBQztBQUNsRyxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSwyREFBMkQsQ0FBQztBQUMxRyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSx5REFBeUQsQ0FBQztBQUN2RyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUN6RixPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSwyRUFBMkUsQ0FBQztBQUNqSSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUNoRixPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxxREFBcUQsQ0FBQzs7QUFFakcsTUFBTSxVQUFVLEdBQUc7SUFDakIsdUJBQXVCO0lBQ3ZCLDJCQUEyQjtJQUMzQiwyQkFBMkI7SUFDM0Isd0JBQXdCO0lBQ3hCLDZCQUE2QjtJQUM3Qiw0QkFBNEI7SUFDNUIsb0NBQW9DO0lBQ3BDLHFCQUFxQjtJQUNyQiwwQkFBMEI7Q0FDM0IsQ0FBQztBQVdGLE1BQU0sT0FBTyxjQUFjOzs0R0FBZCxjQUFjOzZHQUFkLGNBQWMsaUJBcEJ6Qix1QkFBdUI7UUFDdkIsMkJBQTJCO1FBQzNCLDJCQUEyQjtRQUMzQix3QkFBd0I7UUFDeEIsNkJBQTZCO1FBQzdCLDRCQUE0QjtRQUM1QixvQ0FBb0M7UUFDcEMscUJBQXFCO1FBQ3JCLDBCQUEwQixhQU94QixZQUFZLEVBQUUsV0FBVyxFQUFFLG1CQUFtQjtRQUM5QyxjQUFjO1FBQ2QsWUFBWSxhQWpCZCx1QkFBdUI7UUFDdkIsMkJBQTJCO1FBQzNCLDJCQUEyQjtRQUMzQix3QkFBd0I7UUFDeEIsNkJBQTZCO1FBQzdCLDRCQUE0QjtRQUM1QixvQ0FBb0M7UUFDcEMscUJBQXFCO1FBQ3JCLDBCQUEwQjs2R0FZZixjQUFjLFlBTmhCO1lBQ1AsWUFBWSxFQUFFLFdBQVcsRUFBRSxtQkFBbUI7WUFDOUMsY0FBYztZQUNkLFlBQVk7U0FDYjs0RkFFVSxjQUFjO2tCQVQxQixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxVQUFVO29CQUN4QixPQUFPLEVBQUUsVUFBVTtvQkFDbkIsT0FBTyxFQUFFO3dCQUNQLFlBQVksRUFBRSxXQUFXLEVBQUUsbUJBQW1CO3dCQUM5QyxjQUFjO3dCQUNkLFlBQVk7cUJBQ2I7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZvcm1zTW9kdWxlLCBSZWFjdGl2ZUZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5pbXBvcnQgeyBIZUNvbW1vbk1vZHVsZSB9IGZyb20gJy4uL2NvbW1vbi9jb21tb24ubW9kdWxlJztcbmltcG9ydCB7IEhlTm9kZU1vZHVsZSB9IGZyb20gJy4uL25vZGUvbm9kZS5tb2R1bGUnO1xuXG5pbXBvcnQgeyBDeWNsZXNBY3Rpdml0eUNvbXBvbmVudCB9IGZyb20gJy4vY3ljbGVzLWFjdGl2aXR5L2N5Y2xlcy1hY3Rpdml0eS5jb21wb25lbnQnO1xuaW1wb3J0IHsgQ3ljbGVzQWN0aXZpdHlMb2dzQ29tcG9uZW50IH0gZnJvbSAnLi9jeWNsZXMtYWN0aXZpdHktbG9ncy9jeWNsZXMtYWN0aXZpdHktbG9ncy5jb21wb25lbnQnO1xuaW1wb3J0IHsgQ3ljbGVzQ29tcGxldGVuZXNzQ29tcG9uZW50IH0gZnJvbSAnLi9jeWNsZXMtY29tcGxldGVuZXNzL2N5Y2xlcy1jb21wbGV0ZW5lc3MuY29tcG9uZW50JztcbmltcG9ydCB7IEN5Y2xlc0VtaXNzaW9uc0NoYXJ0Q29tcG9uZW50IH0gZnJvbSAnLi9jeWNsZXMtZW1pc3Npb25zLWNoYXJ0L2N5Y2xlcy1lbWlzc2lvbnMtY2hhcnQuY29tcG9uZW50JztcbmltcG9ydCB7IEN5Y2xlc0VtaXNzaW9uc0xvZ3NDb21wb25lbnQgfSBmcm9tICcuL2N5Y2xlcy1lbWlzc2lvbnMtbG9ncy9jeWNsZXMtZW1pc3Npb25zLWxvZ3MuY29tcG9uZW50JztcbmltcG9ydCB7IEN5Y2xlc0VtaXNzaW9uc0NvbXBvbmVudCB9IGZyb20gJy4vY3ljbGVzLWVtaXNzaW9ucy9jeWNsZXMtZW1pc3Npb25zLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDeWNsZXNGdW5jdGlvbmFsVW5pdE1lYXN1cmVDb21wb25lbnQgfSBmcm9tICcuL2N5Y2xlcy1mdW5jdGlvbmFsLXVuaXQtbWVhc3VyZS9jeWNsZXMtZnVuY3Rpb25hbC11bml0LW1lYXN1cmUuY29tcG9uZW50JztcbmltcG9ydCB7IEN5Y2xlc1Jlc3VsdENvbXBvbmVudCB9IGZyb20gJy4vY3ljbGVzLXJlc3VsdC9jeWNsZXMtcmVzdWx0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDeWNsZXNTdWdnZXN0Rm9ybUNvbXBvbmVudCB9IGZyb20gJy4vY3ljbGVzLXN1Z2dlc3QtZm9ybS9jeWNsZXMtc3VnZ2VzdC1mb3JtLmNvbXBvbmVudCc7XG5cbmNvbnN0IGNvbXBvbmVudHMgPSBbXG4gIEN5Y2xlc0FjdGl2aXR5Q29tcG9uZW50LFxuICBDeWNsZXNBY3Rpdml0eUxvZ3NDb21wb25lbnQsXG4gIEN5Y2xlc0NvbXBsZXRlbmVzc0NvbXBvbmVudCxcbiAgQ3ljbGVzRW1pc3Npb25zQ29tcG9uZW50LFxuICBDeWNsZXNFbWlzc2lvbnNDaGFydENvbXBvbmVudCxcbiAgQ3ljbGVzRW1pc3Npb25zTG9nc0NvbXBvbmVudCxcbiAgQ3ljbGVzRnVuY3Rpb25hbFVuaXRNZWFzdXJlQ29tcG9uZW50LFxuICBDeWNsZXNSZXN1bHRDb21wb25lbnQsXG4gIEN5Y2xlc1N1Z2dlc3RGb3JtQ29tcG9uZW50XG5dO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IGNvbXBvbmVudHMsXG4gIGV4cG9ydHM6IGNvbXBvbmVudHMsXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBSZWFjdGl2ZUZvcm1zTW9kdWxlLFxuICAgIEhlQ29tbW9uTW9kdWxlLFxuICAgIEhlTm9kZU1vZHVsZVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIEhlQ3ljbGVzTW9kdWxlIHsgfVxuIl19

package/esm2015/cycles/public-api.js

@@ -0,0 +1,11 @@
+export * from './cycles.module';
+export { CyclesActivityComponent } from './cycles-activity/cycles-activity.component';
+export { CyclesActivityLogsComponent } from './cycles-activity-logs/cycles-activity-logs.component';
+export { CyclesCompletenessComponent } from './cycles-completeness/cycles-completeness.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 { CyclesResultComponent } from './cycles-result/cycles-result.component';
+export { CyclesSuggestFormComponent } from './cycles-suggest-form/cycles-suggest-form.component';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/engine/aggregation-engine.service.js

@@ -0,0 +1,126 @@
+import { __awaiter, __rest } from "tslib";
+import { Injectable } from '@angular/core';
+import { forkJoin, from, of, ReplaySubject } from 'rxjs';
+import { catchError, map, take } from 'rxjs/operators';
+import { TermTermType } from '@hestia-earth/schema';
+import * as csvtojson from 'csvtojson';
+import { worldRegion } from '../search/search.model';
+import { primaryProduct } from '../cycles/cycles.model';
+import { propertyValue, delta, gitHome, gitRawBaseUrl } from '../common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../common/common.service";
+import * as i3 from "../node/node.service";
+const get = require('lodash.get');
+const lookups = Object.freeze({
+    cropYield: 'region-crop-cropGroupingFaostatProduction-yield',
+    cropGroupingColumn: 'cropGroupingFaostatProduction'
+});
+const extractGroupedDataClosesDate = (data, year) => {
+    const dataByDate = (data || '').split(';').reduce((prev, curr) => (Object.assign(Object.assign({}, prev), (curr.length > 0 && curr.split(':')[1] !== '-' ? { [curr.split(':')[0]]: curr.split(':')[1] } : {}))), {});
+    const years = Object.keys(dataByDate).map(v => +v);
+    const closestYear = years.reduce((prev, curr) => Math.abs(curr - year) < Math.abs(prev - year) ? curr : prev, 0);
+    return closestYear ? +dataByDate[closestYear] / 10 : null;
+};
+const cropGrouping = (lookup, product) => (lookup.find(({ term }) => term.id === (product === null || product === void 0 ? void 0 : product.term['@id'])) || {})[lookups.cropGroupingColumn];
+const cropYieldCountry = (cropYield, cycle) => cropYield.find(({ term }) => term.id === get(cycle, 'site.country.@id', worldRegion['@id'])) || {};
+export const extendCycle = ({ crop, cropYield }) => (cycle) => {
+    var _a, _b, _c;
+    const product = primaryProduct(cycle);
+    const grouping = cropGrouping(crop, product);
+    const countryData = cropYieldCountry(cropYield, cycle)[grouping];
+    const countryValue = extractGroupedDataClosesDate(countryData, +(cycle.endDate || ''));
+    const productValue = propertyValue(product === null || product === void 0 ? void 0 : product.value);
+    return {
+        cycle,
+        name: (_a = product === null || product === void 0 ? void 0 : product.term) === null || _a === void 0 ? void 0 : _a.name,
+        startDate: cycle.startDate,
+        endDate: cycle.endDate,
+        country: ((_c = (_b = cycle.site) === null || _b === void 0 ? void 0 : _b.country) === null || _c === void 0 ? void 0 : _c.name) || worldRegion.name,
+        observations: propertyValue(product === null || product === void 0 ? void 0 : product.observations) || 0,
+        yield: productValue,
+        faoYield: countryValue || undefined,
+        diff: delta(productValue, countryValue)
+    };
+};
+export class HeAggregationEngineService {
+    constructor(http, commonService, nodeService) {
+        this.http = http;
+        this.commonService = commonService;
+        this.nodeService = nodeService;
+        this.modelsLoading = false;
+        this.modelsLoaded = false;
+        this._models = new ReplaySubject(1);
+        this.lookupsLoading = false;
+        this.lookupsLoaded = false;
+        this._lookups = new ReplaySubject(1);
+        this.init();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loadModels().toPromise();
+        });
+    }
+    get gitUrl() {
+        return `${gitHome}/hestia-aggregation-engine/-/blob/${this.commonService.gitBranch}`;
+    }
+    get rawUrl() {
+        return `${gitRawBaseUrl}/hestia-aggregation-engine/-/raw/${this.commonService.gitBranch}`;
+    }
+    loadModels() {
+        this.modelsLoading = true;
+        return this.http.get(`${this.rawUrl}/model-links.json`).pipe(catchError(() => of({ links: [] })), map(({ links }) => {
+            this._models.next(links.map((_a) => {
+                var { path: modelPath, docPath } = _a, link = __rest(_a, ["path", "docPath"]);
+                return (Object.assign(Object.assign({}, link), { path: `${this.gitUrl}/${modelPath}`, docPath: `${this.gitUrl}/${docPath}` }));
+            }));
+            this.modelsLoading = false;
+            this.modelsLoaded = true;
+            return links;
+        }));
+    }
+    get models$() {
+        return this.modelsLoading || this.modelsLoaded ? this._models.asObservable() : this.loadModels();
+    }
+    models() {
+        return this.models$.pipe(take(1)).toPromise();
+    }
+    model$(model) {
+        return this.models$.pipe(map(models => models.find(m => Object.keys(model).every(key => model[key] === m[key]))));
+    }
+    model(model) {
+        return this.model$(model).pipe(take(1)).toPromise();
+    }
+    loadLookup(filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.nodeService.downloadLookup(filename);
+            return csvtojson({ delimiter: 'auto' }).fromString(data);
+        });
+    }
+    loadLookups() {
+        return forkJoin({
+            cropYield: from(this.loadLookup(lookups.cropYield)),
+            crop: from(this.loadLookup(TermTermType.crop))
+        }).pipe(map(values => {
+            this._lookups.next(values);
+            this.lookupsLoading = false;
+            this.lookupsLoaded = true;
+            return values;
+        }));
+    }
+    get lookups$() {
+        return this.lookupsLoading || this.lookupsLoaded ? this._lookups.asObservable() : this.loadLookups();
+    }
+    lookups() {
+        return this.lookups$.pipe(take(1)).toPromise();
+    }
+}
+HeAggregationEngineService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeAggregationEngineService, deps: [{ token: i1.HttpClient }, { token: i2.HeCommonService }, { token: i3.HeNodeService }], target: i0.ɵɵFactoryTarget.Injectable });
+HeAggregationEngineService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeAggregationEngineService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeAggregationEngineService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.HeCommonService }, { type: i3.HeNodeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aggregation-engine.service.js","sourceRoot":"","sources":["../../../src/engine/aggregation-engine.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { forkJoin, from, of, ReplaySubject } from 'rxjs';\nimport { catchError, map, take } from 'rxjs/operators';\nimport { ICycleJSONLD, NodeType, Product, Term, TermTermType } from '@hestia-earth/schema';\nimport * as csvtojson from 'csvtojson';\nconst get = require('lodash.get');\n\nimport { HeNodeService } from '../node/node.service';\nimport { worldRegion } from '../search/search.model';\nimport { primaryProduct } from '../cycles/cycles.model';\nimport { propertyValue, delta, gitHome, gitRawBaseUrl } from '../common/utils';\nimport { HeCommonService } from '../common/common.service';\n\nconst lookups = Object.freeze({\n  cropYield: 'region-crop-cropGroupingFaostatProduction-yield',\n  cropGroupingColumn: 'cropGroupingFaostatProduction'\n});\n\nexport interface IModel {\n  type: NodeType;\n  /**\n   * Path to the implementation (code) of the model.\n   */\n  path: string;\n  /**\n   * Path to the documentation of the model.\n   */\n  docPath: string;\n  dataPath: string;\n  '@id'?: string;\n}\n\ninterface IModelLinks {\n  links: IModel[];\n}\n\nexport interface ILookups {\n  crop: any[];\n  cropYield: any[];\n}\n\nconst extractGroupedDataClosesDate = (data: string, year: number) => {\n  const dataByDate = (data || '').split(';').reduce((prev, curr) => ({\n    ...prev,\n    ...(curr.length > 0 && curr.split(':')[1] !== '-' ? {[curr.split(':')[0]]: curr.split(':')[1]} : {})\n  }), {});\n  const years = Object.keys(dataByDate).map(v => +v);\n  const closestYear = years.reduce((prev, curr) => Math.abs(curr - year) < Math.abs(prev - year) ? curr : prev, 0);\n  return closestYear ? +dataByDate[closestYear] / 10 : null;\n};\n\nconst cropGrouping = (lookup: any[], product: Product) =>\n  (lookup.find(({ term }) => term.id === product?.term!['@id']) || {})[lookups.cropGroupingColumn];\n\nexport interface ICycle {\n  cycle: ICycleJSONLD;\n  name?: string;\n  startDate?: string;\n  endDate?: string;\n  country: string;\n  observations?: number;\n  yield?: number;\n  faoYield?: number;\n  diff?: number;\n}\n\nconst cropYieldCountry = (cropYield: any[], cycle: ICycleJSONLD) =>\n  cropYield.find(({ term }) => term.id === get(cycle, 'site.country.@id', worldRegion['@id'])) || {};\n\nexport const extendCycle = ({ crop, cropYield }: ILookups) => (cycle: ICycleJSONLD): ICycle => {\n  const product = primaryProduct(cycle);\n  const grouping = cropGrouping(crop, product!);\n  const countryData = cropYieldCountry(cropYield, cycle)[grouping];\n  const countryValue = extractGroupedDataClosesDate(countryData, +(cycle.endDate || ''));\n  const productValue = propertyValue(product?.value!);\n\n  return {\n    cycle,\n    name: product?.term?.name,\n    startDate: cycle.startDate,\n    endDate: cycle.endDate,\n    country: cycle.site?.country?.name || worldRegion.name,\n    observations: propertyValue(product?.observations!) || 0,\n    yield: productValue,\n    faoYield: countryValue || undefined,\n    diff: delta(productValue, countryValue)\n  };\n};\n\nexport interface ITriggerCountryParams {\n  country: Term;\n  product: Product;\n  '@type'?: NodeType;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class HeAggregationEngineService {\n  private modelsLoading = false;\n  private modelsLoaded = false;\n  private _models = new ReplaySubject<IModel[]>(1);\n\n  private lookupsLoading = false;\n  private lookupsLoaded = false;\n  private _lookups = new ReplaySubject<ILookups>(1);\n\n  constructor(\n    private http: HttpClient,\n    private commonService: HeCommonService,\n    private nodeService: HeNodeService\n  ) {\n    this.init();\n  }\n\n  private async init() {\n    await this.loadModels().toPromise();\n  }\n\n  private get gitUrl() {\n    return `${gitHome}/hestia-aggregation-engine/-/blob/${this.commonService.gitBranch}`;\n  }\n\n  private get rawUrl() {\n    return `${gitRawBaseUrl}/hestia-aggregation-engine/-/raw/${this.commonService.gitBranch}`;\n  }\n\n  private loadModels() {\n    this.modelsLoading = true;\n    return this.http.get<IModelLinks>(`${this.rawUrl}/model-links.json`).pipe(\n      catchError(() => of({ links: [] } as IModelLinks)),\n      map(({ links }) => {\n        this._models.next(links.map(({ path: modelPath, docPath, ...link }) => ({\n          ...link,\n          path: `${this.gitUrl}/${modelPath}`,\n          docPath: `${this.gitUrl}/${docPath}`\n        })));\n        this.modelsLoading = false;\n        this.modelsLoaded = true;\n        return links;\n      })\n    );\n  }\n\n  public get models$() {\n    return this.modelsLoading || this.modelsLoaded ? this._models.asObservable() : this.loadModels();\n  }\n\n  public models() {\n    return this.models$.pipe(take(1)).toPromise();\n  }\n\n  public model$(model: Partial<IModel>) {\n    return this.models$.pipe(\n      map(models => models.find(m => Object.keys(model).every(key => model[key] === m[key])))\n    );\n  }\n\n  public model(model: Partial<IModel>) {\n    return this.model$(model).pipe(take(1)).toPromise();\n  }\n\n  private async loadLookup(filename: string) {\n    const data = await this.nodeService.downloadLookup(filename);\n    return csvtojson({ delimiter: 'auto' }).fromString(data!);\n  }\n\n  private loadLookups() {\n    return forkJoin({\n      cropYield: from(this.loadLookup(lookups.cropYield)),\n      crop: from(this.loadLookup(TermTermType.crop))\n    }).pipe(\n      map(values => {\n        this._lookups.next(values);\n        this.lookupsLoading = false;\n        this.lookupsLoaded = true;\n        return values;\n      })\n    );\n  }\n\n  public get lookups$() {\n    return this.lookupsLoading || this.lookupsLoaded ? this._lookups.asObservable() : this.loadLookups();\n  }\n\n  public lookups() {\n    return this.lookups$.pipe(take(1)).toPromise();\n  }\n}\n"]}

package/esm2015/engine/engine.service.js

@@ -0,0 +1,78 @@
+import { __awaiter, __rest } from "tslib";
+import { Injectable, InjectionToken } from '@angular/core';
+import { of, ReplaySubject } from 'rxjs';
+import { catchError, map, take } from 'rxjs/operators';
+import { baseUrl, toDashCase, gitHome, gitRawBaseUrl } from '../common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../common/common.service";
+export const HE_ORCHESTRATOR_BASE_URL = new InjectionToken('HE_ORCHESTRATOR_BASE_URL');
+export const findConfigModels = ({ models }, modelId, modelKey) => models.flat().filter(({ value, key }) => modelId.startsWith(value) && (!modelKey || key === modelKey));
+export const pathToApiDocsPath = (model, term) => [
+    baseUrl(),
+    'docs',
+    [
+        '#hestia-calculation-models',
+        toDashCase(model),
+        toDashCase(term)
+    ].filter(Boolean).join('-')
+].join('/');
+export class HeEngineService {
+    constructor(http, commonService) {
+        this.http = http;
+        this.commonService = commonService;
+        this.modelsLoading = false;
+        this.modelsLoaded = false;
+        this._models = new ReplaySubject(1);
+        this.init();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loadModels().toPromise();
+        });
+    }
+    get gitUrl() {
+        return `${gitHome}/hestia-engine-models/-/blob/${this.commonService.gitBranch}`;
+    }
+    get rawUrl() {
+        return `${gitRawBaseUrl}/hestia-engine-models/-/raw/${this.commonService.gitBranch}`;
+    }
+    loadModels() {
+        this.modelsLoading = true;
+        return this.http.get(`${this.rawUrl}/model-links.json`).pipe(catchError(() => of({ links: [] })), map(({ links }) => {
+            this._models.next(links.map((_a) => {
+                var { path, docPath } = _a, link = __rest(_a, ["path", "docPath"]);
+                return (Object.assign(Object.assign({}, link), { path: `${this.gitUrl}/${path}`, docPath: `${this.gitUrl}/${docPath}`, apiDocsPath: pathToApiDocsPath(link.model, link.term || link.modelKey) }));
+            }));
+            this.modelsLoading = false;
+            this.modelsLoaded = true;
+            return links;
+        }));
+    }
+    get models$() {
+        return this.modelsLoading || this.modelsLoaded ? this._models.asObservable() : this.loadModels();
+    }
+    models() {
+        return this.models$.pipe(take(1)).toPromise();
+    }
+    model$(model) {
+        return this.models$.pipe(map(models => models.find(m => Object.keys(model).every(key => model[key] === m[key]))));
+    }
+    model(model) {
+        return this.model$(model).pipe(take(1)).toPromise();
+    }
+    ochestratorConfig(type) {
+        return this.http.get(`${HE_ORCHESTRATOR_BASE_URL}/${type}.json`, {
+            params: { inline: false }
+        }).toPromise();
+    }
+}
+HeEngineService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeEngineService, deps: [{ token: i1.HttpClient }, { token: i2.HeCommonService }], target: i0.ɵɵFactoryTarget.Injectable });
+HeEngineService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeEngineService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeEngineService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.HeCommonService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"engine.service.js","sourceRoot":"","sources":["../../../src/engine/engine.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, InjectionToken } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { of, ReplaySubject } from 'rxjs';\nimport { catchError, map, take } from 'rxjs/operators';\nimport { NodeType } from '@hestia-earth/schema';\n\nimport { baseUrl, toDashCase, gitHome, gitRawBaseUrl } from '../common/utils';\nimport { HeCommonService } from '../common/common.service';\n\nexport const HE_ORCHESTRATOR_BASE_URL = new InjectionToken<string>('HE_ORCHESTRATOR_BASE_URL');\n\nexport const findConfigModels = ({ models }: IOrchestratorConfig, modelId: string, modelKey: string) =>\n  models.flat().filter(({ value, key }) => modelId.startsWith(value) && (!modelKey || key === modelKey));\n\nexport const pathToApiDocsPath = (model: string, term?: string) =>\n  [\n    baseUrl(),\n    'docs',\n    [\n      '#hestia-calculation-models',\n      toDashCase(model),\n      toDashCase(term)\n    ].filter(Boolean).join('-')\n  ].join('/');\n\nexport interface IModel {\n  /**\n   * Path to the implementation (code) of the model.\n   */\n  path: string;\n  /**\n   * Path to the documentation of the model.\n   */\n  docPath: string;\n  /**\n   * Path to the API Documentation.\n   */\n  apiDocsPath?: string;\n  /**\n   * The name of the model used as `methodModel`.\n   */\n  model: string;\n  /**\n   * The term the model is associated with.\n   */\n  term?: string;\n  /**\n   * A key in the model if term does not exist.\n   */\n  modelKey?: string;\n}\n\ninterface IModelLinks {\n  links: IModel[];\n}\n\nexport interface IOrchestratorModelConfig {\n  key: string;\n  model: string;\n  value: string;\n}\n\nexport interface IOrchestratorConfig {\n  models: IOrchestratorModelConfig[];\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class HeEngineService {\n  private modelsLoading = false;\n  private modelsLoaded = false;\n  private _models = new ReplaySubject<IModel[]>(1);\n\n  constructor(\n    private http: HttpClient,\n    private commonService: HeCommonService\n  ) {\n    this.init();\n  }\n\n  private async init() {\n    await this.loadModels().toPromise();\n  }\n\n  private get gitUrl() {\n    return `${gitHome}/hestia-engine-models/-/blob/${this.commonService.gitBranch}`;\n  }\n\n  private get rawUrl() {\n    return `${gitRawBaseUrl}/hestia-engine-models/-/raw/${this.commonService.gitBranch}`;\n  }\n\n  private loadModels() {\n    this.modelsLoading = true;\n    return this.http.get<IModelLinks>(`${this.rawUrl}/model-links.json`).pipe(\n      catchError(() => of({ links: [] } as IModelLinks)),\n      map(({ links }) => {\n        this._models.next(links.map(({ path, docPath, ...link }) => ({\n          ...link,\n          path: `${this.gitUrl}/${path}`,\n          docPath: `${this.gitUrl}/${docPath}`,\n          apiDocsPath: pathToApiDocsPath(link.model, link.term || link.modelKey)\n        })));\n        this.modelsLoading = false;\n        this.modelsLoaded = true;\n        return links;\n      })\n    );\n  }\n\n  public get models$() {\n    return this.modelsLoading || this.modelsLoaded ? this._models.asObservable() : this.loadModels();\n  }\n\n  public models() {\n    return this.models$.pipe(take(1)).toPromise();\n  }\n\n  public model$(model: Partial<IModel>) {\n    return this.models$.pipe(\n      map(models => models.find(m => Object.keys(model).every(key => model[key] === m[key])))\n    );\n  }\n\n  public model(model: Partial<IModel>) {\n    return this.model$(model).pipe(take(1)).toPromise();\n  }\n\n  public ochestratorConfig(type: NodeType) {\n    return this.http.get<IOrchestratorConfig>(`${HE_ORCHESTRATOR_BASE_URL}/${type}.json`, {\n      params: { inline: false }\n    }).toPromise();\n  }\n}\n"]}

package/esm2015/engine/public-api.js

@@ -0,0 +1,3 @@
+export { HeAggregationEngineService } from './aggregation-engine.service';
+export { HeEngineService, HE_ORCHESTRATOR_BASE_URL } from './engine.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbmdpbmUvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUMxRSxPQUFPLEVBQUUsZUFBZSxFQUFFLHdCQUF3QixFQUFFLE1BQU0sa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBIZUFnZ3JlZ2F0aW9uRW5naW5lU2VydmljZSB9IGZyb20gJy4vYWdncmVnYXRpb24tZW5naW5lLnNlcnZpY2UnO1xuZXhwb3J0IHsgSGVFbmdpbmVTZXJ2aWNlLCBIRV9PUkNIRVNUUkFUT1JfQkFTRV9VUkwgfSBmcm9tICcuL2VuZ2luZS5zZXJ2aWNlJztcbiJdfQ==