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

package/esm2022/lib/search/components/search-radio/search-radio.component.mjs

@@ -0,0 +1,145 @@
+/*!
+ * @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 { Component, Input, ViewEncapsulation } from '@angular/core';
+import { MatRadioModule } from '@angular/material/radio';
+import { SearchFilterList } from '../../models/search-filter-list.model';
+import { ReplaySubject } from 'rxjs';
+import { first } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { TranslatePipe } from '@ngx-translate/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/radio";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+export class SearchRadioComponent {
+    constructor() {
+        this.pageSize = 5;
+        this.isActive = false;
+        this.displayValue$ = new ReplaySubject(1);
+        this.options = new SearchFilterList();
+    }
+    ngOnInit() {
+        if (this.settings) {
+            this.pageSize = this.settings.pageSize || 5;
+            if (this.settings.options && this.settings.options.length > 0) {
+                this.options = new SearchFilterList(this.settings.options, this.pageSize);
+            }
+        }
+        const initialValue = this.getSelectedValue();
+        if (initialValue !== null) {
+            this.value = initialValue;
+            this.context.queryFragments[this.id] = initialValue;
+        }
+        else if (this.startValue !== null) {
+            this.value = initialValue;
+            this.context.queryFragments[this.id] = initialValue;
+        }
+        this.enableChangeUpdate = this.settings.allowUpdateOnChange ?? true;
+        this.updateDisplayValue();
+        this.context.populateFilters
+            .asObservable()
+            .pipe(first())
+            .subscribe((filtersQueries) => {
+            if (filtersQueries[this.id]) {
+                this.value = filtersQueries[this.id];
+                this.submitValues(false);
+            }
+            else {
+                this.reset(false);
+            }
+            this.context.filterLoaded.next();
+        });
+    }
+    getSelectedValue() {
+        const options = this.settings['options'] || [];
+        if (options && options.length > 0) {
+            this.isActive = true;
+            let selected = options.find((opt) => opt.default);
+            if (!selected) {
+                selected = options[0];
+            }
+            return selected.value;
+        }
+        return null;
+    }
+    submitValues(updateContext = true) {
+        this.setValue(this.value);
+        this.updateDisplayValue();
+        if (updateContext) {
+            this.context.update();
+        }
+    }
+    hasValidValue() {
+        const currentValue = this.getSelectedValue();
+        return !!currentValue;
+    }
+    setValue(newValue) {
+        this.value = newValue;
+        this.context.queryFragments[this.id] = newValue;
+        this.context.filterRawParams[this.id] = newValue;
+        if (this.enableChangeUpdate) {
+            this.updateDisplayValue();
+            this.context.update();
+        }
+    }
+    getCurrentValue() {
+        return this.getSelectedValue();
+    }
+    updateDisplayValue() {
+        const selectOptions = this.options.items.find(({ value }) => value === this.value);
+        if (selectOptions) {
+            this.displayValue$.next(selectOptions.name);
+        }
+        else {
+            this.displayValue$.next('');
+        }
+    }
+    changeHandler(event) {
+        this.setValue(event.value);
+    }
+    clear() {
+        this.isActive = false;
+        const initialValue = this.getSelectedValue();
+        if (initialValue !== null) {
+            this.setValue(initialValue);
+        }
+    }
+    reset(updateContext = true) {
+        const initialValue = this.getSelectedValue();
+        if (initialValue !== null) {
+            this.setValue(initialValue);
+            this.updateDisplayValue();
+            if (updateContext) {
+                this.context.update();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchRadioComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchRadioComponent, isStandalone: true, selector: "adf-search-radio", inputs: { value: "value" }, host: { classAttribute: "adf-search-radio" }, ngImport: i0, template: "<mat-radio-group\n    class=\"adf-search-radio-group\"\n    [(ngModel)]=\"value\"\n    (change)=\"changeHandler($event)\">\n    <mat-radio-button [attr.data-automation-id]=\"'search-radio-'+(option.name | translate)\"\n        *ngFor=\"let option of options\"\n        [value]=\"option.value\"\n        class=\"adf-facet-filter\">\n        <div title=\"{{ option.name | translate }}\" class=\"adf-filter-label\">\n            {{ option.name | translate }}\n        </div>\n    </mat-radio-button>\n</mat-radio-group>\n\n<div class=\"adf-facet-buttons\" *ngIf=\"!options.fitsPage\">\n    <button mat-icon-button\n        *ngIf=\"options.canShowLessItems\"\n        title=\"{{ 'SEARCH.FILTER.ACTIONS.SHOW-LESS' | translate }}\"\n        (click)=\"options.showLessItems()\">\n        <mat-icon>keyboard_arrow_up</mat-icon>\n    </button>\n    <button mat-icon-button\n        *ngIf=\"options.canShowMoreItems\"\n        title=\"{{ 'SEARCH.FILTER.ACTIONS.SHOW-MORE' | translate }}\"\n        (click)=\"options.showMoreItems()\">\n        <mat-icon>keyboard_arrow_down</mat-icon>\n    </button>\n</div>\n", styles: [".adf-search-radio .adf-search-radio-group{display:flex;flex-direction:column}.adf-search-radio .adf-facet-filter{margin:5px}.adf-search-radio .adf-facet-filter .adf-filter-label{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatRadioModule }, { kind: "directive", type: i2.MatRadioGroup, selector: "mat-radio-group", inputs: ["color", "name", "labelPosition", "value", "selected", "disabled", "required", "disabledInteractive"], outputs: ["change"], exportAs: ["matRadioGroup"] }, { kind: "component", type: i2.MatRadioButton, selector: "mat-radio-button", inputs: ["id", "name", "aria-label", "aria-labelledby", "aria-describedby", "disableRipple", "tabIndex", "checked", "value", "labelPosition", "disabled", "required", "color", "disabledInteractive"], outputs: ["change"], exportAs: ["matRadioButton"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchRadioComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-search-radio', standalone: true, imports: [CommonModule, MatRadioModule, FormsModule, TranslatePipe, MatButtonModule, MatIconModule], encapsulation: ViewEncapsulation.None, host: { class: 'adf-search-radio' }, template: "<mat-radio-group\n    class=\"adf-search-radio-group\"\n    [(ngModel)]=\"value\"\n    (change)=\"changeHandler($event)\">\n    <mat-radio-button [attr.data-automation-id]=\"'search-radio-'+(option.name | translate)\"\n        *ngFor=\"let option of options\"\n        [value]=\"option.value\"\n        class=\"adf-facet-filter\">\n        <div title=\"{{ option.name | translate }}\" class=\"adf-filter-label\">\n            {{ option.name | translate }}\n        </div>\n    </mat-radio-button>\n</mat-radio-group>\n\n<div class=\"adf-facet-buttons\" *ngIf=\"!options.fitsPage\">\n    <button mat-icon-button\n        *ngIf=\"options.canShowLessItems\"\n        title=\"{{ 'SEARCH.FILTER.ACTIONS.SHOW-LESS' | translate }}\"\n        (click)=\"options.showLessItems()\">\n        <mat-icon>keyboard_arrow_up</mat-icon>\n    </button>\n    <button mat-icon-button\n        *ngIf=\"options.canShowMoreItems\"\n        title=\"{{ 'SEARCH.FILTER.ACTIONS.SHOW-MORE' | translate }}\"\n        (click)=\"options.showMoreItems()\">\n        <mat-icon>keyboard_arrow_down</mat-icon>\n    </button>\n</div>\n", styles: [".adf-search-radio .adf-search-radio-group{display:flex;flex-direction:column}.adf-search-radio .adf-facet-filter{margin:5px}.adf-search-radio .adf-facet-filter .adf-filter-label{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-radio.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/search/components/search-radio/search-radio.component.ts","../../../../../../../../lib/content-services/src/lib/search/components/search-radio/search-radio.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAkB,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAKzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;;;;;;;AAgBvD,MAAM,OAAO,oBAAoB;IAe7B;QANA,aAAQ,GAAG,CAAC,CAAC;QACb,aAAQ,GAAG,KAAK,CAAC;QAGjB,kBAAa,GAAG,IAAI,aAAa,CAAS,CAAC,CAAC,CAAC;QAGzC,IAAI,CAAC,OAAO,GAAG,IAAI,gBAAgB,EAAqB,CAAC;IAC7D,CAAC;IAED,QAAQ;QACJ,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAC,CAAC;YAE5C,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5D,IAAI,CAAC,OAAO,GAAG,IAAI,gBAAgB,CAAoB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YACjG,CAAC;QACL,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE7C,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YACxB,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;YAC1B,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC;QACxD,CAAC;aAAM,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAClC,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;YAC1B,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,IAAI,IAAI,CAAC;QACpE,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,eAAe;aACvB,YAAY,EAAE;aACd,IAAI,CAAC,KAAK,EAAE,CAAC;aACb,SAAS,CAAC,CAAC,cAAc,EAAE,EAAE;YAC1B,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;gBAC1B,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBACrC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QACrC,CAAC,CAAC,CAAC;IACX,CAAC;IAEO,gBAAgB;QACpB,MAAM,OAAO,GAAU,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtD,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YAErB,IAAI,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAClD,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACZ,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC1B,CAAC;YACD,OAAO,QAAQ,CAAC,KAAK,CAAC;QAC1B,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,YAAY,CAAC,aAAa,GAAG,IAAI;QAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,aAAa,EAAE,CAAC;YAChB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAC1B,CAAC;IACL,CAAC;IAED,aAAa;QACT,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC7C,OAAO,CAAC,CAAC,YAAY,CAAC;IAC1B,CAAC;IAED,QAAQ,CAAC,QAAgB;QACrB,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QACtB,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC;QACjD,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAC1B,CAAC;IACL,CAAC;IAED,eAAe;QACX,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACnC,CAAC;IAED,kBAAkB;QACd,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC;QACnF,IAAI,aAAa,EAAE,CAAC;YAChB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChC,CAAC;IACL,CAAC;IAED,aAAa,CAAC,KAAqB;QAC/B,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,KAAK;QACD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC7C,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YACxB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,aAAa,GAAG,IAAI;QACtB,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC7C,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YACxB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;YAC5B,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,aAAa,EAAE,CAAC;gBAChB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YAC1B,CAAC;QACL,CAAC;IACL,CAAC;+GA5HQ,oBAAoB;mGAApB,oBAAoB,sJC9CjC,6kCA4BA,uSDYc,YAAY,+PAAE,cAAc,olBAAE,WAAW,0VAAE,aAAa,iDAAE,eAAe,2IAAE,aAAa;;4FAMzF,oBAAoB;kBAThC,SAAS;+BACI,kBAAkB,cAChB,IAAI,WACP,CAAC,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,CAAC,iBAGpF,iBAAiB,CAAC,IAAI,QAC/B,EAAE,KAAK,EAAE,kBAAkB,EAAE;wDAKnC,KAAK;sBADJ,KAAK","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 { Component, Input, OnInit, ViewEncapsulation } from '@angular/core';\nimport { MatRadioChange, MatRadioModule } from '@angular/material/radio';\n\nimport { SearchWidget } from '../../models/search-widget.interface';\nimport { SearchWidgetSettings } from '../../models/search-widget-settings.interface';\nimport { SearchQueryBuilderService } from '../../services/search-query-builder.service';\nimport { SearchFilterList } from '../../models/search-filter-list.model';\nimport { ReplaySubject } from 'rxjs';\nimport { first } from 'rxjs/operators';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\n\nexport interface SearchRadioOption {\n    name: string;\n    value: string;\n}\n\n@Component({\n    selector: 'adf-search-radio',\n    standalone: true,\n    imports: [CommonModule, MatRadioModule, FormsModule, TranslatePipe, MatButtonModule, MatIconModule],\n    templateUrl: './search-radio.component.html',\n    styleUrls: ['./search-radio.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-search-radio' }\n})\nexport class SearchRadioComponent implements SearchWidget, OnInit {\n    /** The value of the selected radio button. */\n    @Input()\n    value: string;\n\n    id: string;\n    settings: SearchWidgetSettings;\n    context: SearchQueryBuilderService;\n    options: SearchFilterList<SearchRadioOption>;\n    pageSize = 5;\n    isActive = false;\n    startValue: any;\n    enableChangeUpdate: boolean;\n    displayValue$ = new ReplaySubject<string>(1);\n\n    constructor() {\n        this.options = new SearchFilterList<SearchRadioOption>();\n    }\n\n    ngOnInit() {\n        if (this.settings) {\n            this.pageSize = this.settings.pageSize || 5;\n\n            if (this.settings.options && this.settings.options.length > 0) {\n                this.options = new SearchFilterList<SearchRadioOption>(this.settings.options, this.pageSize);\n            }\n        }\n\n        const initialValue = this.getSelectedValue();\n\n        if (initialValue !== null) {\n            this.value = initialValue;\n            this.context.queryFragments[this.id] = initialValue;\n        } else if (this.startValue !== null) {\n            this.value = initialValue;\n            this.context.queryFragments[this.id] = initialValue;\n        }\n        this.enableChangeUpdate = this.settings.allowUpdateOnChange ?? true;\n        this.updateDisplayValue();\n        this.context.populateFilters\n            .asObservable()\n            .pipe(first())\n            .subscribe((filtersQueries) => {\n                if (filtersQueries[this.id]) {\n                    this.value = filtersQueries[this.id];\n                    this.submitValues(false);\n                } else {\n                    this.reset(false);\n                }\n                this.context.filterLoaded.next();\n            });\n    }\n\n    private getSelectedValue(): string {\n        const options: any[] = this.settings['options'] || [];\n        if (options && options.length > 0) {\n            this.isActive = true;\n\n            let selected = options.find((opt) => opt.default);\n            if (!selected) {\n                selected = options[0];\n            }\n            return selected.value;\n        }\n        return null;\n    }\n\n    submitValues(updateContext = true) {\n        this.setValue(this.value);\n        this.updateDisplayValue();\n        if (updateContext) {\n            this.context.update();\n        }\n    }\n\n    hasValidValue() {\n        const currentValue = this.getSelectedValue();\n        return !!currentValue;\n    }\n\n    setValue(newValue: string) {\n        this.value = newValue;\n        this.context.queryFragments[this.id] = newValue;\n        this.context.filterRawParams[this.id] = newValue;\n        if (this.enableChangeUpdate) {\n            this.updateDisplayValue();\n            this.context.update();\n        }\n    }\n\n    getCurrentValue() {\n        return this.getSelectedValue();\n    }\n\n    updateDisplayValue(): void {\n        const selectOptions = this.options.items.find(({ value }) => value === this.value);\n        if (selectOptions) {\n            this.displayValue$.next(selectOptions.name);\n        } else {\n            this.displayValue$.next('');\n        }\n    }\n\n    changeHandler(event: MatRadioChange) {\n        this.setValue(event.value);\n    }\n\n    clear() {\n        this.isActive = false;\n        const initialValue = this.getSelectedValue();\n        if (initialValue !== null) {\n            this.setValue(initialValue);\n        }\n    }\n\n    reset(updateContext = true) {\n        const initialValue = this.getSelectedValue();\n        if (initialValue !== null) {\n            this.setValue(initialValue);\n            this.updateDisplayValue();\n            if (updateContext) {\n                this.context.update();\n            }\n        }\n    }\n}\n","<mat-radio-group\n    class=\"adf-search-radio-group\"\n    [(ngModel)]=\"value\"\n    (change)=\"changeHandler($event)\">\n    <mat-radio-button [attr.data-automation-id]=\"'search-radio-'+(option.name | translate)\"\n        *ngFor=\"let option of options\"\n        [value]=\"option.value\"\n        class=\"adf-facet-filter\">\n        <div title=\"{{ option.name | translate }}\" class=\"adf-filter-label\">\n            {{ option.name | translate }}\n        </div>\n    </mat-radio-button>\n</mat-radio-group>\n\n<div class=\"adf-facet-buttons\" *ngIf=\"!options.fitsPage\">\n    <button mat-icon-button\n        *ngIf=\"options.canShowLessItems\"\n        title=\"{{ 'SEARCH.FILTER.ACTIONS.SHOW-LESS' | translate }}\"\n        (click)=\"options.showLessItems()\">\n        <mat-icon>keyboard_arrow_up</mat-icon>\n    </button>\n    <button mat-icon-button\n        *ngIf=\"options.canShowMoreItems\"\n        title=\"{{ 'SEARCH.FILTER.ACTIONS.SHOW-MORE' | translate }}\"\n        (click)=\"options.showMoreItems()\">\n        <mat-icon>keyboard_arrow_down</mat-icon>\n    </button>\n</div>\n"]}

