@hestia-earth/ui-components 0.0.1

package/esm2015/node/public-api.js

@@ -0,0 +1,13 @@
+export * from './node-csv.service';
+export * from './node.module';
+export * from './node.service';
+export { NodeCsvExportConfirmComponent } from './node-csv-export-confirm/node-csv-export-confirm.component';
+export { NodeCsvSelectHeadersComponent } from './node-csv-select-headers/node-csv-select-headers.component';
+export { NodeDiffsComponent } from './node-diffs/node-diffs.component';
+export { NodeIconComponent } from './node-icon/node-icon.component';
+export { NodeLinkComponent } from './node-link/node-link.component';
+export { NodeLogsFileComponent } from './node-logs-file/node-logs-file.component';
+export { NodeLogsModelsComponent } from './node-logs-models/node-logs-models.component';
+export { NodeMissingLookupFactorsComponent } from './node-missing-lookup-factors/node-missing-lookup-factors.component';
+export { NodeValueDetailsComponent } from './node-value-details/node-value-details.component';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public-api.js

@@ -0,0 +1,16 @@
+export * from './auth/public-api';
+export * from './bibliographies/public-api';
+export * from './common/public-api';
+export * from './cycles/public-api';
+export * from './engine/public-api';
+export * from './files/public-api';
+export * from './fontawesome/public-api';
+export * from './impact-assessments/public-api';
+export * from './mendeley/public-api';
+export * from './node/public-api';
+export * from './schema/public-api';
+export * from './search/public-api';
+export * from './sites/public-api';
+export * from './terms/public-api';
+export * from './users/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRoL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9iaWJsaW9ncmFwaGllcy9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9jeWNsZXMvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2VuZ2luZS9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vZmlsZXMvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2ZvbnRhd2Vzb21lL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9pbXBhY3QtYXNzZXNzbWVudHMvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL21lbmRlbGV5L3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vc2l0ZXMvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3Rlcm1zL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi91c2Vycy9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/schema/public-api.js

@@ -0,0 +1,2 @@
+export * from './schema.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zY2hlbWEvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEuc2VydmljZSc7XG4iXX0=

package/esm2015/schema/schema.service.js

