geonetwork-ui 2.1.0-initial

package/esm2022/libs/feature/search/src/lib/facets/facets.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { UiFacetsModule } from '../../../../../../libs/ui/search/src';
+import { TranslateModule } from '@ngx-translate/core';
+import { FacetsContainerComponent } from './facets-container/facets-container.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class FacetsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FacetsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: FacetsModule, declarations: [FacetsContainerComponent], imports: [CommonModule, i1.TranslateModule, UiFacetsModule], exports: [FacetsContainerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FacetsModule, imports: [CommonModule, TranslateModule.forChild(), UiFacetsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FacetsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FacetsContainerComponent],
+                    imports: [CommonModule, TranslateModule.forChild(), UiFacetsModule],
+                    exports: [FacetsContainerComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjZXRzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZmVhdHVyZS9zZWFyY2gvc3JjL2xpYi9mYWNldHMvZmFjZXRzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDOUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUN4QyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0NBQXNDLENBQUE7QUFDckUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFBO0FBQ3JELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtDQUErQyxDQUFBOzs7QUFPeEYsTUFBTSxPQUFPLFlBQVk7OEdBQVosWUFBWTsrR0FBWixZQUFZLGlCQUpSLHdCQUF3QixhQUM3QixZQUFZLHNCQUE4QixjQUFjLGFBQ3hELHdCQUF3QjsrR0FFdkIsWUFBWSxZQUhiLFlBQVksRUFBRSxlQUFlLENBQUMsUUFBUSxFQUFFLEVBQUUsY0FBYzs7MkZBR3ZELFlBQVk7a0JBTHhCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsd0JBQXdCLENBQUM7b0JBQ3hDLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxlQUFlLENBQUMsUUFBUSxFQUFFLEVBQUUsY0FBYyxDQUFDO29CQUNuRSxPQUFPLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQztpQkFDcEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBVaUZhY2V0c01vZHVsZSB9IGZyb20gJy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdWkvc2VhcmNoL3NyYydcbmltcG9ydCB7IFRyYW5zbGF0ZU1vZHVsZSB9IGZyb20gJ0BuZ3gtdHJhbnNsYXRlL2NvcmUnXG5pbXBvcnQgeyBGYWNldHNDb250YWluZXJDb21wb25lbnQgfSBmcm9tICcuL2ZhY2V0cy1jb250YWluZXIvZmFjZXRzLWNvbnRhaW5lci5jb21wb25lbnQnXG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW0ZhY2V0c0NvbnRhaW5lckNvbXBvbmVudF0sXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFRyYW5zbGF0ZU1vZHVsZS5mb3JDaGlsZCgpLCBVaUZhY2V0c01vZHVsZV0sXG4gIGV4cG9ydHM6IFtGYWNldHNDb250YWluZXJDb21wb25lbnRdLFxufSlcbmV4cG9ydCBjbGFzcyBGYWNldHNNb2R1bGUge31cbiJdfQ==

package/esm2022/libs/feature/search/src/lib/facets/facets.service.mjs

@@ -0,0 +1,232 @@
+import { Injectable } from '@angular/core';
+import { LogService, parse, PARSE_DELIMITER } from '../../../../../../libs/util/shared/src';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../libs/util/shared/src";
+export class FacetsService {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    createFacetModel(requestAggregations, responseAggregations, isNested, path = []) {
+        const listModel = [];
+        if (requestAggregations !== undefined) {
+            for (const key in requestAggregations) {
+                if (key in responseAggregations) {
+                    const requestAgg = requestAggregations[key];
+                    const responseAgg = responseAggregations[key];
+                    let blockModel = {
+                        key,
+                        items: [],
+                        path: [...path, responseAgg.meta?.field || key],
+                        meta: responseAgg.meta,
+                    };
+                    if ('terms' in requestAgg) {
+                        blockModel = {
+                            ...blockModel,
+                            type: 'terms',
+                            size: requestAgg['terms'].size,
+                            more: responseAgg.sum_other_doc_count > 0,
+                            includeFilter: requestAgg.terms.include !== undefined,
+                            excludeFilter: requestAgg.terms.exclude !== undefined,
+                        };
+                        responseAgg.buckets.forEach((bucket) => {
+                            if (bucket.key) {
+                                const value = bucket.key_as_string || bucket.key;
+                                const itemPath = [...blockModel.path, String(value)];
+                                const itemModel = {
+                                    value,
+                                    meta: bucket.meta,
+                                    count: bucket.doc_count,
+                                    path: itemPath,
+                                };
+                                blockModel.items.push(itemModel);
+                            }
+                        });
+                    }
+                    else if ('histogram' in requestAgg) {
+                        blockModel = {
+                            ...blockModel,
+                            type: 'histogram',
+                            size: requestAgg['histogram'].size,
+                        };
+                        if (requestAgg['histogram'].keyed) {
+                            const entries = Object.entries(responseAgg.buckets);
+                            for (let p = 0; p < entries.length; p++) {
+                                const entry = entries[p];
+                                const nextEntry = entries[p + 1];
+                                const lowerBound = entry[1].key;
+                                const onlyOneBucket = entries.length === 1;
+                                const upperBound = onlyOneBucket
+                                    ? lowerBound + Number(requestAgg['histogram'].interval)
+                                    : nextEntry
+                                        ? nextEntry[1].key
+                                        : '*';
+                                const value = lowerBound + '-' + upperBound;
+                                const itemPath = [...blockModel.path, lowerBound + ''];
+                                const itemModel = {
+                                    value,
+                                    meta: entry[1].meta,
+                                    count: entry[1].doc_count,
+                                    query_string: `+${requestAgg.histogram.field}:[${lowerBound} TO ${upperBound}}`,
+                                    path: itemPath,
+                                };
+                                blockModel.items.push(itemModel);
+                            }
+                        }
+                        else {
+                            this.logger.warn('Facet configuration error. Histogram are only supported with keyed mode.' +
+                                'eg. creationYearForResource: {histogram: { ' +
+                                'field: "creationYearForResource",' +
+                                'interval: 5,' +
+                                'keyed: true,' +
+                                'min_doc_count: 1}}');
+                        }
+                    }
+                    else if ('filters' in requestAgg) {
+                        const type = 'filters';
+                        blockModel = {
+                            ...blockModel,
+                            type,
+                            size: requestAgg[type].size,
+                        };
+                        Object.entries(responseAgg.buckets).forEach((entry) => {
+                            const itemValue = entry[0];
+                            const bucket = entry[1];
+                            const itemPath = [...blockModel.path, itemValue];
+                            const itemModel = {
+                                value: itemValue,
+                                meta: bucket.meta,
+                                count: bucket.doc_count,
+                                path: itemPath,
+                                query_string: requestAgg.filters.filters[itemValue].query_string.query,
+                            };
+                            blockModel.items.push(itemModel);
+                        });
+                    }
+                    else {
+                        this.logger.warn('Unsupported aggregation config.', requestAgg);
+                    }
+                    listModel.push(blockModel);
+                }
+            }
+        }
+        return listModel;
+    }
+    /**
+     * Compute the path value of a facet item. The path value is the last
+     * element of the path array.
+     * If the item is not selected, returns `null`
+     * For 'terms' facet, it is a boolean, true when selected, false when
+     * inverted.
+     * For 'filters' and 'histogram', it is a lucene expression
+     *
+     * @param block model
+     * @param item model
+     */
+    computeItemPathValue(block, item) {
+        const { selected, inverted } = item;
+        const { type } = block;
+        let value = !inverted;
+        if (selected) {
+            if (type === 'filters' || type === 'histogram') {
+                value = item.query_string;
+                if (inverted) {
+                    value = `-(${value})`;
+                }
+            }
+        }
+        else {
+            value = null;
+        }
+        return value;
+    }
+    /**
+     * Create a new filter object that will be passed to the state.
+     * It update recursively the object depending on the path structure.
+     *
+     * @param filters previous state
+     * @param path of the updated item
+     * @param value of the updated item
+     */
+    computeNewFiltersFromState(filters, path, value) {
+        const clone = JSON.parse(JSON.stringify(filters));
+        const getter = parse(path.join(PARSE_DELIMITER));
+        if (value === null) {
+            this.removePathFromFilters_(clone, path);
+        }
+        else {
+            const setter = getter.assign;
+            setter(clone, value);
+        }
+        return clone;
+    }
+    /**
+     * Remove a filter in the state object, depending on the given path, which
+     * could be deep in the parameter tree.
+     * FIXME: revisit because filters cannot be recursive anymore!!!
+     * @param filters state
+     * @param path to remove from state
+     */
+    removePathFromFilters_(filters, path) {
+        const head = path[0];
+        const tail = path.slice(1);
+        if (typeof filters !== 'object')
+            return;
+        for (const prop of Object.keys(filters)) {
+            if (prop in filters) {
+                if (head.toString() === prop && tail.length === 0) {
+                    delete filters[prop];
+                }
+                else {
+                    if ('object' === typeof filters[prop]) {
+                        this.removePathFromFilters_(filters[prop], tail);
+                        if (0 === Object.keys(filters[prop]).length) {
+                            delete filters[prop];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Compute filters recursive paths enabled in the state current
+     * search
+     * e.g [["tag.default", "land use"]]
+     *
+     * @param filters Search filters from state
+     */
+    findSelectedPaths(filters) {
+        const discoveredObjects = []; // For checking for cyclic object
+        const path = [];
+        const results = [];
+        (function find(obj) {
+            for (const key of Object.keys(obj)) {
+                if (typeof obj[key] !== 'object') {
+                    // Found a selected path
+                    path.push(key);
+                    results.push(Array.from(path));
+                    path.pop();
+                }
+                const o = obj[key]; // The next object to be searched
+                if (o && typeof o === 'object') {
+                    if (!discoveredObjects.find((discovered) => discovered === o)) {
+                        // check for cyclic link
+                        path.push(key);
+                        discoveredObjects.push(o);
+                        find(o);
+                        path.pop();
+                    }
+                }
+            }
+        })(filters);
+        return results;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FacetsService, deps: [{ token: i1.LogService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FacetsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FacetsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LogService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facets.service.js","sourceRoot":"","sources":["../../../../../../../../libs/feature/search/src/lib/facets/facets.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { LogService, parse, PARSE_DELIMITER } from '../../../../../../libs/util/shared/src'\nimport { FacetPath, ModelBlock, ModelItem } from '../../../../../../libs/ui/search/src'\nimport { FieldFilter, FieldFilters } from '../../../../../../libs/common/domain/src/lib/search'\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class FacetsService {\n  constructor(private logger: LogService) {}\n\n  createFacetModel(\n    requestAggregations,\n    responseAggregations,\n    isNested: boolean,\n    path: string[] = []\n  ): ModelBlock[] {\n    const listModel = []\n    if (requestAggregations !== undefined) {\n      interface AggEntry {\n        key: string\n        meta: Record<string, unknown>\n        doc_count: number\n      }\n\n      for (const key in requestAggregations) {\n        if (key in responseAggregations) {\n          const requestAgg = requestAggregations[key]\n          const responseAgg = responseAggregations[key]\n\n          let blockModel: any = {\n            key,\n            items: [],\n            path: [...path, responseAgg.meta?.field || key],\n            meta: responseAgg.meta,\n          }\n          if ('terms' in requestAgg) {\n            blockModel = {\n              ...blockModel,\n              type: 'terms',\n              size: requestAgg['terms'].size,\n              more: responseAgg.sum_other_doc_count > 0,\n              includeFilter: requestAgg.terms.include !== undefined,\n              excludeFilter: requestAgg.terms.exclude !== undefined,\n            }\n\n            responseAgg.buckets.forEach((bucket) => {\n              if (bucket.key) {\n                const value = bucket.key_as_string || bucket.key\n                const itemPath = [...blockModel.path, String(value)]\n                const itemModel = {\n                  value,\n                  meta: bucket.meta,\n                  count: bucket.doc_count,\n                  path: itemPath,\n                }\n                blockModel.items.push(itemModel)\n              }\n            })\n          } else if ('histogram' in requestAgg) {\n            blockModel = {\n              ...blockModel,\n              type: 'histogram',\n              size: requestAgg['histogram'].size,\n            }\n\n            if (requestAgg['histogram'].keyed) {\n              const entries = Object.entries(responseAgg.buckets)\n              for (let p = 0; p < entries.length; p++) {\n                const entry: [string, AggEntry] = entries[p] as [\n                  string,\n                  AggEntry\n                ]\n                const nextEntry: [string, AggEntry] = entries[p + 1] as [\n                  string,\n                  AggEntry\n                ]\n                const lowerBound = entry[1].key\n                const onlyOneBucket = entries.length === 1\n                const upperBound = onlyOneBucket\n                  ? lowerBound + Number(requestAgg['histogram'].interval)\n                  : nextEntry\n                  ? nextEntry[1].key\n                  : '*'\n                const value = lowerBound + '-' + upperBound\n                const itemPath = [...blockModel.path, lowerBound + '']\n                const itemModel = {\n                  value,\n                  meta: entry[1].meta,\n                  count: entry[1].doc_count,\n                  query_string: `+${requestAgg.histogram.field}:[${lowerBound} TO ${upperBound}}`,\n                  path: itemPath,\n                }\n                blockModel.items.push(itemModel)\n              }\n            } else {\n              this.logger.warn(\n                'Facet configuration error. Histogram are only supported with keyed mode.' +\n                  'eg. creationYearForResource: {histogram: { ' +\n                  'field: \"creationYearForResource\",' +\n                  'interval: 5,' +\n                  'keyed: true,' +\n                  'min_doc_count: 1}}'\n              )\n            }\n          } else if ('filters' in requestAgg) {\n            const type = 'filters'\n            blockModel = {\n              ...blockModel,\n              type,\n              size: requestAgg[type].size,\n            }\n\n            Object.entries(responseAgg.buckets).forEach((entry) => {\n              const itemValue = entry[0]\n              const bucket = entry[1] as AggEntry\n              const itemPath = [...blockModel.path, itemValue]\n              const itemModel = {\n                value: itemValue,\n                meta: bucket.meta,\n                count: bucket.doc_count,\n                path: itemPath,\n                query_string:\n                  requestAgg.filters.filters[itemValue].query_string.query,\n              }\n              blockModel.items.push(itemModel)\n            })\n          } else {\n            this.logger.warn('Unsupported aggregation config.', requestAgg)\n          }\n          listModel.push(blockModel)\n        }\n      }\n    }\n    return listModel\n  }\n\n  /**\n   * Compute the path value of a facet item. The path value is the last\n   * element of the path array.\n   * If the item is not selected, returns `null`\n   * For 'terms' facet, it is a boolean, true when selected, false when\n   * inverted.\n   * For 'filters' and 'histogram', it is a lucene expression\n   *\n   * @param block model\n   * @param item model\n   */\n  computeItemPathValue(block: ModelBlock, item: ModelItem) {\n    const { selected, inverted } = item\n    const { type } = block\n    let value: unknown = !inverted\n\n    if (selected) {\n      if (type === 'filters' || type === 'histogram') {\n        value = item.query_string\n        if (inverted) {\n          value = `-(${value})`\n        }\n      }\n    } else {\n      value = null\n    }\n    return value\n  }\n\n  /**\n   * Create a new filter object that will be passed to the state.\n   * It update recursively the object depending on the path structure.\n   *\n   * @param filters previous state\n   * @param path of the updated item\n   * @param value of the updated item\n   */\n  computeNewFiltersFromState(\n    filters: FieldFilters,\n    path: FacetPath,\n    value: unknown\n  ): FieldFilters {\n    const clone = JSON.parse(JSON.stringify(filters))\n    const getter = parse(path.join(PARSE_DELIMITER))\n    if (value === null) {\n      this.removePathFromFilters_(clone, path)\n    } else {\n      const setter = getter.assign\n      setter(clone, value)\n    }\n    return clone\n  }\n\n  /**\n   * Remove a filter in the state object, depending on the given path, which\n   * could be deep in the parameter tree.\n   * FIXME: revisit because filters cannot be recursive anymore!!!\n   * @param filters state\n   * @param path to remove from state\n   */\n  private removePathFromFilters_(\n    filters: FieldFilters | FieldFilter,\n    path: FacetPath\n  ) {\n    const head = path[0]\n    const tail = path.slice(1)\n    if (typeof filters !== 'object') return\n    for (const prop of Object.keys(filters)) {\n      if (prop in filters) {\n        if (head.toString() === prop && tail.length === 0) {\n          delete filters[prop]\n        } else {\n          if ('object' === typeof filters[prop]) {\n            this.removePathFromFilters_(filters[prop] as FieldFilter, tail)\n            if (0 === Object.keys(filters[prop]).length) {\n              delete filters[prop]\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Compute filters recursive paths enabled in the state current\n   * search\n   * e.g [[\"tag.default\", \"land use\"]]\n   *\n   * @param filters Search filters from state\n   */\n  findSelectedPaths(filters): string[][] {\n    const discoveredObjects = [] // For checking for cyclic object\n    const path = []\n    const results = []\n\n    ;(function find(obj) {\n      for (const key of Object.keys(obj)) {\n        if (typeof obj[key] !== 'object') {\n          // Found a selected path\n          path.push(key)\n          results.push(Array.from(path))\n          path.pop()\n        }\n        const o = obj[key] // The next object to be searched\n        if (o && typeof o === 'object') {\n          if (!discoveredObjects.find((discovered) => discovered === o)) {\n            // check for cyclic link\n            path.push(key)\n            discoveredObjects.push(o)\n            find(o)\n            path.pop()\n          }\n        }\n      }\n    })(filters)\n\n    return results\n  }\n}\n"]}

package/esm2022/libs/feature/search/src/lib/favorites/favorite-star/favorite-star.component.mjs

@@ -0,0 +1,104 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Input, ViewChild, } from '@angular/core';
+import { map, pairwise, withLatestFrom } from 'rxjs/operators';
+import tippy from 'tippy.js';
+import { TranslateService } from '@ngx-translate/core';
+import { StarToggleComponent } from '../../../../../../../libs/ui/inputs/src';
+import { AuthService, FavoritesService, } from '../../../../../../../libs/api/repository/src/lib/gn4';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../../libs/api/repository/src/lib/gn4";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@angular/common";
+import * as i4 from "../../../../../../ui/inputs/src/lib/star-toggle/star-toggle.component";
+export class FavoriteStarComponent {
+    set record(value) {
+        this.record_ = value;
+        this.favoriteCount =
+            'extras' in this.record_ && 'favoriteCount' in this.record_.extras
+                ? this.record_.extras.favoriteCount
+                : null;
+    }
+    get record() {
+        return this.record_;
+    }
+    get hasFavoriteCount() {
+        return this.favoriteCount !== null;
+    }
+    constructor(favoritesService, authService, changeDetector, translateService) {
+        this.favoritesService = favoritesService;
+        this.authService = authService;
+        this.changeDetector = changeDetector;
+        this.translateService = translateService;
+        this.isFavorite$ = this.favoritesService.myFavoritesUuid$.pipe(map((favorites) => favorites.indexOf(this.record.uniqueIdentifier) > -1));
+        this.isAnonymous$ = this.authService.isAnonymous$;
+        this.loading = false;
+        this.loginUrl = this.authService.loginUrl;
+        this.loginMessage$ = this.translateService.get('favorite.not.authenticated.tooltip', {
+            link: this.loginUrl,
+        });
+    }
+    ngAfterViewInit() {
+        this.subscription = this.isAnonymous$
+            .pipe(withLatestFrom(this.loginMessage$))
+            .subscribe(([anonymous, loginMessage]) => {
+            if (anonymous) {
+                tippy(this.starToggleRef.nativeElement, {
+                    appendTo: () => document.body,
+                    content: loginMessage,
+                    allowHTML: true,
+                    interactive: true,
+                    zIndex: 40,
+                    maxWidth: 250,
+                });
+            }
+        });
+        this.countSubscription = this.favoritesService.myFavoritesUuid$
+            .pipe(pairwise())
+            .subscribe(([oldFavs, newFavs]) => {
+            const editedFavs = (oldFavs.length < newFavs.length
+                ? newFavs.slice(-1)
+                : oldFavs.filter((fav) => !newFavs.includes(fav)))[0];
+            if (this.hasFavoriteCount &&
+                editedFavs === this.record.uniqueIdentifier) {
+                if (newFavs.includes(editedFavs)) {
+                    this.favoriteCount += 1;
+                }
+                else {
+                    this.favoriteCount += -1;
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+        this.countSubscription.unsubscribe();
+    }
+    toggleFavorite(isFavorite) {
+        this.loading = true;
+        (isFavorite
+            ? this.favoritesService.addToFavorites([this.record.uniqueIdentifier])
+            : this.favoritesService.removeFromFavorites([
+                this.record.uniqueIdentifier,
+            ])).subscribe({
+            complete: () => {
+                this.loading = false;
+                this.changeDetector.detectChanges();
+            },
+            error: () => {
+                this.loading = false;
+                this.changeDetector.detectChanges();
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FavoriteStarComponent, deps: [{ token: i1.FavoritesService }, { token: i1.AuthService }, { token: i0.ChangeDetectorRef }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: FavoriteStarComponent, selector: "gn-ui-favorite-star", inputs: { record: "record" }, viewQueries: [{ propertyName: "starToggleRef", first: true, predicate: StarToggleComponent, descendants: true, read: ElementRef }], ngImport: i0, template: "<div>\n  <span class=\"align-text-top mr-1.5 favorite-count\" *ngIf=\"hasFavoriteCount\">{{\n    favoriteCount\n  }}</span>\n  <gn-ui-star-toggle\n    [toggled]=\"isFavorite$ | async\"\n    (newValue)=\"toggleFavorite($event)\"\n    [disabled]=\"loading || (isAnonymous$ | async)\"\n  ></gn-ui-star-toggle>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.StarToggleComponent, selector: "gn-ui-star-toggle", inputs: ["toggled", "disabled"], outputs: ["newValue"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FavoriteStarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'gn-ui-favorite-star', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div>\n  <span class=\"align-text-top mr-1.5 favorite-count\" *ngIf=\"hasFavoriteCount\">{{\n    favoriteCount\n  }}</span>\n  <gn-ui-star-toggle\n    [toggled]=\"isFavorite$ | async\"\n    (newValue)=\"toggleFavorite($event)\"\n    [disabled]=\"loading || (isAnonymous$ | async)\"\n  ></gn-ui-star-toggle>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.FavoritesService }, { type: i1.AuthService }, { type: i0.ChangeDetectorRef }, { type: i2.TranslateService }]; }, propDecorators: { record: [{
+                type: Input
+            }], starToggleRef: [{
+                type: ViewChild,
+                args: [StarToggleComponent, { read: ElementRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"favorite-star.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/feature/search/src/lib/favorites/favorite-star/favorite-star.component.ts","../../../../../../../../../libs/feature/search/src/lib/favorites/favorite-star/favorite-star.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Input,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core'\nimport { map, pairwise, withLatestFrom } from 'rxjs/operators'\nimport tippy from 'tippy.js'\nimport { TranslateService } from '@ngx-translate/core'\nimport { StarToggleComponent } from '../../../../../../../libs/ui/inputs/src'\nimport { Observable, Subscription } from 'rxjs'\nimport { CatalogRecord } from '../../../../../../../libs/common/domain/src/lib/record'\nimport {\n  AuthService,\n  FavoritesService,\n} from '../../../../../../../libs/api/repository/src/lib/gn4'\n\n@Component({\n  selector: 'gn-ui-favorite-star',\n  templateUrl: './favorite-star.component.html',\n  styleUrls: ['./favorite-star.component.css'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FavoriteStarComponent implements AfterViewInit, OnDestroy {\n  @Input() set record(value) {\n    this.record_ = value\n    this.favoriteCount =\n      'extras' in this.record_ && 'favoriteCount' in this.record_.extras\n        ? (this.record_.extras.favoriteCount as number)\n        : null\n  }\n  get record() {\n    return this.record_\n  }\n  isFavorite$ = this.favoritesService.myFavoritesUuid$.pipe(\n    map((favorites) => favorites.indexOf(this.record.uniqueIdentifier) > -1)\n  )\n  isAnonymous$ = this.authService.isAnonymous$\n  record_: CatalogRecord\n  favoriteCount: number | null\n  loading = false\n  loginUrl = this.authService.loginUrl\n  loginMessage$: Observable<string> = this.translateService.get(\n    'favorite.not.authenticated.tooltip',\n    {\n      link: this.loginUrl,\n    }\n  )\n  @ViewChild(StarToggleComponent, { read: ElementRef })\n  starToggleRef: ElementRef\n  subscription: Subscription\n  countSubscription: Subscription\n\n  get hasFavoriteCount() {\n    return this.favoriteCount !== null\n  }\n\n  constructor(\n    private favoritesService: FavoritesService,\n    private authService: AuthService,\n    private changeDetector: ChangeDetectorRef,\n    private translateService: TranslateService\n  ) {}\n\n  ngAfterViewInit(): void {\n    this.subscription = this.isAnonymous$\n      .pipe(withLatestFrom(this.loginMessage$))\n      .subscribe(([anonymous, loginMessage]) => {\n        if (anonymous) {\n          tippy(this.starToggleRef.nativeElement, {\n            appendTo: () => document.body,\n            content: loginMessage,\n            allowHTML: true,\n            interactive: true,\n            zIndex: 40,\n            maxWidth: 250,\n          })\n        }\n      })\n    this.countSubscription = this.favoritesService.myFavoritesUuid$\n      .pipe(pairwise())\n      .subscribe(([oldFavs, newFavs]) => {\n        const editedFavs = (\n          oldFavs.length < newFavs.length\n            ? newFavs.slice(-1)\n            : oldFavs.filter((fav) => !newFavs.includes(fav))\n        )[0]\n        if (\n          this.hasFavoriteCount &&\n          editedFavs === this.record.uniqueIdentifier\n        ) {\n          if (newFavs.includes(editedFavs)) {\n            this.favoriteCount += 1\n          } else {\n            this.favoriteCount += -1\n          }\n        }\n      })\n  }\n\n  ngOnDestroy(): void {\n    this.subscription.unsubscribe()\n    this.countSubscription.unsubscribe()\n  }\n\n  toggleFavorite(isFavorite) {\n    this.loading = true\n    ;(isFavorite\n      ? this.favoritesService.addToFavorites([this.record.uniqueIdentifier])\n      : this.favoritesService.removeFromFavorites([\n          this.record.uniqueIdentifier,\n        ])\n    ).subscribe({\n      complete: () => {\n        this.loading = false\n        this.changeDetector.detectChanges()\n      },\n      error: () => {\n        this.loading = false\n        this.changeDetector.detectChanges()\n      },\n    })\n  }\n}\n","<div>\n  <span class=\"align-text-top mr-1.5 favorite-count\" *ngIf=\"hasFavoriteCount\">{{\n    favoriteCount\n  }}</span>\n  <gn-ui-star-toggle\n    [toggled]=\"isFavorite$ | async\"\n    (newValue)=\"toggleFavorite($event)\"\n    [disabled]=\"loading || (isAnonymous$ | async)\"\n  ></gn-ui-star-toggle>\n</div>\n"]}

package/esm2022/libs/feature/search/src/lib/feature-search.module.mjs

@@ -0,0 +1,131 @@
+import { CommonModule } from '@angular/common';
+import { HttpClientModule, HttpClientXsrfModule } from '@angular/common/http';
+import { UiSearchModule } from '../../../../../libs/ui/search/src';
+import { EffectsModule } from '@ngrx/effects';
+import { StoreModule } from '@ngrx/store';
+import { TranslateModule } from '@ngx-translate/core';
+import { FacetsModule } from './facets/facets.module';
+import { FuzzySearchComponent } from './fuzzy-search/fuzzy-search.component';
+import { RecordsMetricsComponent } from './records-metrics/records-metrics.component';
+import { ResultsLayoutComponent } from './results-layout/results-layout.component';
+import { ResultsListContainerComponent } from './results-list/results-list.container.component';
+import { SortByComponent } from './sort-by/sort-by.component';
+import { SearchEffects } from './state/effects';
+import { initialState, reducer, SEARCH_FEATURE_KEY } from './state/reducer';
+import { ResultsHitsContainerComponent } from './results-hits-number/results-hits.container.component';
+import { SearchStateContainerDirective } from './state/container/search-state.container.directive';
+import { UiInputsModule } from '../../../../../libs/ui/inputs/src';
+import { InjectionToken, NgModule } from '@angular/core';
+import { UiElementsModule } from '../../../../../libs/ui/elements/src';
+import { FavoriteStarComponent } from './favorites/favorite-star/favorite-star.component';
+import { MatIconModule } from '@angular/material/icon';
+import { FilterDropdownComponent } from './filter-dropdown/filter-dropdown.component';
+import { UiWidgetsModule } from '../../../../../libs/ui/widgets/src';
+import { RecordsRepositoryInterface } from '../../../../../libs/common/domain/src/lib/records-repository.interface';
+import { Gn4Repository } from '../../../../../libs/api/repository/src/lib/gn4';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@ngrx/effects";
+// this geometry will be used to filter & boost results accordingly
+export const FILTER_GEOMETRY = new InjectionToken('filter-geometry');
+// expects the replacement key ${uuid}
+export const RECORD_URL_TOKEN = new InjectionToken('record-url-token');
+export class FeatureSearchModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FeatureSearchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: FeatureSearchModule, declarations: [SortByComponent,
+            ResultsLayoutComponent,
+            FuzzySearchComponent,
+            RecordsMetricsComponent,
+            ResultsListContainerComponent,
+            ResultsHitsContainerComponent,
+            SearchStateContainerDirective,
+            FavoriteStarComponent,
+            FilterDropdownComponent], imports: [CommonModule, i1.TranslateModule, i2.StoreFeatureModule, i3.EffectsFeatureModule, HttpClientModule,
+            HttpClientXsrfModule,
+            UiSearchModule,
+            UiInputsModule,
+            UiElementsModule,
+            FacetsModule,
+            MatIconModule,
+            UiWidgetsModule], exports: [SortByComponent,
+            ResultsLayoutComponent,
+            FuzzySearchComponent,
+            RecordsMetricsComponent,
+            ResultsListContainerComponent,
+            ResultsHitsContainerComponent,
+            FacetsModule,
+            SearchStateContainerDirective,
+            FavoriteStarComponent,
+            FilterDropdownComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FeatureSearchModule, providers: [
+            {
+                provide: RecordsRepositoryInterface,
+                useClass: Gn4Repository,
+            },
+        ], imports: [CommonModule,
+            TranslateModule.forChild(),
+            StoreModule.forFeature(SEARCH_FEATURE_KEY, reducer, {
+                initialState,
+            }),
+            EffectsModule.forFeature([SearchEffects]),
+            HttpClientModule,
+            HttpClientXsrfModule,
+            UiSearchModule,
+            UiInputsModule,
+            UiElementsModule,
+            FacetsModule,
+            MatIconModule,
+            UiWidgetsModule, FacetsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FeatureSearchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SortByComponent,
+                        ResultsLayoutComponent,
+                        FuzzySearchComponent,
+                        RecordsMetricsComponent,
+                        ResultsListContainerComponent,
+                        ResultsHitsContainerComponent,
+                        SearchStateContainerDirective,
+                        FavoriteStarComponent,
+                        FilterDropdownComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        TranslateModule.forChild(),
+                        StoreModule.forFeature(SEARCH_FEATURE_KEY, reducer, {
+                            initialState,
+                        }),
+                        EffectsModule.forFeature([SearchEffects]),
+                        HttpClientModule,
+                        HttpClientXsrfModule,
+                        UiSearchModule,
+                        UiInputsModule,
+                        UiElementsModule,
+                        FacetsModule,
+                        MatIconModule,
+                        UiWidgetsModule,
+                    ],
+                    exports: [
+                        SortByComponent,
+                        ResultsLayoutComponent,
+                        FuzzySearchComponent,
+                        RecordsMetricsComponent,
+                        ResultsListContainerComponent,
+                        ResultsHitsContainerComponent,
+                        FacetsModule,
+                        SearchStateContainerDirective,
+                        FavoriteStarComponent,
+                        FilterDropdownComponent,
+                    ],
+                    providers: [
+                        {
+                            provide: RecordsRepositoryInterface,
+                            useClass: Gn4Repository,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-search.module.js","sourceRoot":"","sources":["../../../../../../../libs/feature/search/src/lib/feature-search.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common'\nimport { HttpClientModule, HttpClientXsrfModule } from '@angular/common/http'\nimport { UiSearchModule } from '../../../../../libs/ui/search/src'\nimport { EffectsModule } from '@ngrx/effects'\nimport { StoreModule } from '@ngrx/store'\nimport { TranslateModule } from '@ngx-translate/core'\nimport { FacetsModule } from './facets/facets.module'\nimport { FuzzySearchComponent } from './fuzzy-search/fuzzy-search.component'\nimport { RecordsMetricsComponent } from './records-metrics/records-metrics.component'\nimport { ResultsLayoutComponent } from './results-layout/results-layout.component'\nimport { ResultsListContainerComponent } from './results-list/results-list.container.component'\nimport { SortByComponent } from './sort-by/sort-by.component'\nimport { SearchEffects } from './state/effects'\nimport { initialState, reducer, SEARCH_FEATURE_KEY } from './state/reducer'\nimport { ResultsHitsContainerComponent } from './results-hits-number/results-hits.container.component'\nimport { SearchStateContainerDirective } from './state/container/search-state.container.directive'\nimport { UiInputsModule } from '../../../../../libs/ui/inputs/src'\nimport { InjectionToken, NgModule } from '@angular/core'\nimport { UiElementsModule } from '../../../../../libs/ui/elements/src'\nimport { FavoriteStarComponent } from './favorites/favorite-star/favorite-star.component'\nimport { MatIconModule } from '@angular/material/icon'\nimport { FilterDropdownComponent } from './filter-dropdown/filter-dropdown.component'\nimport { Geometry } from 'geojson'\nimport { UiWidgetsModule } from '../../../../../libs/ui/widgets/src'\nimport { RecordsRepositoryInterface } from '../../../../../libs/common/domain/src/lib/records-repository.interface'\nimport { Gn4Repository } from '../../../../../libs/api/repository/src/lib/gn4'\n\n// this geometry will be used to filter & boost results accordingly\nexport const FILTER_GEOMETRY = new InjectionToken<Promise<Geometry>>(\n  'filter-geometry'\n)\n\n// expects the replacement key ${uuid}\nexport const RECORD_URL_TOKEN = new InjectionToken<string>('record-url-token')\n\n@NgModule({\n  declarations: [\n    SortByComponent,\n    ResultsLayoutComponent,\n    FuzzySearchComponent,\n    RecordsMetricsComponent,\n    ResultsListContainerComponent,\n    ResultsHitsContainerComponent,\n    SearchStateContainerDirective,\n    FavoriteStarComponent,\n    FilterDropdownComponent,\n  ],\n  imports: [\n    CommonModule,\n    TranslateModule.forChild(),\n    StoreModule.forFeature(SEARCH_FEATURE_KEY, reducer, {\n      initialState,\n    }),\n    EffectsModule.forFeature([SearchEffects]),\n    HttpClientModule,\n    HttpClientXsrfModule,\n    UiSearchModule,\n    UiInputsModule,\n    UiElementsModule,\n    FacetsModule,\n    MatIconModule,\n    UiWidgetsModule,\n  ],\n  exports: [\n    SortByComponent,\n    ResultsLayoutComponent,\n    FuzzySearchComponent,\n    RecordsMetricsComponent,\n    ResultsListContainerComponent,\n    ResultsHitsContainerComponent,\n    FacetsModule,\n    SearchStateContainerDirective,\n    FavoriteStarComponent,\n    FilterDropdownComponent,\n  ],\n  providers: [\n    {\n      provide: RecordsRepositoryInterface,\n      useClass: Gn4Repository,\n    },\n  ],\n})\nexport class FeatureSearchModule {}\n"]}

package/esm2022/libs/feature/search/src/lib/filter-dropdown/filter-dropdown.component.mjs

@@ -0,0 +1,42 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import { of, switchMap } from 'rxjs';
+import { catchError, filter, map, startWith } from 'rxjs/operators';
+import { SearchFacade } from '../state/search.facade';
+import { SearchService } from '../utils/service/search.service';
+import { FieldsService } from '../utils/service/fields.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../state/search.facade";
+import * as i2 from "../utils/service/search.service";
+import * as i3 from "../utils/service/fields.service";
+import * as i4 from "../../../../../ui/inputs/src/lib/dropdown-multiselect/dropdown-multiselect.component";
+import * as i5 from "@angular/common";
+export class FilterDropdownComponent {
+    onSelectedValues(values) {
+        this.fieldsService
+            .buildFiltersFromFieldValues({ [this.fieldName]: values })
+            .subscribe((filters) => this.searchService.updateFilters(filters));
+    }
+    constructor(searchFacade, searchService, fieldsService) {
+        this.searchFacade = searchFacade;
+        this.searchService = searchService;
+        this.fieldsService = fieldsService;
+        this.selected$ = this.searchFacade.searchFilters$.pipe(switchMap((filters) => this.fieldsService.readFieldValuesFromFilters(filters)), map((fieldValues) => fieldValues[this.fieldName]), filter((selected) => !!selected), startWith([]), catchError(() => of([])));
+    }
+    ngOnInit() {
+        this.choices$ = this.fieldsService.getAvailableValues(this.fieldName).pipe(startWith([]), map((values) => values.map((v) => ({
+            ...v,
+            value: v.value.toString(), // converting to string for the dropdown
+        }))), catchError(() => of([])));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FilterDropdownComponent, deps: [{ token: i1.SearchFacade }, { token: i2.SearchService }, { token: i3.FieldsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: FilterDropdownComponent, selector: "gn-ui-filter-dropdown", inputs: { fieldName: "fieldName", title: "title" }, ngImport: i0, template: "<gn-ui-dropdown-multiselect\n  class=\"w-full\"\n  [title]=\"title\"\n  [maxRows]=\"6\"\n  [choices]=\"choices$ | async\"\n  [selected]=\"selected$ | async\"\n  [allowSearch]=\"true\"\n  (selectValues)=\"onSelectedValues($event)\"\n  [attr.data-cy-field]=\"fieldName\"\n>\n</gn-ui-dropdown-multiselect>\n", styles: [""], dependencies: [{ kind: "component", type: i4.DropdownMultiselectComponent, selector: "gn-ui-dropdown-multiselect", inputs: ["title", "choices", "selected", "allowSearch", "maxRows", "searchInputValue"], outputs: ["selectValues"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FilterDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'gn-ui-filter-dropdown', changeDetection: ChangeDetectionStrategy.OnPush, template: "<gn-ui-dropdown-multiselect\n  class=\"w-full\"\n  [title]=\"title\"\n  [maxRows]=\"6\"\n  [choices]=\"choices$ | async\"\n  [selected]=\"selected$ | async\"\n  [allowSearch]=\"true\"\n  (selectValues)=\"onSelectedValues($event)\"\n  [attr.data-cy-field]=\"fieldName\"\n>\n</gn-ui-dropdown-multiselect>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.SearchFacade }, { type: i2.SearchService }, { type: i3.FieldsService }]; }, propDecorators: { fieldName: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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