package/esm2022/lib/search/components/search-slider/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export * from './search-slider.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9jb21wb25lbnRzL3NlYXJjaC1zbGlkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtc2xpZGVyLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/lib/search/components/search-slider/search-slider.component.mjs

@@ -0,0 +1,119 @@
+/*!
+ * @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 { Component, DestroyRef, inject, Input, ViewEncapsulation } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { CommonModule } from '@angular/common';
+import { MatSliderModule } from '@angular/material/slider';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { TranslatePipe } from '@ngx-translate/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/slider";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/button";
+export class SearchSliderComponent {
+    constructor() {
+        this.thumbLabel = false;
+        this.displayValue$ = new ReplaySubject(1);
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        if (this.settings) {
+            if (Object.prototype.hasOwnProperty.call(this.settings, 'min')) {
+                this.min = this.settings['min'];
+            }
+            if (Object.prototype.hasOwnProperty.call(this.settings, 'max')) {
+                this.max = this.settings['max'];
+            }
+            if (Object.prototype.hasOwnProperty.call(this.settings, 'step')) {
+                this.step = this.settings['step'];
+            }
+            this.thumbLabel = this.settings['thumbLabel'] ? true : false;
+            this.enableChangeUpdate = this.settings.allowUpdateOnChange ?? true;
+        }
+        if (this.startValue) {
+            this.setValue(this.startValue);
+        }
+        this.context.populateFilters
+            .asObservable()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((filtersQueries) => {
+            if (filtersQueries[this.id]) {
+                this.value = filtersQueries[this.id];
+                this.updateQuery(this.value, false);
+            }
+            else {
+                this.reset(false);
+            }
+            this.context.filterLoaded.next();
+        });
+    }
+    clear() {
+        this.value = this.min || 0;
+        if (this.enableChangeUpdate) {
+            this.updateQuery(null);
+        }
+    }
+    reset(updateContext = true) {
+        this.value = this.min || 0;
+        this.updateQuery(null, updateContext);
+    }
+    onChangedHandler() {
+        if (this.enableChangeUpdate) {
+            this.updateQuery(this.value);
+        }
+    }
+    submitValues() {
+        this.updateQuery(this.value);
+    }
+    hasValidValue() {
+        return !!this.value;
+    }
+    getCurrentValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.value = value;
+        this.submitValues();
+    }
+    updateQuery(value, updateContext = true) {
+        this.context.filterRawParams[this.id] = value;
+        this.displayValue$.next(this.value ? `${this.value} ${this.settings.unit ?? ''}` : '');
+        if (this.id && this.context && this.settings && this.settings.field) {
+            if (value === null) {
+                this.context.queryFragments[this.id] = '';
+            }
+            else {
+                this.context.queryFragments[this.id] = `${this.settings.field}:[0 TO ${value}]`;
+            }
+            if (updateContext) {
+                this.context.update();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchSliderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchSliderComponent, isStandalone: true, selector: "adf-search-slider", inputs: { value: "value" }, host: { classAttribute: "adf-search-slider" }, ngImport: i0, template: "<mat-slider\n    class=\"adf-search-slider\"\n    data-automation-id=\"slider-range\"\n    [max]=\"max\"\n    [min]=\"min\"\n    [step]=\"step\"\n    [discrete]=\"thumbLabel\">\n    <input matSliderThumb (change)=\"onChangedHandler()\" [(ngModel)]=\"value\">\n</mat-slider>\n\n<div class=\"adf-facet-buttons\" *ngIf=\"!settings?.hideDefaultAction\">\n    <button mat-button color=\"primary\" (click)=\"clear()\" data-automation-id=\"slider-btn-clear\">\n        {{ 'SEARCH.FILTER.ACTIONS.CLEAR' | translate }}\n    </button>\n</div>\n", styles: [".adf-search-slider{width:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatSliderModule }, { kind: "component", type: i2.MatSlider, selector: "mat-slider", inputs: ["disabled", "discrete", "showTickMarks", "min", "color", "disableRipple", "max", "step", "displayWith"], exportAs: ["matSlider"] }, { kind: "directive", type: i2.MatSliderThumb, selector: "input[matSliderThumb]", inputs: ["value"], outputs: ["valueChange", "dragStart", "dragEnd"], exportAs: ["matSliderThumb"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchSliderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-search-slider', standalone: true, imports: [CommonModule, MatSliderModule, FormsModule, MatButtonModule, TranslatePipe], encapsulation: ViewEncapsulation.None, host: { class: 'adf-search-slider' }, template: "<mat-slider\n    class=\"adf-search-slider\"\n    data-automation-id=\"slider-range\"\n    [max]=\"max\"\n    [min]=\"min\"\n    [step]=\"step\"\n    [discrete]=\"thumbLabel\">\n    <input matSliderThumb (change)=\"onChangedHandler()\" [(ngModel)]=\"value\">\n</mat-slider>\n\n<div class=\"adf-facet-buttons\" *ngIf=\"!settings?.hideDefaultAction\">\n    <button mat-button color=\"primary\" (click)=\"clear()\" data-automation-id=\"slider-btn-clear\">\n        {{ 'SEARCH.FILTER.ACTIONS.CLEAR' | translate }}\n    </button>\n</div>\n", styles: [".adf-search-slider{width:100%}\n"] }]
+        }], propDecorators: { value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-slider.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/search/components/search-slider/search-slider.component.ts","../../../../../../../../lib/content-services/src/lib/search/components/search-slider/search-slider.component.html"],"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 { Component, DestroyRef, inject, Input, OnInit, ViewEncapsulation } from '@angular/core';\nimport { SearchWidget } from '../../models/search-widget.interface';\nimport { SearchWidgetSettings } from '../../models/search-widget-settings.interface';\nimport { SearchQueryBuilderService } from '../../services/search-query-builder.service';\nimport { ReplaySubject } from 'rxjs';\nimport { CommonModule } from '@angular/common';\nimport { MatSliderModule } from '@angular/material/slider';\nimport { FormsModule } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Component({\n    selector: 'adf-search-slider',\n    standalone: true,\n    imports: [CommonModule, MatSliderModule, FormsModule, MatButtonModule, TranslatePipe],\n    templateUrl: './search-slider.component.html',\n    styleUrls: ['./search-slider.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-search-slider' }\n})\nexport class SearchSliderComponent implements SearchWidget, OnInit {\n    /** The numeric value represented by the slider. */\n    @Input()\n    value: number | null;\n\n    isActive?: boolean;\n    startValue: any;\n\n    id: string;\n    settings: SearchWidgetSettings;\n    context: SearchQueryBuilderService;\n    step: number;\n    min: number;\n    max: number;\n    thumbLabel = false;\n    enableChangeUpdate: boolean;\n    displayValue$ = new ReplaySubject<string>(1);\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    ngOnInit() {\n        if (this.settings) {\n            if (Object.prototype.hasOwnProperty.call(this.settings, 'min')) {\n                this.min = this.settings['min'];\n            }\n\n            if (Object.prototype.hasOwnProperty.call(this.settings, 'max')) {\n                this.max = this.settings['max'];\n            }\n\n            if (Object.prototype.hasOwnProperty.call(this.settings, 'step')) {\n                this.step = this.settings['step'];\n            }\n\n            this.thumbLabel = this.settings['thumbLabel'] ? true : false;\n            this.enableChangeUpdate = this.settings.allowUpdateOnChange ?? true;\n        }\n\n        if (this.startValue) {\n            this.setValue(this.startValue);\n        }\n        this.context.populateFilters\n            .asObservable()\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe((filtersQueries) => {\n                if (filtersQueries[this.id]) {\n                    this.value = filtersQueries[this.id];\n                    this.updateQuery(this.value, false);\n                } else {\n                    this.reset(false);\n                }\n                this.context.filterLoaded.next();\n            });\n    }\n\n    clear() {\n        this.value = this.min || 0;\n        if (this.enableChangeUpdate) {\n            this.updateQuery(null);\n        }\n    }\n\n    reset(updateContext = true) {\n        this.value = this.min || 0;\n        this.updateQuery(null, updateContext);\n    }\n\n    onChangedHandler() {\n        if (this.enableChangeUpdate) {\n            this.updateQuery(this.value);\n        }\n    }\n\n    submitValues() {\n        this.updateQuery(this.value);\n    }\n\n    hasValidValue() {\n        return !!this.value;\n    }\n\n    getCurrentValue() {\n        return this.value;\n    }\n\n    setValue(value: any) {\n        this.value = value;\n        this.submitValues();\n    }\n\n    private updateQuery(value: number | null, updateContext = true) {\n        this.context.filterRawParams[this.id] = value;\n        this.displayValue$.next(this.value ? `${this.value} ${this.settings.unit ?? ''}` : '');\n        if (this.id && this.context && this.settings && this.settings.field) {\n            if (value === null) {\n                this.context.queryFragments[this.id] = '';\n            } else {\n                this.context.queryFragments[this.id] = `${this.settings.field}:[0 TO ${value}]`;\n            }\n            if (updateContext) {\n                this.context.update();\n            }\n        }\n    }\n}\n","<mat-slider\n    class=\"adf-search-slider\"\n    data-automation-id=\"slider-range\"\n    [max]=\"max\"\n    [min]=\"min\"\n    [step]=\"step\"\n    [discrete]=\"thumbLabel\">\n    <input matSliderThumb (change)=\"onChangedHandler()\" [(ngModel)]=\"value\">\n</mat-slider>\n\n<div class=\"adf-facet-buttons\" *ngIf=\"!settings?.hideDefaultAction\">\n    <button mat-button color=\"primary\" (click)=\"clear()\" data-automation-id=\"slider-btn-clear\">\n        {{ 'SEARCH.FILTER.ACTIONS.CLEAR' | translate }}\n    </button>\n</div>\n"]}

