@alfresco/adf-content-services 8.1.0-16295066092 → 8.1.0-16320806191

package/esm2022/lib/search/services/search-configuration.service.mjs

@@ -0,0 +1,50 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SearchConfigurationService {
+    /**
+     * Generates a request object with custom search parameters.
+     *
+     * @param searchTerm Term text to search for
+     * @param maxResults Maximum number of search results to show in a page
+     * @param skipCount The offset of the start of the page within the results list
+     * @returns Query body defined by the parameters
+     */
+    generateQueryBody(searchTerm, maxResults, skipCount) {
+        return {
+            query: {
+                query: searchTerm ? `'${searchTerm}*' OR name:'${searchTerm}*'` : searchTerm
+            },
+            include: ['path', 'allowableOperations'],
+            paging: {
+                maxItems: maxResults,
+                skipCount
+            },
+            filterQueries: [{ query: `TYPE:'cm:folder' OR TYPE:'cm:content'` }, { query: 'NOT cm:creator:System' }]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchConfigurationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchConfigurationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/services/search-facet-filters.service.mjs

@@ -0,0 +1,374 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { FacetBucketSortBy, FacetBucketSortDirection } from '../models/facet-field.interface';
+import { throwError } from 'rxjs';
+import { SearchQueryBuilderService } from './search-query-builder.service';
+import { TranslationService } from '@alfresco/adf-core';
+import { SearchService } from './search.service';
+import { catchError } from 'rxjs/operators';
+import { SearchFilterList } from '../models/search-filter-list.model';
+import { CategoryService } from '../../category/services/category.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "./search-query-builder.service";
+import * as i2 from "./search.service";
+import * as i3 from "@alfresco/adf-core";
+import * as i4 from "../../category/services/category.service";
+const DEFAULT_PAGE_SIZE = 5;
+export class SearchFacetFiltersService {
+    constructor(queryBuilder, searchService, translationService, categoryService) {
+        this.queryBuilder = queryBuilder;
+        this.searchService = searchService;
+        this.translationService = translationService;
+        this.categoryService = categoryService;
+        /**
+         * All facet field items to be displayed in the component. These are updated according to the response.
+         * When a new search is performed, the already existing items are updated with the new bucket count values and
+         * the newly received items are added to the responseFacets.
+         */
+        this.responseFacets = null;
+        /* tabbed facet incorporating creator and modifier facets */
+        this.tabbedFacet = null;
+        /** shows the facet chips */
+        this.selectedBuckets = [];
+        this.facetQueriesPageSize = DEFAULT_PAGE_SIZE;
+        this.getFilterByMinCount = (minCountInput) => (bucket) => {
+            let minCount = minCountInput;
+            if (minCount === undefined) {
+                minCount = 1;
+            }
+            return bucket.count >= minCount;
+        };
+        this.getBucketFilterFunction = (bucketList) => (bucket) => {
+            if (bucket && bucketList.filterText) {
+                const pattern = (bucketList.filterText || '').toLowerCase();
+                const label = (this.translationService.instant(bucket.display) || this.translationService.instant(bucket.label)).toLowerCase();
+                return this.queryBuilder.config.filterWithContains ? label.indexOf(pattern) !== -1 : label.startsWith(pattern);
+            }
+            return true;
+        };
+        if (queryBuilder.config?.facetQueries) {
+            this.facetQueriesPageSize = queryBuilder.config.facetQueries.pageSize || DEFAULT_PAGE_SIZE;
+        }
+        this.queryBuilder.configUpdated.pipe(takeUntilDestroyed()).subscribe(() => {
+            this.selectedBuckets = [];
+            this.responseFacets = null;
+        });
+        this.queryBuilder.updated.pipe(takeUntilDestroyed()).subscribe((query) => this.queryBuilder.execute(true, query));
+        this.queryBuilder.executed.pipe(takeUntilDestroyed()).subscribe((resultSetPaging) => {
+            this.onDataLoaded(resultSetPaging);
+            this.searchService.dataLoaded.next(resultSetPaging);
+        });
+    }
+    onDataLoaded(data) {
+        const context = data.list.context;
+        if (context) {
+            this.parseFacets(context);
+        }
+        else {
+            this.responseFacets = null;
+        }
+    }
+    parseFacets(context) {
+        this.parseFacetFields(context);
+        this.parseFacetIntervals(context);
+        this.parseFacetQueries(context);
+        this.sortFacets();
+        this.parseTabbedFacetField();
+    }
+    parseFacetItems(context, configFacetFields, itemType) {
+        configFacetFields.forEach((facetField) => {
+            const responseField = this.findFacet(context, itemType, facetField.label);
+            const responseBuckets = this.getResponseBuckets(responseField, facetField).filter(this.getFilterByMinCount(facetField.mincount));
+            this.sortFacetBuckets(responseBuckets, facetField.settings?.bucketSortBy, facetField.settings?.bucketSortDirection ?? FacetBucketSortDirection.ASCENDING);
+            const alreadyExistingField = this.findResponseFacet(itemType, facetField.label);
+            if (facetField.field === 'cm:categories') {
+                this.loadCategoryNames(responseBuckets);
+            }
+            if (alreadyExistingField) {
+                const alreadyExistingBuckets = alreadyExistingField.buckets?.items || [];
+                this.updateExistingBuckets(responseField, responseBuckets, alreadyExistingField, alreadyExistingBuckets);
+            }
+            else if (responseField) {
+                if (responseBuckets.length > 0) {
+                    const bucketList = new SearchFilterList(responseBuckets, facetField.pageSize);
+                    bucketList.filter = this.getBucketFilterFunction(bucketList);
+                    if (!this.responseFacets) {
+                        this.responseFacets = [];
+                    }
+                    this.responseFacets.push({
+                        ...facetField,
+                        type: responseField.type || itemType,
+                        label: facetField.label,
+                        pageSize: facetField.pageSize | DEFAULT_PAGE_SIZE,
+                        currentPageSize: facetField.pageSize | DEFAULT_PAGE_SIZE,
+                        buckets: bucketList
+                    });
+                }
+            }
+        });
+    }
+    parseTabbedFacetField() {
+        if (this.responseFacets) {
+            const fields = this.responseFacets.reduce((acc, facet) => `${acc},${facet.field}`, '');
+            const tabbedFacetField = {
+                fields: ['creator', 'modifier'],
+                label: 'SEARCH.FILTER.PEOPLE',
+                facets: {}
+            };
+            this.extractCreatorAndModifier(tabbedFacetField, fields);
+        }
+    }
+    extractCreatorAndModifier(tabbedFacet, fields) {
+        if (fields.includes('creator') && fields.includes('modifier')) {
+            for (let i = this.responseFacets.length - 1; i >= 0; i--) {
+                if (this.responseFacets[i].field === 'creator' || this.responseFacets[i].field === 'modifier') {
+                    const removedFacet = this.responseFacets.splice(i, 1)[0];
+                    Object.defineProperty(tabbedFacet.facets, removedFacet.field, {
+                        value: removedFacet,
+                        writable: true
+                    });
+                }
+            }
+            this.tabbedFacet = tabbedFacet;
+        }
+    }
+    parseFacetFields(context) {
+        const configFacetFields = this.queryBuilder.config.facetFields?.fields || [];
+        this.parseFacetItems(context, configFacetFields, 'field');
+    }
+    parseFacetIntervals(context) {
+        const configFacetIntervals = this.queryBuilder.config.facetIntervals?.intervals || [];
+        this.parseFacetItems(context, configFacetIntervals, 'interval');
+    }
+    parseFacetQueries(context) {
+        const facetQuerySetting = this.queryBuilder.config.facetQueries?.settings || {};
+        const configFacetQueries = this.queryBuilder.config.facetQueries?.queries || [];
+        const configGroups = configFacetQueries.reduce((acc, query) => {
+            const group = this.queryBuilder.getQueryGroup(query);
+            if (acc[group]) {
+                acc[group].push(query);
+            }
+            else {
+                acc[group] = [query];
+            }
+            return acc;
+        }, []);
+        const minCount = this.queryBuilder.config.facetQueries?.mincount;
+        const minCountFilter = this.getFilterByMinCount(minCount);
+        Object.keys(configGroups).forEach((group) => {
+            const responseField = this.findFacet(context, 'query', group);
+            const responseBuckets = this.getResponseQueryBuckets(responseField, configGroups[group]).filter(minCountFilter);
+            this.sortFacetBuckets(responseBuckets, facetQuerySetting?.bucketSortBy, facetQuerySetting.bucketSortDirection ?? FacetBucketSortDirection.ASCENDING);
+            const alreadyExistingField = this.findResponseFacet('query', group);
+            if (alreadyExistingField) {
+                const alreadyExistingBuckets = alreadyExistingField.buckets?.items || [];
+                this.updateExistingBuckets(responseField, responseBuckets, alreadyExistingField, alreadyExistingBuckets);
+            }
+            else if (responseField) {
+                if (responseBuckets.length > 0) {
+                    const bucketList = new SearchFilterList(responseBuckets, this.facetQueriesPageSize);
+                    bucketList.filter = this.getBucketFilterFunction(bucketList);
+                    if (!this.responseFacets) {
+                        this.responseFacets = [];
+                    }
+                    this.responseFacets.push({
+                        field: group,
+                        type: responseField.type || 'query',
+                        label: group,
+                        pageSize: DEFAULT_PAGE_SIZE,
+                        currentPageSize: DEFAULT_PAGE_SIZE,
+                        buckets: bucketList,
+                        settings: facetQuerySetting
+                    });
+                }
+            }
+        });
+    }
+    sortFacets() {
+        this.responseFacets?.sort((facet1, facet2) => (facet1.settings?.facetOrder ?? 0) - (facet2.settings?.facetOrder ?? 0));
+    }
+    getResponseBuckets(responseField, configField) {
+        return (responseField?.buckets || []).map((respBucket) => {
+            respBucket['count'] = this.getCountValue(respBucket);
+            respBucket.filterQuery = respBucket.filterQuery || this.getCorrespondingFilterQuery(configField, respBucket.label);
+            return {
+                ...respBucket,
+                checked: false,
+                display: respBucket.display,
+                label: respBucket.label
+            };
+        });
+    }
+    getResponseQueryBuckets(responseField, configGroup) {
+        return (configGroup || []).map((query) => {
+            const respBucket = (responseField?.buckets || []).find((bucket) => bucket.label === query.label) || {};
+            respBucket['count'] = this.getCountValue(respBucket);
+            return {
+                ...respBucket,
+                checked: false,
+                display: respBucket.display,
+                label: respBucket.label
+            };
+        });
+    }
+    sortFacetBuckets(buckets, sortBy, sortDirection) {
+        switch (sortBy) {
+            case FacetBucketSortBy.LABEL:
+                buckets.sort((bucket1, bucket2) => sortDirection === FacetBucketSortDirection.ASCENDING
+                    ? bucket1.label.localeCompare(bucket2.label)
+                    : bucket2.label.localeCompare(bucket1.label));
+                break;
+            case FacetBucketSortBy.COUNT:
+                buckets.sort((bucket1, bucket2) => sortDirection === FacetBucketSortDirection.ASCENDING ? bucket1.count - bucket2.count : bucket2.count - bucket1.count);
+                break;
+            default:
+                return;
+        }
+    }
+    getCountValue(bucket) {
+        return (!!bucket && !!bucket.metrics && bucket.metrics[0]?.value?.count) || 0;
+    }
+    getBucketCountDisplay(bucket) {
+        return bucket.count === null ? '' : `(${bucket.count})`;
+    }
+    getCorrespondingFilterQuery(configFacetItem, bucketLabel) {
+        let filterQuery = null;
+        if (configFacetItem.field && bucketLabel) {
+            if (configFacetItem.sets) {
+                const configSet = configFacetItem.sets.find((set) => bucketLabel === set.label);
+                if (configSet) {
+                    filterQuery = this.buildIntervalQuery(configFacetItem.field, configSet);
+                }
+            }
+            else {
+                filterQuery = `${configFacetItem.field}:"${bucketLabel}"`;
+            }
+        }
+        return filterQuery;
+    }
+    buildIntervalQuery(fieldName, interval) {
+        const start = interval.start;
+        const end = interval.end;
+        const startLimit = interval.startInclusive === undefined || interval.startInclusive === true ? '[' : '<';
+        const endLimit = interval.endInclusive === undefined || interval.endInclusive === true ? ']' : '>';
+        return `${fieldName}:${startLimit}"${start}" TO "${end}"${endLimit}`;
+    }
+    findFacet(context, itemType, fieldLabel) {
+        return (context.facets || []).find((response) => response.type === itemType && response.label === fieldLabel) || {};
+    }
+    findResponseFacet(itemType, fieldLabel) {
+        return (this.responseFacets || []).find((response) => response.type === itemType && response.label === fieldLabel);
+    }
+    updateExistingBuckets(responseField, responseBuckets, alreadyExistingField, alreadyExistingBuckets) {
+        const bucketsToDelete = [];
+        alreadyExistingBuckets.forEach((bucket) => {
+            const responseBucket = (responseField?.buckets || []).find((respBucket) => respBucket.label === bucket.label);
+            if (!responseBucket) {
+                bucketsToDelete.push(bucket);
+            }
+            bucket.count = this.getCountValue(responseBucket);
+            return bucket;
+        });
+        const hasSelection = !!this.selectedBuckets.find((selBuckets) => alreadyExistingField.label === selBuckets.field.label && alreadyExistingField.type === selBuckets.field.type);
+        if (!hasSelection && bucketsToDelete.length) {
+            bucketsToDelete.forEach((bucket) => {
+                alreadyExistingField.buckets.deleteItem(bucket);
+            });
+        }
+        responseBuckets.forEach((respBucket) => {
+            const existingBucket = alreadyExistingBuckets.find((oldBucket) => oldBucket.label === respBucket.label);
+            if (!existingBucket) {
+                alreadyExistingField.buckets.addItem(respBucket);
+            }
+        });
+    }
+    loadCategoryNames(bucketList) {
+        bucketList.forEach((item) => {
+            const categoryId = item.label.split('/').pop();
+            this.categoryService
+                .getCategory(categoryId, { include: ['path'] })
+                .pipe(catchError((error) => throwError(error)))
+                .subscribe((category) => {
+                const nextAfterGeneralPathPartIndex = 3;
+                const pathSeparator = '/';
+                const path = category.entry.path.split(pathSeparator).slice(nextAfterGeneralPathPartIndex).join('/');
+                item.display = path ? `${path}/${category.entry.name}` : category.entry.name;
+            });
+        });
+    }
+    unselectFacetBucket(facetField, bucket) {
+        if (bucket) {
+            bucket.checked = false;
+            this.queryBuilder.removeUserFacetBucket(facetField.field, bucket);
+            this.updateSelectedBuckets();
+            this.queryBuilder.update();
+        }
+    }
+    /* update adf-search-chip-list component view */
+    updateSelectedBuckets() {
+        if (this.responseFacets) {
+            this.selectedBuckets = [];
+            let facetFields = this.tabbedFacet === null ? [] : Object.keys(this.tabbedFacet?.fields).map((field) => this.tabbedFacet.facets[field]);
+            facetFields = [...facetFields, ...this.responseFacets];
+            for (const facetField of facetFields) {
+                if (facetField?.buckets) {
+                    this.selectedBuckets.push(...this.queryBuilder
+                        .getUserFacetBuckets(facetField.field)
+                        .filter((bucket) => bucket.checked)
+                        .map((bucket) => ({ field: facetField, bucket })));
+                }
+            }
+        }
+        else {
+            this.selectedBuckets = [];
+        }
+    }
+    resetAllSelectedBuckets() {
+        this.responseFacets.forEach((facetField) => {
+            if (facetField?.buckets) {
+                for (const bucket of facetField.buckets.items) {
+                    bucket.checked = false;
+                    this.queryBuilder.removeUserFacetBucket(facetField.field, bucket);
+                }
+                this.updateSelectedBuckets();
+            }
+        });
+        this.queryBuilder.update();
+    }
+    resetQueryFragments() {
+        this.queryBuilder.queryFragments = {};
+        this.queryBuilder.resetToDefaults();
+    }
+    reset() {
+        this.responseFacets = [];
+        this.selectedBuckets = [];
+        this.tabbedFacet = null;
+        this.queryBuilder.resetToDefaults(true);
+        this.queryBuilder.update();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchFacetFiltersService, deps: [{ token: i1.SearchQueryBuilderService }, { token: i2.SearchService }, { token: i3.TranslationService }, { token: i4.CategoryService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchFacetFiltersService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchFacetFiltersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.SearchQueryBuilderService }, { type: i2.SearchService }, { type: i3.TranslationService }, { type: i4.CategoryService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-facet-filters.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/search/services/search-facet-filters.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable } from '@angular/core';\nimport { FacetBucketSortBy, FacetBucketSortDirection, FacetField } from '../models/facet-field.interface';\nimport { throwError } from 'rxjs';\nimport { SearchQueryBuilderService } from './search-query-builder.service';\nimport { TranslationService } from '@alfresco/adf-core';\nimport { SearchService } from './search.service';\nimport { catchError } from 'rxjs/operators';\nimport { GenericBucket, GenericFacetResponse, ResultSetContext, ResultSetPaging } from '@alfresco/js-api';\nimport { SearchFilterList } from '../models/search-filter-list.model';\nimport { FacetFieldBucket } from '../models/facet-field-bucket.interface';\nimport { CategoryService } from '../../category/services/category.service';\nimport { TabbedFacetField } from '../models/tabbed-facet-field.interface';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nexport interface SelectedBucket {\n    field: FacetField;\n    bucket: FacetFieldBucket;\n}\n\nconst DEFAULT_PAGE_SIZE: number = 5;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SearchFacetFiltersService {\n    /**\n     * All facet field items to be displayed in the component. These are updated according to the response.\n     * When a new search is performed, the already existing items are updated with the new bucket count values and\n     * the newly received items are added to the responseFacets.\n     */\n    responseFacets: FacetField[] = null;\n    /* tabbed facet incorporating creator and modifier facets */\n    tabbedFacet: TabbedFacetField = null;\n\n    /** shows the facet chips */\n    selectedBuckets: SelectedBucket[] = [];\n\n    private readonly facetQueriesPageSize = DEFAULT_PAGE_SIZE;\n    constructor(\n        private queryBuilder: SearchQueryBuilderService,\n        private searchService: SearchService,\n        private translationService: TranslationService,\n        private categoryService: CategoryService\n    ) {\n        if (queryBuilder.config?.facetQueries) {\n            this.facetQueriesPageSize = queryBuilder.config.facetQueries.pageSize || DEFAULT_PAGE_SIZE;\n        }\n\n        this.queryBuilder.configUpdated.pipe(takeUntilDestroyed()).subscribe(() => {\n            this.selectedBuckets = [];\n            this.responseFacets = null;\n        });\n\n        this.queryBuilder.updated.pipe(takeUntilDestroyed()).subscribe((query) => this.queryBuilder.execute(true, query));\n\n        this.queryBuilder.executed.pipe(takeUntilDestroyed()).subscribe((resultSetPaging: ResultSetPaging) => {\n            this.onDataLoaded(resultSetPaging);\n            this.searchService.dataLoaded.next(resultSetPaging);\n        });\n    }\n\n    onDataLoaded(data: any) {\n        const context = data.list.context;\n\n        if (context) {\n            this.parseFacets(context);\n        } else {\n            this.responseFacets = null;\n        }\n    }\n\n    private parseFacets(context: ResultSetContext) {\n        this.parseFacetFields(context);\n        this.parseFacetIntervals(context);\n        this.parseFacetQueries(context);\n        this.sortFacets();\n        this.parseTabbedFacetField();\n    }\n\n    private parseFacetItems(context: ResultSetContext, configFacetFields: FacetField[], itemType: string) {\n        configFacetFields.forEach((facetField) => {\n            const responseField = this.findFacet(context, itemType, facetField.label);\n            const responseBuckets = this.getResponseBuckets(responseField, facetField).filter(this.getFilterByMinCount(facetField.mincount));\n            this.sortFacetBuckets(\n                responseBuckets,\n                facetField.settings?.bucketSortBy,\n                facetField.settings?.bucketSortDirection ?? FacetBucketSortDirection.ASCENDING\n            );\n            const alreadyExistingField = this.findResponseFacet(itemType, facetField.label);\n\n            if (facetField.field === 'cm:categories') {\n                this.loadCategoryNames(responseBuckets);\n            }\n\n            if (alreadyExistingField) {\n                const alreadyExistingBuckets = alreadyExistingField.buckets?.items || [];\n\n                this.updateExistingBuckets(responseField, responseBuckets, alreadyExistingField, alreadyExistingBuckets);\n            } else if (responseField) {\n                if (responseBuckets.length > 0) {\n                    const bucketList = new SearchFilterList<FacetFieldBucket>(responseBuckets, facetField.pageSize);\n                    bucketList.filter = this.getBucketFilterFunction(bucketList);\n\n                    if (!this.responseFacets) {\n                        this.responseFacets = [];\n                    }\n                    this.responseFacets.push({\n                        ...facetField,\n                        type: responseField.type || itemType,\n                        label: facetField.label,\n                        pageSize: facetField.pageSize | DEFAULT_PAGE_SIZE,\n                        currentPageSize: facetField.pageSize | DEFAULT_PAGE_SIZE,\n                        buckets: bucketList\n                    });\n                }\n            }\n        });\n    }\n\n    private parseTabbedFacetField() {\n        if (this.responseFacets) {\n            const fields = this.responseFacets.reduce((acc, facet) => `${acc},${facet.field}`, '');\n            const tabbedFacetField: TabbedFacetField = {\n                fields: ['creator', 'modifier'],\n                label: 'SEARCH.FILTER.PEOPLE',\n                facets: {}\n            };\n            this.extractCreatorAndModifier(tabbedFacetField, fields);\n        }\n    }\n\n    private extractCreatorAndModifier(tabbedFacet: TabbedFacetField, fields: string) {\n        if (fields.includes('creator') && fields.includes('modifier')) {\n            for (let i = this.responseFacets.length - 1; i >= 0; i--) {\n                if (this.responseFacets[i].field === 'creator' || this.responseFacets[i].field === 'modifier') {\n                    const removedFacet = this.responseFacets.splice(i, 1)[0];\n                    Object.defineProperty(tabbedFacet.facets, removedFacet.field, {\n                        value: removedFacet,\n                        writable: true\n                    });\n                }\n            }\n            this.tabbedFacet = tabbedFacet;\n        }\n    }\n\n    private parseFacetFields(context: ResultSetContext) {\n        const configFacetFields = this.queryBuilder.config.facetFields?.fields || [];\n        this.parseFacetItems(context, configFacetFields, 'field');\n    }\n\n    private parseFacetIntervals(context: ResultSetContext) {\n        const configFacetIntervals = this.queryBuilder.config.facetIntervals?.intervals || [];\n        this.parseFacetItems(context, configFacetIntervals, 'interval');\n    }\n\n    private parseFacetQueries(context: ResultSetContext) {\n        const facetQuerySetting = this.queryBuilder.config.facetQueries?.settings || {};\n        const configFacetQueries = this.queryBuilder.config.facetQueries?.queries || [];\n        const configGroups = configFacetQueries.reduce((acc, query) => {\n            const group = this.queryBuilder.getQueryGroup(query);\n            if (acc[group]) {\n                acc[group].push(query);\n            } else {\n                acc[group] = [query];\n            }\n            return acc;\n        }, []);\n\n        const minCount = this.queryBuilder.config.facetQueries?.mincount;\n        const minCountFilter = this.getFilterByMinCount(minCount);\n\n        Object.keys(configGroups).forEach((group) => {\n            const responseField = this.findFacet(context, 'query', group);\n            const responseBuckets = this.getResponseQueryBuckets(responseField, configGroups[group]).filter(minCountFilter);\n            this.sortFacetBuckets(\n                responseBuckets,\n                facetQuerySetting?.bucketSortBy,\n                facetQuerySetting.bucketSortDirection ?? FacetBucketSortDirection.ASCENDING\n            );\n            const alreadyExistingField = this.findResponseFacet('query', group);\n\n            if (alreadyExistingField) {\n                const alreadyExistingBuckets = alreadyExistingField.buckets?.items || [];\n\n                this.updateExistingBuckets(responseField, responseBuckets, alreadyExistingField, alreadyExistingBuckets);\n            } else if (responseField) {\n                if (responseBuckets.length > 0) {\n                    const bucketList = new SearchFilterList<FacetFieldBucket>(responseBuckets, this.facetQueriesPageSize);\n                    bucketList.filter = this.getBucketFilterFunction(bucketList);\n\n                    if (!this.responseFacets) {\n                        this.responseFacets = [];\n                    }\n                    this.responseFacets.push({\n                        field: group,\n                        type: responseField.type || 'query',\n                        label: group,\n                        pageSize: DEFAULT_PAGE_SIZE,\n                        currentPageSize: DEFAULT_PAGE_SIZE,\n                        buckets: bucketList,\n                        settings: facetQuerySetting\n                    });\n                }\n            }\n        });\n    }\n\n    private sortFacets() {\n        this.responseFacets?.sort((facet1, facet2) => (facet1.settings?.facetOrder ?? 0) - (facet2.settings?.facetOrder ?? 0));\n    }\n\n    private getResponseBuckets(responseField: GenericFacetResponse, configField: FacetField): FacetFieldBucket[] {\n        return (responseField?.buckets || []).map((respBucket) => {\n            respBucket['count'] = this.getCountValue(respBucket);\n            respBucket.filterQuery = respBucket.filterQuery || this.getCorrespondingFilterQuery(configField, respBucket.label);\n            return {\n                ...respBucket,\n                checked: false,\n                display: respBucket.display,\n                label: respBucket.label\n            } as FacetFieldBucket;\n        });\n    }\n\n    private getResponseQueryBuckets(responseField: GenericFacetResponse, configGroup: any): FacetFieldBucket[] {\n        return (configGroup || []).map((query) => {\n            const respBucket = (responseField?.buckets || []).find((bucket) => bucket.label === query.label) || {};\n\n            respBucket['count'] = this.getCountValue(respBucket);\n            return {\n                ...respBucket,\n                checked: false,\n                display: respBucket.display,\n                label: respBucket.label\n            };\n        });\n    }\n\n    private sortFacetBuckets(buckets: FacetFieldBucket[], sortBy: FacetBucketSortBy, sortDirection: FacetBucketSortDirection) {\n        switch (sortBy) {\n            case FacetBucketSortBy.LABEL:\n                buckets.sort((bucket1, bucket2) =>\n                    sortDirection === FacetBucketSortDirection.ASCENDING\n                        ? bucket1.label.localeCompare(bucket2.label)\n                        : bucket2.label.localeCompare(bucket1.label)\n                );\n                break;\n            case FacetBucketSortBy.COUNT:\n                buckets.sort((bucket1, bucket2) =>\n                    sortDirection === FacetBucketSortDirection.ASCENDING ? bucket1.count - bucket2.count : bucket2.count - bucket1.count\n                );\n                break;\n            default:\n                return;\n        }\n    }\n\n    private getCountValue(bucket: GenericBucket): number {\n        return (!!bucket && !!bucket.metrics && bucket.metrics[0]?.value?.count) || 0;\n    }\n\n    getBucketCountDisplay(bucket: FacetFieldBucket): string {\n        return bucket.count === null ? '' : `(${bucket.count})`;\n    }\n\n    private getFilterByMinCount =\n        (minCountInput: number) =>\n        (bucket: FacetFieldBucket): boolean => {\n            let minCount = minCountInput;\n            if (minCount === undefined) {\n                minCount = 1;\n            }\n            return bucket.count >= minCount;\n        };\n\n    private getCorrespondingFilterQuery(configFacetItem: FacetField, bucketLabel: string): string {\n        let filterQuery = null;\n\n        if (configFacetItem.field && bucketLabel) {\n            if (configFacetItem.sets) {\n                const configSet = configFacetItem.sets.find((set) => bucketLabel === set.label);\n\n                if (configSet) {\n                    filterQuery = this.buildIntervalQuery(configFacetItem.field, configSet);\n                }\n            } else {\n                filterQuery = `${configFacetItem.field}:\"${bucketLabel}\"`;\n            }\n        }\n\n        return filterQuery;\n    }\n\n    private buildIntervalQuery(fieldName: string, interval: any): string {\n        const start = interval.start;\n        const end = interval.end;\n        const startLimit = interval.startInclusive === undefined || interval.startInclusive === true ? '[' : '<';\n        const endLimit = interval.endInclusive === undefined || interval.endInclusive === true ? ']' : '>';\n\n        return `${fieldName}:${startLimit}\"${start}\" TO \"${end}\"${endLimit}`;\n    }\n\n    private findFacet(context: ResultSetContext, itemType: string, fieldLabel: string): GenericFacetResponse {\n        return (context.facets || []).find((response) => response.type === itemType && response.label === fieldLabel) || {};\n    }\n\n    private findResponseFacet(itemType: string, fieldLabel: string): FacetField {\n        return (this.responseFacets || []).find((response) => response.type === itemType && response.label === fieldLabel);\n    }\n\n    private updateExistingBuckets(\n        responseField: GenericFacetResponse,\n        responseBuckets: FacetFieldBucket[],\n        alreadyExistingField: FacetField,\n        alreadyExistingBuckets: FacetFieldBucket[]\n    ) {\n        const bucketsToDelete = [];\n\n        alreadyExistingBuckets.forEach((bucket) => {\n            const responseBucket = (responseField?.buckets || []).find((respBucket) => respBucket.label === bucket.label);\n\n            if (!responseBucket) {\n                bucketsToDelete.push(bucket);\n            }\n            bucket.count = this.getCountValue(responseBucket);\n            return bucket;\n        });\n\n        const hasSelection = !!this.selectedBuckets.find(\n            (selBuckets) => alreadyExistingField.label === selBuckets.field.label && alreadyExistingField.type === selBuckets.field.type\n        );\n\n        if (!hasSelection && bucketsToDelete.length) {\n            bucketsToDelete.forEach((bucket) => {\n                alreadyExistingField.buckets.deleteItem(bucket);\n            });\n        }\n\n        responseBuckets.forEach((respBucket) => {\n            const existingBucket = alreadyExistingBuckets.find((oldBucket) => oldBucket.label === respBucket.label);\n\n            if (!existingBucket) {\n                alreadyExistingField.buckets.addItem(respBucket);\n            }\n        });\n    }\n\n    private getBucketFilterFunction =\n        (bucketList: SearchFilterList<FacetFieldBucket>) =>\n        (bucket: FacetFieldBucket): boolean => {\n            if (bucket && bucketList.filterText) {\n                const pattern = (bucketList.filterText || '').toLowerCase();\n                const label = (this.translationService.instant(bucket.display) || this.translationService.instant(bucket.label)).toLowerCase();\n                return this.queryBuilder.config.filterWithContains ? label.indexOf(pattern) !== -1 : label.startsWith(pattern);\n            }\n            return true;\n        };\n\n    private loadCategoryNames(bucketList: FacetFieldBucket[]) {\n        bucketList.forEach((item) => {\n            const categoryId = item.label.split('/').pop();\n            this.categoryService\n                .getCategory(categoryId, { include: ['path'] })\n                .pipe(catchError((error) => throwError(error)))\n                .subscribe((category) => {\n                    const nextAfterGeneralPathPartIndex = 3;\n                    const pathSeparator = '/';\n                    const path = category.entry.path.split(pathSeparator).slice(nextAfterGeneralPathPartIndex).join('/');\n                    item.display = path ? `${path}/${category.entry.name}` : category.entry.name;\n                });\n        });\n    }\n\n    unselectFacetBucket(facetField: FacetField, bucket: FacetFieldBucket) {\n        if (bucket) {\n            bucket.checked = false;\n            this.queryBuilder.removeUserFacetBucket(facetField.field, bucket);\n            this.updateSelectedBuckets();\n            this.queryBuilder.update();\n        }\n    }\n\n    /* update adf-search-chip-list component view */\n    updateSelectedBuckets() {\n        if (this.responseFacets) {\n            this.selectedBuckets = [];\n            let facetFields = this.tabbedFacet === null ? [] : Object.keys(this.tabbedFacet?.fields).map((field) => this.tabbedFacet.facets[field]);\n            facetFields = [...facetFields, ...this.responseFacets];\n            for (const facetField of facetFields) {\n                if (facetField?.buckets) {\n                    this.selectedBuckets.push(\n                        ...this.queryBuilder\n                            .getUserFacetBuckets(facetField.field)\n                            .filter((bucket) => bucket.checked)\n                            .map((bucket) => ({ field: facetField, bucket }))\n                    );\n                }\n            }\n        } else {\n            this.selectedBuckets = [];\n        }\n    }\n\n    resetAllSelectedBuckets() {\n        this.responseFacets.forEach((facetField) => {\n            if (facetField?.buckets) {\n                for (const bucket of facetField.buckets.items) {\n                    bucket.checked = false;\n                    this.queryBuilder.removeUserFacetBucket(facetField.field, bucket);\n                }\n                this.updateSelectedBuckets();\n            }\n        });\n        this.queryBuilder.update();\n    }\n\n    resetQueryFragments() {\n        this.queryBuilder.queryFragments = {};\n        this.queryBuilder.resetToDefaults();\n    }\n\n    reset() {\n        this.responseFacets = [];\n        this.selectedBuckets = [];\n        this.tabbedFacet = null;\n        this.queryBuilder.resetToDefaults(true);\n        this.queryBuilder.update();\n    }\n}\n"]}

package/esm2022/lib/search/services/search-filter.service.mjs

@@ -0,0 +1,56 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { SearchTextComponent } from '../components/search-text/search-text.component';
+import { SearchRadioComponent } from '../components/search-radio/search-radio.component';
+import { SearchSliderComponent } from '../components/search-slider/search-slider.component';
+import { SearchNumberRangeComponent } from '../components/search-number-range/search-number-range.component';
+import { SearchCheckListComponent } from '../components/search-check-list/search-check-list.component';
+import { SearchDatetimeRangeComponent } from '../components/search-datetime-range/search-datetime-range.component';
+import { SearchLogicalFilterComponent } from '../components/search-logical-filter/search-logical-filter.component';
+import { SearchFilterAutocompleteChipsComponent } from '../components/search-filter-autocomplete-chips/search-filter-autocomplete-chips.component';
+import { SearchPropertiesComponent } from '../components/search-properties/search-properties.component';
+import { SearchDateRangeTabbedComponent } from '../components/search-date-range-tabbed/search-date-range-tabbed.component';
+import * as i0 from "@angular/core";
+export class SearchFilterService {
+    constructor() {
+        /**
+         * Contains string-to-type mappings for registered widgets.
+         */
+        this.widgets = {
+            text: SearchTextComponent,
+            radio: SearchRadioComponent,
+            slider: SearchSliderComponent,
+            properties: SearchPropertiesComponent,
+            'number-range': SearchNumberRangeComponent,
+            'check-list': SearchCheckListComponent,
+            'datetime-range': SearchDatetimeRangeComponent,
+            'logical-filter': SearchLogicalFilterComponent,
+            'autocomplete-chips': SearchFilterAutocompleteChipsComponent,
+            'date-range': SearchDateRangeTabbedComponent
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchFilterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchFilterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchFilterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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