@@ -0,0 +1,167 @@
+import { __awaiter } from "tslib";
+/* eslint-disable complexity */
+import { Injectable } from '@angular/core';
+import { from, of, ReplaySubject } from 'rxjs';
+import { catchError, map, mergeMap, reduce, take } from 'rxjs/operators';
+import { isEmpty, isUndefined, isEqual } from '@hestia-earth/utils';
+import { SchemaType, NodeType, SCHEMA_VERSION, sortKeysByType } from '@hestia-earth/schema';
+import { headersFromCsv } from '@hestia-earth/schema-convert';
+import { baseUrl } from '../common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export const linkTypeEnabled = (type) => [
+    NodeType.Cycle,
+    NodeType.ImpactAssessment,
+    NodeType.Site,
+    NodeType.Source,
+    NodeType.Term
+].includes(type);
+export const refToSchemaType = (ref = '') => ref.startsWith('http') ? ref : ref.substring(2).replace('-deep', '').replace('.json#', '');
+export const definitionToSchemaType = ({ title, $ref }) => (title || refToSchemaType($ref));
+const schemaTypeProperties = (properties, schemaType) => schemaType ? [
+    'type',
+    ...('id' in properties && schemaType !== SchemaType.Term ? ['id'] : [])
+] : [];
+const definitionToSchema = ({ required, properties }) => ({
+    required: required || [],
+    properties: properties || {}
+});
+export const schemaRequiredProperties = (schemas, def) => {
+    const schemaType = definitionToSchemaType(def);
+    const { required, properties } = schemaType in schemas ?
+        schemas[schemaType] :
+        definitionToSchema(def);
+    // remove internal properties
+    const props = (required || []).filter(key => !properties[key].internal);
+    return {
+        schemaType,
+        properties: [
+            ...props,
+            ...schemaTypeProperties(properties, schemaType)
+        ].map(key => ({ key, value: properties[key] }))
+    };
+};
+export const valueTypeToDefault = {
+    number: '',
+    integer: '',
+    boolean: false,
+    string: ''
+};
+export const nestingTypeEnabled = (schemaType) => ![
+    SchemaType.Cycle,
+    SchemaType.ImpactAssessment,
+    SchemaType.Organisation,
+    SchemaType.Site,
+    SchemaType.Source
+].includes(schemaType);
+export const nestingEnabled = (schemaType, key) => nestingTypeEnabled(schemaType) || ['type', 'id'].includes(key);
+export const schemaTypeToDefaultValue = (schemas, prop, nested = false) => {
+    const mappings = {
+        object: () => {
+            const { schemaType, properties } = schemaRequiredProperties(schemas, prop);
+            return properties
+                .filter(({ key }) => !nested || nestingEnabled(schemaType, key))
+                .map(({ key, value }) => ({ key, value: schemaTypeToDefaultValue(schemas, value, true) }))
+                .reduce((prev, curr) => (Object.assign(Object.assign({}, prev), { [curr.key]: curr.value })), {});
+        },
+        array: () => {
+            const { items } = prop;
+            return [schemaTypeToDefaultValue(schemas, items, true)];
+        },
+        default: () => prop.default || valueTypeToDefault[prop.type]
+    };
+    const mapped = !prop.type ? mappings.object : (prop.type in mappings ? mappings[prop.type] : mappings.default);
+    return mapped();
+};
+const typePropertiesKeys = {
+    [SchemaType.Term]: ['type', 'id', '@id', 'name']
+};
+export const availableProperties = (schema, schemaType, value, isTopLevel = true, skipExistingNode = true) => {
+    const { properties } = 'properties' in schema ? schema : { properties: {} };
+    const keys = schemaType in typePropertiesKeys ? typePropertiesKeys[schemaType] : Object.keys(properties || {});
+    const internalProps = keys === null || keys === void 0 ? void 0 : keys.filter(prop => properties[prop].internal);
+    const existing = [
+        ...(isEmpty(value) ? [] : Object.keys(value).filter(v => !isEmpty(value[v]) || value[v] === '')),
+        ...internalProps,
+        ...(isTopLevel ? [] : ['@id']),
+        '@type'
+    ];
+    const available = keys === null || keys === void 0 ? void 0 : keys.filter(prop => !existing.includes(prop)).reduce((prev, prop) => {
+        prev[prop] = properties[prop];
+        return prev;
+    }, {});
+    // avoid editing an existing node
+    const isExistingNode = !isUndefined(value) && !isUndefined(value['@type'] || value.type) && !isUndefined(value['@id']);
+    return isExistingNode && skipExistingNode ? {} : available;
+};
+export const isSchemaIri = (schema) => isEqual(Object.keys((schema === null || schema === void 0 ? void 0 : schema.properties) || {}), ['@id']) && isEqual(((schema === null || schema === void 0 ? void 0 : schema.required) || []), ['@id']);
+export class HeSchemaService {
+    constructor(http) {
+        this.http = http;
+        this.schemasLoading = false;
+        this.schemasLoaded = false;
+        this._schemas = new ReplaySubject(1);
+        this.sortConfigLoading = false;
+        this.sortConfigLoaded = false;
+        this._sortConfig = new ReplaySubject(1);
+    }
+    loadSchemas() {
+        this.schemasLoading = true;
+        return from(Object.values(SchemaType)).pipe(mergeMap(type => this.http.get(`${baseUrl()}/schema/${SCHEMA_VERSION}/json-schema/${type}.json`).pipe(map(schema => ({ type, schema })), catchError(() => of({ type, schema: { properties: [] } })))), reduce((prev, { type, schema }) => (Object.assign(Object.assign({}, prev), { [type]: schema })), {}), map(data => {
+            this._schemas.next(data);
+            this.schemasLoading = false;
+            this.schemasLoaded = true;
+            return data;
+        }));
+    }
+    get schemas$() {
+        return this.schemasLoading || this.schemasLoaded ? this._schemas.asObservable() : this.loadSchemas();
+    }
+    schemas() {
+        return this.schemas$.pipe(take(1)).toPromise();
+    }
+    loadSortConfig() {
+        this.sortConfigLoading = true;
+        return this.http.get(`${baseUrl()}/schema/${SCHEMA_VERSION}/sort-config/config.json`).pipe(catchError(() => of(undefined)), map(data => {
+            this._sortConfig.next(data);
+            this.sortConfigLoading = false;
+            this.sortConfigLoaded = true;
+            return data;
+        }));
+    }
+    get sortConfig$() {
+        return this.sortConfigLoading || this.sortConfigLoaded ? this._sortConfig.asObservable() : this.loadSortConfig();
+    }
+    sortConfig() {
+        return this.sortConfig$.pipe(take(1)).toPromise();
+    }
+    /**
+     * Parse and sort (if possible) headers from CSV content according to the schema order.
+     * This will load the sort configuration according to the current schema version.
+     *
+     * @param csvContent The content as a string
+     * @returns List of strings as Observable when parsing / sorting is done.
+     */
+    parseHeaders(csvContent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = headersFromCsv(csvContent);
+            try {
+                const config = yield this.sortConfig();
+                return sortKeysByType(headers, 'asc', config);
+            }
+            catch (err) {
+                return headers;
+            }
+        });
+    }
+    ;
+}
+HeSchemaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSchemaService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+HeSchemaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSchemaService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSchemaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.service.js","sourceRoot":"","sources":["../../../src/schema/schema.service.ts"],"names":[],"mappings":";AAAA,+BAA+B;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAc,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAIxG,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;;;AAE1C,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAA2B,EAAE,EAAE,CAAC;IAC9D,QAAQ,CAAC,KAAK;IACd,QAAQ,CAAC,gBAAgB;IACzB,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,MAAM;IACf,QAAQ,CAAC,IAAI;CACd,CAAC,QAAQ,CAAC,IAAgB,CAAC,CAAC;AAE7B,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,GAAG,GAAG,EAAE,EAAE,EAAE,CAC1C,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAe,CAAC;AAE3G,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,EAAqB,EAAE,EAAE,CAC3E,CAAC,KAAK,IAAI,eAAe,CAAC,IAAI,CAAC,CAAe,CAAC;AAEjD,MAAM,oBAAoB,GAAG,CAAC,UAAiC,EAAE,UAAuB,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IACxG,MAAM;IACN,GAAG,CAAC,IAAI,IAAI,UAAU,IAAI,UAAU,KAAK,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;CACxE,CAAC,CAAC,CAAC,EAAE,CAAC;AAEP,MAAM,kBAAkB,GAAG,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAqB,EAAE,EAAE,CAAC,CAAC;IAC3E,QAAQ,EAAE,QAAQ,IAAI,EAAE;IACxB,UAAU,EAAE,UAAU,IAAI,EAAE;CAC7B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,OAAoB,EAAE,GAAsB,EAAE,EAAE;IACvF,MAAM,UAAU,GAAG,sBAAsB,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,IAAI,OAAO,CAAC,CAAC;QACrD,OAAO,CAAC,UAAU,CAAuB,CAAC,CAAC;QAC5C,kBAAkB,CAAC,GAAG,CAAC,CAAC;IAC1B,6BAA6B;IAC7B,MAAM,KAAK,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;IACxE,OAAO;QACL,UAAU;QACV,UAAU,EAAE;YACV,GAAG,KAAK;YACR,GAAG,oBAAoB,CAAC,UAAU,EAAE,UAAU,CAAC;SAChD,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;KAChD,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,EAAE;CACX,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,UAAsB,EAAE,EAAE,CAAC,CAAC;IAC7D,UAAU,CAAC,KAAK;IAChB,UAAU,CAAC,gBAAgB;IAC3B,UAAU,CAAC,YAAY;IACvB,UAAU,CAAC,IAAI;IACf,UAAU,CAAC,MAAM;CAClB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAEvB,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,UAAsB,EAAE,GAAW,EAAE,EAAE,CACpE,kBAAkB,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAEjE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,OAAoB,EAAE,IAAgB,EAAE,MAAM,GAAG,KAAK,EAAO,EAAE;IACtG,MAAM,QAAQ,GAEV;QACF,MAAM,EAAE,GAAG,EAAE;YACX,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,wBAAwB,CAAC,OAAO,EAAE,IAAyB,CAAC,CAAC;YAChG,OAAO,UAAU;iBACd,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,cAAc,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;iBAC/D,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;iBACzF,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,iCAAM,IAAI,KAAE,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,IAAG,EAAE,EAAE,CAAC,CAAC;QACvE,CAAC;QACD,KAAK,EAAE,GAAG,EAAE;YACV,MAAM,EAAE,KAAK,EAAE,GAAG,IAAwB,CAAC;YAC3C,OAAO,CAAC,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QAC1D,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,IAAK,kBAA0B,CAAC,IAAI,CAAC,IAAc,CAAC;KAChF,CAAC;IACF,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAC5C,IAAI,CAAC,IAAc,IAAI,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAc,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CACnF,CAAC;IACF,OAAO,MAAM,EAAE,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAEpB;IACF,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC;CACjD,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,MAAkB,EAAE,UAAsB,EAAE,KAAU,EAAE,UAAU,GAAG,IAAI,EAAE,gBAAgB,GAAG,IAAI,EAClG,EAAE;IACF,MAAM,EAAE,UAAU,EAAE,GAAG,YAAY,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAC5E,MAAM,IAAI,GAAG,UAAU,IAAI,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;IAC/G,MAAM,aAAa,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtE,MAAM,QAAQ,GAAG;QACf,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;QAChG,GAAG,aAAc;QACjB,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC9B,OAAO;KACR,CAAC;IACF,MAAM,SAAS,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,IAAS,EAAE,IAAI,EAAE,EAAE;QAC1F,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC,EAAE,EAAE,CAAC,CAAC;IACP,iCAAiC;IACjC,MAAM,cAAc,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACvH,OAAO,cAAc,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7D,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAA0B,EAAE,EAAE,CACxD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,UAAU,KAAI,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,QAAQ,KAAI,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;AAKxG,MAAM,OAAO,eAAe;IAS1B,YACU,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;QATlB,mBAAc,GAAG,KAAK,CAAC;QACvB,kBAAa,GAAG,KAAK,CAAC;QACtB,aAAQ,GAAG,IAAI,aAAa,CAAc,CAAC,CAAC,CAAC;QAE7C,sBAAiB,GAAG,KAAK,CAAC;QAC1B,qBAAgB,GAAG,KAAK,CAAC;QACzB,gBAAW,GAAG,IAAI,aAAa,CAAa,CAAC,CAAC,CAAC;IAInD,CAAC;IAEG,WAAW;QACjB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAC5B,GAAG,OAAO,EAAE,WAAW,cAAc,gBAAgB,IAAI,OAAO,CACjE,CAAC,IAAI,CACJ,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,EACjC,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAC3D,CAAC,EACF,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,iCAAM,IAAI,KAAE,CAAC,IAAI,CAAC,EAAE,MAAM,IAAG,EAAE,EAAiB,CAAC,EACpF,GAAG,CAAC,IAAI,CAAC,EAAE;YACT,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;YAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IACvG,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IACjD,CAAC;IAEO,cAAc;QACpB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAa,GAAG,OAAO,EAAE,WAAW,cAAc,0BAA0B,CAAC,CAAC,IAAI,CACpG,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,CAAE,SAA+B,CAAC,CAAC,EACtD,GAAG,CAAC,IAAI,CAAC,EAAE;YACT,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;YAC/B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAC7B,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;IACnH,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IACpD,CAAC;IAED;;;;;;OAMG;IACU,YAAY,CAAC,UAAkB;;YAC1C,MAAM,OAAO,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;YAC3C,IAAI;gBACF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;gBACvC,OAAO,cAAc,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;aAC/C;YACD,OAAO,GAAG,EAAE;gBACV,OAAO,OAAO,CAAC;aAChB;QACH,CAAC;KAAA;IAAA,CAAC;;6GA7ES,eAAe;iHAAf,eAAe,cAFd,MAAM;4FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["/* eslint-disable complexity */\nimport { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { from, of, ReplaySubject } from 'rxjs';\nimport { catchError, map, mergeMap, reduce, take } from 'rxjs/operators';\nimport { isEmpty, isUndefined, isEqual } from '@hestia-earth/utils';\nimport { SchemaType, NodeType, SCHEMA_VERSION, sortConfig, sortKeysByType } from '@hestia-earth/schema';\nimport {\n  definitions, definition, IDefinition, IDefinitionObject, IDefinitionArray, IDefinitionProperties\n} from '@hestia-earth/json-schema';\nimport { headersFromCsv } from '@hestia-earth/schema-convert';\n\nimport { baseUrl } from '../common/utils';\n\nexport const linkTypeEnabled = (type: SchemaType | NodeType) => [\n  NodeType.Cycle,\n  NodeType.ImpactAssessment,\n  NodeType.Site,\n  NodeType.Source,\n  NodeType.Term\n].includes(type as NodeType);\n\nexport const refToSchemaType = (ref = '') =>\n  ref.startsWith('http') ? ref : ref.substring(2).replace('-deep', '').replace('.json#', '') as SchemaType;\n\nexport const definitionToSchemaType = ({ title, $ref }: IDefinitionObject) =>\n  (title || refToSchemaType($ref)) as SchemaType;\n\nconst schemaTypeProperties = (properties: IDefinitionProperties, schemaType?: SchemaType) => schemaType ? [\n  'type',\n  ...('id' in properties && schemaType !== SchemaType.Term ? ['id'] : [])\n] : [];\n\nconst definitionToSchema = ({ required, properties }: IDefinitionObject) => ({\n  required: required || [],\n  properties: properties || {}\n});\n\nexport const schemaRequiredProperties = (schemas: definitions, def: IDefinitionObject) => {\n  const schemaType = definitionToSchemaType(def);\n  const { required, properties } = schemaType in schemas ?\n    (schemas[schemaType] as IDefinitionObject) :\n    definitionToSchema(def);\n  // remove internal properties\n  const props = (required || []).filter(key => !properties[key].internal);\n  return {\n    schemaType,\n    properties: [\n      ...props,\n      ...schemaTypeProperties(properties, schemaType)\n    ].map(key => ({ key, value: properties[key] }))\n  };\n};\n\nexport const valueTypeToDefault = {\n  number: '',\n  integer: '',\n  boolean: false,\n  string: ''\n};\n\nexport const nestingTypeEnabled = (schemaType: SchemaType) => ![\n  SchemaType.Cycle,\n  SchemaType.ImpactAssessment,\n  SchemaType.Organisation,\n  SchemaType.Site,\n  SchemaType.Source\n].includes(schemaType);\n\nexport const nestingEnabled = (schemaType: SchemaType, key: string) =>\n  nestingTypeEnabled(schemaType) || ['type', 'id'].includes(key);\n\nexport const schemaTypeToDefaultValue = (schemas: definitions, prop: definition, nested = false): any => {\n  const mappings: {\n    [key: string]: () => any;\n  } = {\n    object: () => {\n      const { schemaType, properties } = schemaRequiredProperties(schemas, prop as IDefinitionObject);\n      return properties\n        .filter(({ key }) => !nested || nestingEnabled(schemaType, key))\n        .map(({ key, value }) => ({ key, value: schemaTypeToDefaultValue(schemas, value, true) }))\n        .reduce((prev, curr) => ({ ...prev, [curr.key]: curr.value }), {});\n    },\n    array: () => {\n      const { items } = prop as IDefinitionArray;\n      return [schemaTypeToDefaultValue(schemas, items, true)];\n    },\n    default: () => prop.default || (valueTypeToDefault as any)[prop.type as string]\n  };\n  const mapped = !prop.type ? mappings.object : (\n    prop.type as string in mappings ? mappings[prop.type as string] : mappings.default\n  );\n  return mapped();\n};\n\nconst typePropertiesKeys: {\n  [type in SchemaType]?: string[];\n} = {\n  [SchemaType.Term]: ['type', 'id', '@id', 'name']\n};\n\nexport const availableProperties = (\n  schema: definition, schemaType: SchemaType, value: any, isTopLevel = true, skipExistingNode = true\n) => {\n  const { properties } = 'properties' in schema ? schema : { properties: {} };\n  const keys = schemaType in typePropertiesKeys ? typePropertiesKeys[schemaType] : Object.keys(properties || {});\n  const internalProps = keys?.filter(prop => properties[prop].internal);\n  const existing = [\n    ...(isEmpty(value) ? [] : Object.keys(value).filter(v => !isEmpty(value[v]) || value[v] === '')),\n    ...internalProps!,\n    ...(isTopLevel ? [] : ['@id']),\n    '@type'\n  ];\n  const available = keys?.filter(prop => !existing.includes(prop)).reduce((prev: any, prop) => {\n    prev[prop] = properties[prop];\n    return prev;\n  }, {});\n  // avoid editing an existing node\n  const isExistingNode = !isUndefined(value) && !isUndefined(value['@type'] || value.type) && !isUndefined(value['@id']);\n  return isExistingNode && skipExistingNode ? {} : available;\n};\n\nexport const isSchemaIri = (schema?: IDefinitionObject) =>\n  isEqual(Object.keys(schema?.properties || {}), ['@id']) && isEqual((schema?.required || []), ['@id']);\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class HeSchemaService {\n  private schemasLoading = false;\n  private schemasLoaded = false;\n  private _schemas = new ReplaySubject<definitions>(1);\n\n  private sortConfigLoading = false;\n  private sortConfigLoaded = false;\n  private _sortConfig = new ReplaySubject<sortConfig>(1);\n\n  constructor(\n    private http: HttpClient\n  ) { }\n\n  private loadSchemas() {\n    this.schemasLoading = true;\n    return from(Object.values(SchemaType)).pipe(\n      mergeMap(type => this.http.get<IDefinition>(\n        `${baseUrl()}/schema/${SCHEMA_VERSION}/json-schema/${type}.json`\n      ).pipe(\n        map(schema => ({ type, schema })),\n        catchError(() => of({ type, schema: { properties: [] } }))\n      )),\n      reduce((prev, { type, schema }) => ({ ...prev, [type]: schema }), {} as definitions),\n      map(data => {\n        this._schemas.next(data);\n        this.schemasLoading = false;\n        this.schemasLoaded = true;\n        return data;\n      })\n    );\n  }\n\n  public get schemas$() {\n    return this.schemasLoading || this.schemasLoaded ? this._schemas.asObservable() : this.loadSchemas();\n  }\n\n  public schemas() {\n    return this.schemas$.pipe(take(1)).toPromise();\n  }\n\n  private loadSortConfig() {\n    this.sortConfigLoading = true;\n    return this.http.get<sortConfig>(`${baseUrl()}/schema/${SCHEMA_VERSION}/sort-config/config.json`).pipe(\n      catchError(() => of((undefined as any) as sortConfig)),\n      map(data => {\n        this._sortConfig.next(data);\n        this.sortConfigLoading = false;\n        this.sortConfigLoaded = true;\n        return data;\n      })\n    );\n  }\n\n  public get sortConfig$() {\n    return this.sortConfigLoading || this.sortConfigLoaded ? this._sortConfig.asObservable() : this.loadSortConfig();\n  }\n\n  public sortConfig() {\n    return this.sortConfig$.pipe(take(1)).toPromise();\n  }\n\n  /**\n   * Parse and sort (if possible) headers from CSV content according to the schema order.\n   * This will load the sort configuration according to the current schema version.\n   *\n   * @param csvContent The content as a string\n   * @returns List of strings as Observable when parsing / sorting is done.\n   */\n  public async parseHeaders(csvContent: string) {\n    const headers = headersFromCsv(csvContent);\n    try {\n      const config = await this.sortConfig();\n      return sortKeysByType(headers, 'asc', config);\n    }\n    catch (err) {\n      return headers;\n    }\n  };\n}\n"]}