package/esm2022/lib/search/components/search-sorting-picker/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export * from './search-sorting-picker.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9jb21wb25lbnRzL3NlYXJjaC1zb3J0aW5nLXBpY2tlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1zb3J0aW5nLXBpY2tlci5jb21wb25lbnQnO1xuIl19

package/esm2022/lib/search/components/search-sorting-picker/search-sorting-picker.component.mjs

@@ -0,0 +1,77 @@
+/*!
+ * @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 { Component, ViewEncapsulation } from '@angular/core';
+import { SearchQueryBuilderService } from '../../services/search-query-builder.service';
+import { CommonModule } from '@angular/common';
+import { SortingPickerComponent } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/search-query-builder.service";
+export class SearchSortingPickerComponent {
+    constructor(queryBuilder) {
+        this.queryBuilder = queryBuilder;
+        this.options = [];
+    }
+    ngOnInit() {
+        this.options = this.queryBuilder.getSortingOptions();
+        const primary = this.queryBuilder.getPrimarySorting();
+        if (primary) {
+            this.value = primary.key;
+            this.ascending = primary.ascending;
+        }
+    }
+    onValueChanged(key) {
+        this.value = key;
+        this.ascending = this.getSortingOrder();
+        this.applySorting();
+    }
+    onSortingChanged(ascending) {
+        this.ascending = ascending;
+        this.applySorting();
+    }
+    findOptionByKey(key) {
+        if (key) {
+            return this.options.find((opt) => opt.key === key);
+        }
+        return null;
+    }
+    applySorting() {
+        const option = this.findOptionByKey(this.value);
+        if (option) {
+            this.queryBuilder.sorting = [
+                {
+                    ...option,
+                    ascending: this.ascending
+                }
+            ];
+            this.queryBuilder.update();
+        }
+    }
+    getSortingOrder() {
+        const option = this.findOptionByKey(this.value);
+        if (option) {
+            return option.ascending;
+        }
+        return this.queryBuilder.getPrimarySorting().ascending;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchSortingPickerComponent, deps: [{ token: i1.SearchQueryBuilderService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchSortingPickerComponent, isStandalone: true, selector: "adf-search-sorting-picker", host: { classAttribute: "adf-search-sorting-picker" }, ngImport: i0, template: "<adf-sorting-picker\n    [options]=\"options\"\n    [selected]=\"value\"\n    [ascending]=\"ascending\"\n    (valueChange)=\"onValueChanged($event)\"\n    (sortingChange)=\"onSortingChanged($event)\" />\n", styles: [".adf-search-sorting-picker .adf-sorting-picker-button{color:var(--adf-theme-foreground-text-color-054)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: SortingPickerComponent, selector: "adf-sorting-picker", inputs: ["options", "selected", "ascending"], outputs: ["valueChange", "sortingChange"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchSortingPickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-search-sorting-picker', standalone: true, imports: [CommonModule, SortingPickerComponent], encapsulation: ViewEncapsulation.None, host: { class: 'adf-search-sorting-picker' }, template: "<adf-sorting-picker\n    [options]=\"options\"\n    [selected]=\"value\"\n    [ascending]=\"ascending\"\n    (valueChange)=\"onValueChanged($event)\"\n    (sortingChange)=\"onSortingChanged($event)\" />\n", styles: [".adf-search-sorting-picker .adf-sorting-picker-button{color:var(--adf-theme-foreground-text-color-054)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.SearchQueryBuilderService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/components/search-text/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export * from './search-text.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9jb21wb25lbnRzL3NlYXJjaC10ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXRleHQuY29tcG9uZW50JztcbiJdfQ==