package/esm2015/search/public-api.js

@@ -0,0 +1,4 @@
+export * from './search.model';
+export * from './search.module';
+export * from './search.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZWFyY2gvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC5zZXJ2aWNlJztcbiJdfQ==

package/esm2015/search/search.model.js

@@ -0,0 +1,204 @@
+import { NodeType, TermTermType, nestedSearchableKeys } from '@hestia-earth/schema';
+export const searchableTypes = [
+    NodeType.Cycle,
+    NodeType.Source
+];
+export const serializeSearchFilters = (filters) => Object.keys(filters || {})
+    .filter(key => filters[key].length)
+    .map(key => `${key}=${filters[key].filter(Boolean).join('|')}`)
+    .join(';');
+export const deserializeSearchFilters = (filters) => (filters || '').split(';').reduce((prev, curr) => {
+    const [key, values] = curr.split('=');
+    prev[key] = (values || '').split('|').filter(Boolean);
+    return prev;
+}, {});
+export const matchType = (type) => Object.freeze({
+    match: { '@type': type }
+});
+export const matchTermType = (termType) => Object.freeze({
+    match: { termType }
+});
+export const matchRegex = (key, value) => Object.freeze({
+    regexp: { [key]: { value: value.toString() } }
+});
+export const matchQuery = (key, value, boost) => Object.freeze({
+    match: {
+        [key]: Object.assign({ query: value }, (boost ? { boost } : {}))
+    }
+});
+export const matchExactQuery = (key, value, boost) => matchQuery(`${key}.keyword`, value, boost);
+export const matchNameNormalized = (query, boost = 20) => Object.freeze({
+    match: { nameNormalized: { query, boost } }
+});
+export const numberGte = (key, value) => Object.freeze({
+    range: { [key]: { gte: value } }
+});
+export const multiMatchQuery = (query, fields, type = 'best_fields', boost, analyzer) => Object.freeze({
+    multi_match: Object.assign(Object.assign({ query,
+        fields,
+        type }, (boost ? { boost } : {})), (analyzer ? { analyzer } : {}))
+});
+export const matchPhraseQuery = (query, boost, ...fields) => fields.length ? multiMatchQuery(query, fields, 'phrase', boost) : matchExactQuery('name', query, boost);
+export const matchPhrasePrefixQuery = (query, boost = 2, ...fields) => fields.length ?
+    multiMatchQuery(query, fields, 'phrase_prefix', boost) :
+    Object.freeze({
+        match_phrase_prefix: {
+            nameSearchAsYouType: {
+                query,
+                boost
+            }
+        }
+    });
+export const matchBoolPrefixQuery = (query, boost = 1, ...fields) => fields.length ?
+    multiMatchQuery(query, fields, 'bool_prefix', boost) :
+    Object.freeze({
+        match_bool_prefix: {
+            name: {
+                query,
+                boost
+            }
+        }
+    });
+export const wildcardQuery = (query, boost = 3, ...fields) => Object.freeze({
+    simple_query_string: {
+        query: `*${query}*`,
+        fields,
+        analyze_wildcard: true,
+        boost
+    }
+});
+const matchCountryLevel = { match: { gadmLevel: 0 } };
+export const matchGlobalRegion = { regexp: { '@id': 'region-*' } };
+export const matchCountry = Object.freeze({
+    bool: {
+        should: [
+            matchCountryLevel,
+            matchGlobalRegion
+        ],
+        minimum_should_match: 1
+    }
+});
+export const countriesQuery = Object.freeze({
+    bool: {
+        must: [
+            matchType(NodeType.Term),
+            matchTermType(TermTermType.region),
+            matchCountryLevel
+        ]
+    }
+});
+export const allCountriesQuery = Object.freeze({
+    bool: Object.assign({ must: [
+            matchType(NodeType.Term),
+            matchTermType(TermTermType.region)
+        ] }, matchCountry.bool)
+});
+export const matchRegion = numberGte('gadmLevel', 1);
+export const regionsQuery = Object.freeze({
+    bool: {
+        must: [
+            matchType(NodeType.Term),
+            matchTermType(TermTermType.region),
+            matchRegion
+        ]
+    }
+});
+export const worldRegion = Object.freeze({
+    '@id': 'region-world',
+    name: 'World'
+});
+export const cropsQuery = Object.freeze({
+    bool: {
+        must: [
+            matchType(NodeType.Term),
+            matchTermType(TermTermType.crop)
+        ]
+    }
+});
+export const matchAggregatedQuery = matchQuery('aggregated', true);
+const isNestedKey = (key) => nestedSearchableKeys.includes(key.split('.')[0]);
+export const matchNestedKey = (key, query) => isNestedKey(key) ? {
+    nested: { path: key.split('.')[0], query }
+} : query;
+/**
+ * List of fields to return in the search results.
+ */
+export const searchResultsFields = Object.freeze({
+    [NodeType.Cycle]: [
+        'description', 'dataDescription', 'endDate',
+        'emissionsCount', 'inputsCount', 'productsCount',
+        'site.location', 'site.country.name', 'site.region.name'
+    ],
+    [NodeType.Source]: ['bibliography.title', 'bibliography.documentDOI'],
+    [NodeType.ImpactAssessment]: ['emissionsResourceUseCount', 'impactsCount', 'country.name']
+});
+/**
+ * List of fields to search in.
+ */
+const searchFields = Object.freeze({
+    [NodeType.Cycle]: ['name', 'description', 'dataDescription'],
+    [NodeType.Source]: ['name', 'bibliography.title'],
+    [NodeType.ImpactAssessment]: ['name', 'product.name', 'country.name']
+});
+const searchFieldsNested = Object.freeze({
+    [NodeType.Cycle]: [
+        'inputs.term.name',
+        'emissions.term.name',
+        'practices.term.name'
+    ],
+    [NodeType.Source]: [],
+    [NodeType.ImpactAssessment]: [
+        'emissionsResourceUse.term.name',
+        'impacts.term.name'
+    ]
+});
+/**
+ * Specific strict queries per type.
+ */
+const searchQueries = {
+    [NodeType.Cycle]: { must: [], must_not: [matchAggregatedQuery] },
+    [NodeType.Source]: { must: [], must_not: [matchAggregatedQuery] }
+};
+const searchFiltersKeys = {
+    [NodeType.Cycle]: key => key,
+    [NodeType.Source]: key => key
+};
+/* eslint-disable complexity */
+export const searchQuery = (type, query, filters, aggregated) => {
+    const boolQuery = (Object.assign(Object.assign({ must: [
+            matchType(type),
+            aggregated ? matchAggregatedQuery : null
+        ].filter(Boolean) }, (query ? {
+        should: [
+            matchPhraseQuery(query, 100, ...searchFields[type]),
+            matchPhrasePrefixQuery(query, 20, ...searchFields[type]),
+            matchBoolPrefixQuery(query, 10, ...searchFields[type]),
+            ...searchFieldsNested[type].map(field => matchNestedKey(field, matchBoolPrefixQuery(query, 1, field)))
+        ],
+        minimum_should_match: 1
+    } : {})), { must_not: [
+            aggregated ? null : matchAggregatedQuery
+        ].filter(Boolean) }));
+    const keys = Object.keys(filters || {}).filter(key => filters[key].length);
+    return {
+        bool: keys.length ? {
+            must: keys.map(key => {
+                const filterKey = searchFiltersKeys[type](key);
+                return {
+                    bool: {
+                        should: filters[key]
+                            .map(value => matchNestedKey(filterKey, matchExactQuery(filterKey, value)))
+                            .map(must => {
+                            const localQuery = JSON.parse(JSON.stringify(boolQuery));
+                            localQuery.must.push(must);
+                            return { bool: localQuery };
+                        }),
+                        minimum_should_match: 1
+                    }
+                };
+            })
+        } : boolQuery
+    };
+};
+/* eslint-enable complexity */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.model.js","sourceRoot":"","sources":["../../../src/search/search.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { NodeType, TermTermType, nestedSearchableKeys } from '@hestia-earth/schema';\n\nexport type searchableType = NodeType.Cycle | NodeType.Source;\n\nexport const searchableTypes: searchableType[] = [\n  NodeType.Cycle,\n  NodeType.Source\n];\n\ntype multiMatchType = 'best_fields' | 'most_fields' | 'cross_fields' | 'phrase' | 'phrase_prefix' | 'bool_prefix';\ntype multiMatchAnalyzer = 'standard';\n\nexport interface ISearchFilters {\n  [key: string]: (string | number)[];\n}\n\nexport const serializeSearchFilters = (filters: ISearchFilters) =>\n  Object.keys(filters || {})\n    .filter(key => filters[key].length)\n    .map(key => `${key}=${filters[key].filter(Boolean).join('|')}`)\n    .join(';');\n\nexport const deserializeSearchFilters = (filters: string): ISearchFilters =>\n  (filters || '').split(';').reduce((prev: any, curr) => {\n    const [key, values] = curr.split('=');\n    prev[key] = (values || '').split('|').filter(Boolean);\n    return prev;\n  }, {});\n\nexport const matchType = (type: NodeType | string) => Object.freeze({\n  match: { '@type': type }\n});\n\nexport const matchTermType = (termType: TermTermType | string) => Object.freeze({\n  match: { termType }\n});\n\nexport const matchRegex = (key: string, value: string | RegExp) => Object.freeze({\n  regexp: { [key]: { value: value.toString() } }\n});\n\nexport const matchQuery = (key: string, value: any, boost?: number) => Object.freeze({\n  match: {\n    [key]: {\n      query: value,\n      ...(boost ? { boost } : {})\n    }\n  }\n});\n\nexport const matchExactQuery = (key: string, value: any, boost?: number) => matchQuery(`${key}.keyword`, value, boost);\n\nexport const matchNameNormalized = (query: string, boost = 20) => Object.freeze({\n  match: { nameNormalized: { query, boost } }\n});\n\nexport const numberGte = (key: string, value: number) => Object.freeze({\n  range: { [key]: { gte: value } }\n});\n\nexport const multiMatchQuery = (\n  query: string, fields: string[], type: multiMatchType = 'best_fields', boost?: number, analyzer?: multiMatchAnalyzer\n) => Object.freeze({\n  multi_match: {\n    query,\n    fields,\n    type,\n    ...(boost ? { boost } : {}),\n    ...(analyzer ? { analyzer } : {})\n  }\n});\n\nexport const matchPhraseQuery = (query: string, boost?: number, ...fields: string[]) =>\n  fields.length ? multiMatchQuery(query, fields, 'phrase', boost) : matchExactQuery('name', query, boost);\n\nexport const matchPhrasePrefixQuery = (query: string, boost = 2, ...fields: string[]) =>\n  fields.length ?\n    multiMatchQuery(query, fields, 'phrase_prefix', boost) :\n    Object.freeze({\n      match_phrase_prefix: {\n        nameSearchAsYouType: {\n          query,\n          boost\n        }\n      }\n    });\n\nexport const matchBoolPrefixQuery = (query: string, boost = 1, ...fields: string[]) =>\n  fields.length ?\n    multiMatchQuery(query, fields, 'bool_prefix', boost) :\n    Object.freeze({\n      match_bool_prefix: {\n        name: {\n          query,\n          boost\n        }\n      }\n    });\n\nexport const wildcardQuery = (query: string, boost = 3, ...fields: string[]) => Object.freeze({\n  simple_query_string: {\n    query: `*${query}*`,\n    fields,\n    analyze_wildcard: true,\n    boost\n  }\n});\n\nconst matchCountryLevel = { match: { gadmLevel: 0 } };\n\nexport const matchGlobalRegion = { regexp: { '@id': 'region-*' } };\n\nexport const matchCountry = Object.freeze({\n  bool: {\n    should: [\n      matchCountryLevel,\n      matchGlobalRegion\n    ],\n    minimum_should_match: 1\n  }\n});\n\nexport const countriesQuery = Object.freeze({\n  bool: {\n    must: [\n      matchType(NodeType.Term),\n      matchTermType(TermTermType.region),\n      matchCountryLevel\n    ]\n  }\n});\n\nexport const allCountriesQuery = Object.freeze({\n  bool: {\n    must: [\n      matchType(NodeType.Term),\n      matchTermType(TermTermType.region)\n    ],\n    ...matchCountry.bool\n  }\n});\n\nexport const matchRegion = numberGte('gadmLevel', 1);\n\nexport const regionsQuery = Object.freeze({\n  bool: {\n    must: [\n      matchType(NodeType.Term),\n      matchTermType(TermTermType.region),\n      matchRegion\n    ]\n  }\n});\n\nexport const worldRegion = Object.freeze({\n  '@id': 'region-world',\n  name: 'World'\n});\n\nexport const cropsQuery = Object.freeze({\n  bool: {\n    must: [\n      matchType(NodeType.Term),\n      matchTermType(TermTermType.crop)\n    ]\n  }\n});\n\nexport const matchAggregatedQuery = matchQuery('aggregated', true);\n\nconst isNestedKey = (key: string) => nestedSearchableKeys.includes(key.split('.')[0]);\n\nexport const matchNestedKey = (key: string, query: any) =>\n  isNestedKey(key) ? {\n    nested: { path: key.split('.')[0], query }\n  } : query;\n\n/**\n * List of fields to return in the search results.\n */\nexport const searchResultsFields: {\n  [type in searchableType]: string[];\n} = Object.freeze({\n  [NodeType.Cycle]: [\n    'description', 'dataDescription', 'endDate',\n    'emissionsCount', 'inputsCount', 'productsCount',\n    'site.location', 'site.country.name', 'site.region.name'\n  ],\n  [NodeType.Source]: ['bibliography.title', 'bibliography.documentDOI'],\n  [NodeType.ImpactAssessment]: ['emissionsResourceUseCount', 'impactsCount', 'country.name']\n});\n\n/**\n * List of fields to search in.\n */\nconst searchFields: {\n  [type in searchableType]: string[];\n} = Object.freeze({\n  [NodeType.Cycle]: ['name', 'description', 'dataDescription'],\n  [NodeType.Source]: ['name', 'bibliography.title'],\n  [NodeType.ImpactAssessment]: ['name', 'product.name', 'country.name']\n});\n\nconst searchFieldsNested: {\n  [type in searchableType]: string[];\n} = Object.freeze({\n  [NodeType.Cycle]: [\n    'inputs.term.name',\n    'emissions.term.name',\n    'practices.term.name'\n  ],\n  [NodeType.Source]: [],\n  [NodeType.ImpactAssessment]: [\n    'emissionsResourceUse.term.name',\n    'impacts.term.name'\n  ]\n});\n\n/**\n * Specific strict queries per type.\n */\nconst searchQueries: {\n  [type in searchableType]: { must: any[]; must_not: any[] };\n} = {\n  [NodeType.Cycle]: { must: [], must_not: [matchAggregatedQuery] },\n  [NodeType.Source]: { must: [], must_not: [matchAggregatedQuery] }\n};\n\nconst searchFiltersKeys: {\n  [type in searchableType]: (key: string) => string;\n} = {\n  [NodeType.Cycle]: key => key,\n  [NodeType.Source]: key => key\n};\n\n/* eslint-disable complexity */\nexport const searchQuery = (type: searchableType, query?: string, filters?: ISearchFilters, aggregated?: boolean) => {\n  const boolQuery: any = ({\n    must: [\n      matchType(type),\n      aggregated ? matchAggregatedQuery : null\n    ].filter(Boolean),\n    ...(query ? {\n      should: [\n        matchPhraseQuery(query, 100, ...searchFields[type]), // make sure exact matches come first\n        matchPhrasePrefixQuery(query, 20, ...searchFields[type]),\n        matchBoolPrefixQuery(query, 10, ...searchFields[type]),\n        ...searchFieldsNested[type].map(field => matchNestedKey(field, matchBoolPrefixQuery(query, 1, field)))\n      ],\n      minimum_should_match: 1\n    } : {}),\n    must_not: [\n      aggregated ? null : matchAggregatedQuery\n    ].filter(Boolean)\n  });\n  const keys = Object.keys(filters || {}).filter(key => filters![key].length);\n  return {\n    bool: keys.length ? {\n      must: keys.map(key => {\n        const filterKey = searchFiltersKeys[type](key);\n        return {\n          bool: {\n            should: filters![key]\n              .map(value => matchNestedKey(filterKey, matchExactQuery(filterKey, value)))\n              .map(must => {\n                const localQuery = JSON.parse(JSON.stringify(boolQuery));\n                localQuery.must.push(must);\n                return { bool: localQuery };\n              }),\n            minimum_should_match: 1\n          }\n        };\n      })\n    } : boolQuery\n  };\n};\n/* eslint-enable complexity */\n"]}

package/esm2015/search/search.module.js

@@ -0,0 +1,13 @@
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export { HeSearchService } from './search.service';
+export class HeSearchModule {
+}
+HeSearchModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+HeSearchModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchModule });
+HeSearchModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZWFyY2gvc2VhcmNoLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUV6QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFHbkQsTUFBTSxPQUFPLGNBQWM7OzRHQUFkLGNBQWM7NkdBQWQsY0FBYzs2R0FBZCxjQUFjOzRGQUFkLGNBQWM7a0JBRDFCLFFBQVE7bUJBQUMsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCB7IEhlU2VhcmNoU2VydmljZSB9IGZyb20gJy4vc2VhcmNoLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe30pXG5leHBvcnQgY2xhc3MgSGVTZWFyY2hNb2R1bGUgeyB9XG4iXX0=

package/esm2015/search/search.service.js

@@ -0,0 +1,99 @@
+import { __rest } from "tslib";
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { NodeType, SchemaType } from '@hestia-earth/schema';
+import { matchType, matchPhraseQuery, matchPhrasePrefixQuery, matchQuery, searchableTypes, matchBoolPrefixQuery } from './search.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../common/common.service";
+const emptySearchResult = () => ({
+    time: 0,
+    count: 0,
+    results: []
+});
+export const MAX_RESULTS = 10000;
+export const suggestMatchQuery = (query) => [
+    matchPhraseQuery(query, 10),
+    matchQuery('nameNormalized', query, 8),
+    matchPhrasePrefixQuery(query, 2)
+];
+export const suggestQuery = (query, type, extraQueries = []) => ({
+    bool: {
+        must: extraQueries,
+        should: (type ? [type] : searchableTypes).map(v => ({
+            bool: {
+                must: [matchType(v)],
+                should: suggestMatchQuery(query),
+                minimum_should_match: 1
+            }
+        })),
+        minimum_should_match: 1
+    }
+});
+const suggestSourceQuery = (query, fields) => ({
+    bool: {
+        must: [matchType(NodeType.Source)],
+        should: [
+            matchPhraseQuery(query, 100, ...fields),
+            matchPhrasePrefixQuery(query, 20, ...fields),
+            matchBoolPrefixQuery(query, 10, ...fields)
+        ],
+        minimum_should_match: 1
+    }
+});
+export class HeSearchService {
+    constructor(http, commonService) {
+        this.http = http;
+        this.commonService = commonService;
+    }
+    search(params) {
+        return this.http.post(`${this.commonService.apiBaseUrl}/search`, params)
+            .pipe(catchError(() => of(emptySearchResult())))
+            .toPromise();
+    }
+    count(params = {}) {
+        return this.http.post(`${this.commonService.apiBaseUrl}/count`, params).toPromise().catch(() => 0);
+    }
+    get$(type, id) {
+        return this.http.post(`${this.commonService.apiBaseUrl}/search`, {
+            limit: 1,
+            query: {
+                bool: {
+                    must: [{ match: { '@type': type } }, { match: { '@id': id } }]
+                }
+            }
+        })
+            .pipe(catchError(() => of(emptySearchResult())), map(({ results }) => results[0] || null));
+    }
+    get(type, id) {
+        return this.get$(type, id).toPromise();
+    }
+    suggest(term, type, extraQueries = [], fullQuery, limit = 10, includes = []) {
+        const query = fullQuery || suggestQuery(term, type, extraQueries);
+        return this.http.post(`${this.commonService.apiBaseUrl}/search`, {
+            limit,
+            fields: ['name', '@id', type ? '' : '@type', 'termType', 'aggregated', ...includes].filter(val => !!val),
+            query
+        })
+            .pipe(catchError(() => of(emptySearchResult())), map(({ results }) => results.map((_a) => {
+            var { _score } = _a, res = __rest(_a, ["_score"]);
+            return res;
+        })));
+    }
+    suggestSource(term, limit = 5, fields = ['bibliography.title'], includes = ['bibliography.title']) {
+        return this.suggest(term, NodeType.Source, [], suggestSourceQuery(term, fields), limit, includes)
+            .pipe(map((sources) => sources.map(source => (Object.assign(Object.assign({}, source), { bibliography: Object.assign({ 
+                // needed to create a nested property
+                type: SchemaType.Bibliography }, source.bibliography) })))));
+    }
+}
+HeSearchService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchService, deps: [{ token: i1.HttpClient }, { token: i2.HeCommonService }], target: i0.ɵɵFactoryTarget.Injectable });
+HeSearchService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HeSearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.HeCommonService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../src/search/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { of } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport {\n  JSONLD, NodeType, ICycleJSONLD, ISourceJSONLD, ITermJSONLD, Source, SchemaType, IImpactAssessmentJSONLD\n} from '@hestia-earth/schema';\n\nimport { HeCommonService } from '../common/common.service';\nimport {\n  matchType, matchPhraseQuery, matchPhrasePrefixQuery, matchQuery, searchableType, searchableTypes, matchBoolPrefixQuery\n} from './search.model';\n\nexport type searchResult = ICycleJSONLD | ISourceJSONLD | IImpactAssessmentJSONLD | ITermJSONLD;\n\nexport type sortOrders = 'asc' | 'desc';\n\ninterface ISearchParamSort {\n  [key: string]: sortOrders;\n}\n\ninterface ISearchScript {\n  _script: {\n    type?: string;\n    order?: sortOrders;\n    script: string;\n  };\n}\n\nexport interface ISearchParams {\n  limit?: number;\n  offset?: number;\n  fields?: string[];\n  sort?: ISearchParamSort[] | ISearchScript;\n  query?: any;\n}\n\nexport interface ISearchResultExtended {\n  _score: number;\n  createdAt: string;\n  // geospacial search\n  location?: {\n    lat: number;\n    lon: number;\n  };\n  // used in search\n  properties?: string[];\n  expanded?: boolean;\n  extended?: boolean;\n  pinned?: boolean;\n  loading?: boolean;\n  selected?: boolean;\n  // count for lists\n  inputsCount?: number;\n  emissionsCount?: number;\n  productsCount?: number;\n}\n\nexport interface ISearchResults<C extends JSONLD<T>, T extends NodeType = searchableType> {\n  /**\n   * Amount of time the query took\n   */\n  time: number;\n  /**\n   * Numnber of results\n   */\n  count: number;\n  results: (C & ISearchResultExtended)[];\n}\n\nconst emptySearchResult = <C extends JSONLD<T>, T extends NodeType>() => ({\n  time: 0,\n  count: 0,\n  results: []\n} as ISearchResults<C, T>);\n\nexport const MAX_RESULTS = 10000;\n\nexport const suggestMatchQuery = (query: string) => [\n  matchPhraseQuery(query, 10),\n  matchQuery('nameNormalized', query, 8),\n  matchPhrasePrefixQuery(query, 2)\n];\n\nexport const suggestQuery = <T extends NodeType = searchableType>(\n  query: string, type?: T, extraQueries: any[] = []\n) => ({\n  bool: {\n    must: extraQueries,\n    should: (type ? [type] : searchableTypes).map(v => ({\n      bool: {\n        must: [matchType(v)],\n        should: suggestMatchQuery(query),\n        minimum_should_match: 1\n      }\n    })),\n    minimum_should_match: 1\n  }\n});\n\nconst suggestSourceQuery = (query: string, fields: string[]) => ({\n  bool: {\n    must: [matchType(NodeType.Source)],\n    should: [\n      matchPhraseQuery(query, 100, ...fields),\n      matchPhrasePrefixQuery(query, 20, ...fields),\n      matchBoolPrefixQuery(query, 10, ...fields)\n    ],\n    minimum_should_match: 1\n  }\n});\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class HeSearchService {\n  constructor(\n    private http: HttpClient,\n    private commonService: HeCommonService\n  ) { }\n\n  public search<C extends JSONLD<T>, T extends NodeType = searchableType>(params: ISearchParams) {\n    return this.http.post<ISearchResults<C, T>>(`${this.commonService.apiBaseUrl}/search`, params)\n      .pipe(\n        catchError(() => of(emptySearchResult<C, T>()))\n      )\n      .toPromise();\n  }\n\n  public count(params = {}) {\n    return this.http.post<number>(`${this.commonService.apiBaseUrl}/count`, params).toPromise().catch(() => 0);\n  }\n\n  public get$<C extends JSONLD<T>, T extends NodeType>(type: T, id: string) {\n    return this.http.post<ISearchResults<C, T>>(`${this.commonService.apiBaseUrl}/search`, {\n      limit: 1,\n      query: {\n        bool: {\n          must: [{ match: { '@type': type } }, { match: { '@id': id } }]\n        }\n      }\n    })\n      .pipe(\n        catchError(() => of(emptySearchResult<C, T>())),\n        map(({ results }) => results[0] || null)\n      );\n  }\n\n  public get<C extends JSONLD<T>, T extends NodeType>(type: T, id: string) {\n    return this.get$<C, T>(type, id).toPromise();\n  }\n\n  public suggest<C extends JSONLD<T>, T extends NodeType = searchableType>(\n    term: string, type?: T, extraQueries: any[] = [], fullQuery?: any, limit = 10, includes: string[] = []\n  ) {\n    const query = fullQuery || suggestQuery(term, type, extraQueries);\n    return this.http.post<ISearchResults<C, T>>(`${this.commonService.apiBaseUrl}/search`, {\n      limit,\n      fields: ['name', '@id', type ? '' : '@type', 'termType', 'aggregated', ...includes].filter(val => !!val),\n      query\n    })\n      .pipe(\n        catchError(() => of(emptySearchResult<C, T>())),\n        map(({ results }) => results.map(({ _score, ...res }) => res))\n      );\n  }\n\n  public suggestSource(term: string, limit = 5, fields = ['bibliography.title'], includes = ['bibliography.title']) {\n    return this.suggest(term, NodeType.Source, [], suggestSourceQuery(term, fields), limit, includes)\n      .pipe(\n        map((sources: Partial<Source>[]) => sources.map(source => ({\n          ...source,\n          bibliography: {\n            // needed to create a nested property\n            type: SchemaType.Bibliography,\n            ...source.bibliography\n          }\n        } as Partial<Source>)))\n      );\n  }\n}\n"]}