@alfresco/adf-content-services 8.1.0-15972188736 → 8.1.0-15979090800

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

@@ -0,0 +1,134 @@
+/*!
+ * @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 { map } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { TranslatePipe } from '@ngx-translate/core';
+import { MatInputModule } from '@angular/material/input';
+import { MatButtonModule } from '@angular/material/button';
+import { FormsModule } from '@angular/forms';
+import { MatIconModule } from '@angular/material/icon';
+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/form-field";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/icon";
+export class SearchTextComponent {
+    constructor() {
+        /** The content of the text box. */
+        this.value = '';
+        this.isActive = false;
+        this.enableChangeUpdate = true;
+        this.displayValue$ = new ReplaySubject(1);
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        if (this.context && this.settings?.pattern) {
+            const pattern = new RegExp(this.settings.pattern, 'g');
+            const match = pattern.exec(this.context.queryFragments[this.id] || '');
+            if (this.settings.allowUpdateOnChange !== undefined && this.settings.allowUpdateOnChange !== null) {
+                this.enableChangeUpdate = this.settings.allowUpdateOnChange;
+            }
+            if (match && match.length > 1) {
+                this.value = match[1];
+            }
+            if (this.startValue) {
+                this.setValue(this.startValue);
+            }
+            else {
+                if (this.context?.queryFragments) {
+                    this.context.queryFragments[this.id] = '';
+                }
+            }
+        }
+        this.context.populateFilters
+            .asObservable()
+            .pipe(map((filtersQueries) => filtersQueries[this.id]), takeUntilDestroyed(this.destroyRef))
+            .subscribe((filterQuery) => {
+            if (filterQuery) {
+                this.value = filterQuery;
+                this.updateQuery(this.value, false);
+            }
+            else {
+                this.reset(false);
+            }
+            this.context.filterLoaded.next();
+        });
+    }
+    clear() {
+        this.isActive = false;
+        this.value = '';
+        if (this.enableChangeUpdate) {
+            this.updateQuery(null);
+        }
+    }
+    reset(updateContext = true) {
+        this.value = '';
+        this.updateQuery(null, updateContext);
+    }
+    onChangedHandler(event) {
+        this.value = event.target.value;
+        this.isActive = !!this.value;
+        if (this.enableChangeUpdate) {
+            this.updateQuery(this.value);
+        }
+    }
+    updateQuery(value, updateContext = true) {
+        this.context.filterRawParams[this.id] = value;
+        this.displayValue$.next(value);
+        if (this.context && this.settings && this.settings.field) {
+            this.context.queryFragments[this.id] = value ? `${this.settings.field}:'${this.getSearchPrefix()}${value}${this.getSearchSuffix()}'` : '';
+            if (updateContext) {
+                this.context.update();
+            }
+        }
+    }
+    submitValues() {
+        this.updateQuery(this.value);
+    }
+    hasValidValue() {
+        return !!this.value;
+    }
+    getCurrentValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.value = value;
+        this.displayValue$.next(this.value);
+        this.submitValues();
+    }
+    getSearchPrefix() {
+        return this.settings.searchPrefix ? this.settings.searchPrefix : '';
+    }
+    getSearchSuffix() {
+        return this.settings.searchSuffix ? this.settings.searchSuffix : '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchTextComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchTextComponent, isStandalone: true, selector: "adf-search-text", inputs: { value: "value" }, host: { classAttribute: "adf-search-text" }, ngImport: i0, template: "<mat-form-field\n    class=\"adf-search-text-form-field\"\n    appearance=\"fill\">\n    <mat-label>{{ settings?.placeholder | translate }}</mat-label>\n    <input\n        matInput\n        [(ngModel)]=\"value\"\n        (change)=\"onChangedHandler($event)\">\n    <button\n        mat-icon-button\n        *ngIf=\"value\"\n        matSuffix\n        (click)=\"clear()\"\n        class=\"adf-search-text-form-field-clear-button\">\n        <mat-icon>close</mat-icon>\n    </button>\n</mat-form-field>\n", styles: [".adf-search-text{padding:0}.adf-search-text .adf-search-text-form-field{width:100%}.adf-search-text .adf-search-text-form-field-clear-button{min-width:unset;border-radius:50%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "directive", type: i2.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i3.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i5.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: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i6.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: SearchTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-search-text', standalone: true, imports: [CommonModule, MatFormFieldModule, TranslatePipe, MatInputModule, MatButtonModule, FormsModule, MatIconModule], encapsulation: ViewEncapsulation.None, host: { class: 'adf-search-text' }, template: "<mat-form-field\n    class=\"adf-search-text-form-field\"\n    appearance=\"fill\">\n    <mat-label>{{ settings?.placeholder | translate }}</mat-label>\n    <input\n        matInput\n        [(ngModel)]=\"value\"\n        (change)=\"onChangedHandler($event)\">\n    <button\n        mat-icon-button\n        *ngIf=\"value\"\n        matSuffix\n        (click)=\"clear()\"\n        class=\"adf-search-text-form-field-clear-button\">\n        <mat-icon>close</mat-icon>\n    </button>\n</mat-form-field>\n", styles: [".adf-search-text{padding:0}.adf-search-text .adf-search-text-form-field{width:100%}.adf-search-text .adf-search-text-form-field-clear-button{min-width:unset;border-radius:50%}\n"] }]
+        }], propDecorators: { value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-text.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/search/components/search-text/search-text.component.ts","../../../../../../../../lib/content-services/src/lib/search/components/search-text/search-text.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 { map } from 'rxjs/operators';\nimport { CommonModule } from '@angular/common';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatButtonModule } from '@angular/material/button';\nimport { FormsModule } from '@angular/forms';\nimport { MatIconModule } from '@angular/material/icon';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Component({\n    selector: 'adf-search-text',\n    standalone: true,\n    imports: [CommonModule, MatFormFieldModule, TranslatePipe, MatInputModule, MatButtonModule, FormsModule, MatIconModule],\n    templateUrl: './search-text.component.html',\n    styleUrls: ['./search-text.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-search-text' }\n})\nexport class SearchTextComponent implements SearchWidget, OnInit {\n    /** The content of the text box. */\n    @Input()\n    value = '';\n\n    id: string;\n    settings: SearchWidgetSettings;\n    context: SearchQueryBuilderService;\n    startValue: string;\n    isActive = false;\n    enableChangeUpdate = true;\n    displayValue$ = new ReplaySubject<string>(1);\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    ngOnInit() {\n        if (this.context && this.settings?.pattern) {\n            const pattern = new RegExp(this.settings.pattern, 'g');\n            const match = pattern.exec(this.context.queryFragments[this.id] || '');\n            if (this.settings.allowUpdateOnChange !== undefined && this.settings.allowUpdateOnChange !== null) {\n                this.enableChangeUpdate = this.settings.allowUpdateOnChange;\n            }\n\n            if (match && match.length > 1) {\n                this.value = match[1];\n            }\n\n            if (this.startValue) {\n                this.setValue(this.startValue);\n            } else {\n                if (this.context?.queryFragments) {\n                    this.context.queryFragments[this.id] = '';\n                }\n            }\n        }\n        this.context.populateFilters\n            .asObservable()\n            .pipe(\n                map((filtersQueries) => filtersQueries[this.id]),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((filterQuery) => {\n                if (filterQuery) {\n                    this.value = filterQuery;\n                    this.updateQuery(this.value, false);\n                } else {\n                    this.reset(false);\n                }\n                this.context.filterLoaded.next();\n            });\n    }\n    clear() {\n        this.isActive = false;\n        this.value = '';\n        if (this.enableChangeUpdate) {\n            this.updateQuery(null);\n        }\n    }\n\n    reset(updateContext = true) {\n        this.value = '';\n        this.updateQuery(null, updateContext);\n    }\n\n    onChangedHandler(event) {\n        this.value = event.target.value;\n        this.isActive = !!this.value;\n        if (this.enableChangeUpdate) {\n            this.updateQuery(this.value);\n        }\n    }\n\n    private updateQuery(value: string, updateContext = true) {\n        this.context.filterRawParams[this.id] = value;\n        this.displayValue$.next(value);\n        if (this.context && this.settings && this.settings.field) {\n            this.context.queryFragments[this.id] = value ? `${this.settings.field}:'${this.getSearchPrefix()}${value}${this.getSearchSuffix()}'` : '';\n            if (updateContext) {\n                this.context.update();\n            }\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: string) {\n        this.value = value;\n        this.displayValue$.next(this.value);\n        this.submitValues();\n    }\n\n    private getSearchPrefix(): string {\n        return this.settings.searchPrefix ? this.settings.searchPrefix : '';\n    }\n\n    private getSearchSuffix(): string {\n        return this.settings.searchSuffix ? this.settings.searchSuffix : '';\n    }\n}\n","<mat-form-field\n    class=\"adf-search-text-form-field\"\n    appearance=\"fill\">\n    <mat-label>{{ settings?.placeholder | translate }}</mat-label>\n    <input\n        matInput\n        [(ngModel)]=\"value\"\n        (change)=\"onChangedHandler($event)\">\n    <button\n        mat-icon-button\n        *ngIf=\"value\"\n        matSuffix\n        (click)=\"clear()\"\n        class=\"adf-search-text-form-field-clear-button\">\n        <mat-icon>close</mat-icon>\n    </button>\n</mat-form-field>\n"]}

package/esm2022/lib/search/components/search-widget-container/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-widget-container.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9jb21wb25lbnRzL3NlYXJjaC13aWRnZXQtY29udGFpbmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMscUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXdpZGdldC1jb250YWluZXIuY29tcG9uZW50JztcbiJdfQ==

package/esm2022/lib/search/components/search-widget-container/search-widget-container.component.mjs

@@ -0,0 +1,113 @@
+/*!
+ * @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, ViewChild, ViewContainerRef, Injector } from '@angular/core';
+import { SearchFilterService } from '../../services/search-filter.service';
+import { SearchHeaderQueryBuilderService, SearchQueryBuilderService } from '../../services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/search-filter.service";
+export class SearchWidgetContainerComponent {
+    constructor(searchFilterService, injector) {
+        this.searchFilterService = searchFilterService;
+        this.injector = injector;
+    }
+    ngOnInit() {
+        const componentType = this.searchFilterService.widgets[this.selector];
+        if (componentType) {
+            this.content.clear();
+            this.componentRef = this.content.createComponent(componentType, { index: 0 });
+            this.setupWidget(this.componentRef);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['value']?.currentValue && this.componentRef?.instance) {
+            this.componentRef.instance.isActive = true;
+            this.componentRef.instance.setValue(changes['value'].currentValue);
+        }
+    }
+    setupWidget(ref) {
+        if (ref?.instance) {
+            ref.instance.id = this.id;
+            ref.instance.settings = { ...this.settings };
+            if (this.useHeaderQueryBuilder) {
+                ref.instance.context = this.injector.get(SearchHeaderQueryBuilderService);
+            }
+            else {
+                ref.instance.context = this.injector.get(SearchQueryBuilderService);
+            }
+            if (this.value) {
+                ref.instance.isActive = true;
+                ref.instance.startValue = this.value;
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+    applyInnerWidget() {
+        this.componentRef.instance.submitValues();
+    }
+    setValue(currentValue) {
+        this.componentRef.instance.isActive = true;
+        this.componentRef.instance.setValue(currentValue);
+    }
+    hasValueSelected() {
+        return this.componentRef.instance.hasValidValue();
+    }
+    getCurrentValue() {
+        return this.componentRef.instance.getCurrentValue();
+    }
+    getDisplayValue() {
+        if (!this.componentRef?.instance) {
+            return null;
+        }
+        return this.componentRef.instance.displayValue$;
+    }
+    resetInnerWidget() {
+        if (this.componentRef?.instance) {
+            this.componentRef.instance.reset();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchWidgetContainerComponent, deps: [{ token: i1.SearchFilterService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchWidgetContainerComponent, isStandalone: true, selector: "adf-search-widget-container", inputs: { id: "id", selector: "selector", settings: "settings", config: "config", value: "value", useHeaderQueryBuilder: "useHeaderQueryBuilder" }, viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: '<div #content></div>', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchWidgetContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-search-widget-container',
+                    standalone: true,
+                    template: '<div #content></div>'
+                }]
+        }], ctorParameters: () => [{ type: i1.SearchFilterService }, { type: i0.Injector }], propDecorators: { content: [{
+                type: ViewChild,
+                args: ['content', { read: ViewContainerRef, static: true }]
+            }], id: [{
+                type: Input
+            }], selector: [{
+                type: Input
+            }], settings: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], useHeaderQueryBuilder: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-widget-container.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/search/components/search-widget-container/search-widget-container.component.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 { Component, Input, ViewChild, ViewContainerRef, OnInit, OnDestroy, ComponentRef, SimpleChanges, OnChanges, Injector } from '@angular/core';\nimport { SearchFilterService } from '../../services/search-filter.service';\nimport { Observable } from 'rxjs';\nimport { SearchHeaderQueryBuilderService, SearchQueryBuilderService } from '../../services';\n\n@Component({\n    selector: 'adf-search-widget-container',\n    standalone: true,\n    template: '<div #content></div>'\n})\nexport class SearchWidgetContainerComponent implements OnInit, OnDestroy, OnChanges {\n    @ViewChild('content', { read: ViewContainerRef, static: true })\n    content: ViewContainerRef;\n\n    @Input()\n    id: string;\n\n    @Input()\n    selector: string;\n\n    @Input()\n    settings: any;\n\n    @Input()\n    config: any;\n\n    @Input()\n    value: any;\n\n    @Input()\n    useHeaderQueryBuilder: boolean;\n\n    componentRef: ComponentRef<any>;\n\n    constructor(private searchFilterService: SearchFilterService, private injector: Injector) {}\n\n    ngOnInit() {\n        const componentType = this.searchFilterService.widgets[this.selector];\n        if (componentType) {\n            this.content.clear();\n            this.componentRef = this.content.createComponent(componentType, { index: 0 });\n            this.setupWidget(this.componentRef);\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['value']?.currentValue && this.componentRef?.instance) {\n            this.componentRef.instance.isActive = true;\n            this.componentRef.instance.setValue(changes['value'].currentValue);\n        }\n    }\n\n    private setupWidget(ref: ComponentRef<any>) {\n        if (ref?.instance) {\n            ref.instance.id = this.id;\n            ref.instance.settings = { ...this.settings };\n            if (this.useHeaderQueryBuilder) {\n                ref.instance.context = this.injector.get(SearchHeaderQueryBuilderService);\n            } else {\n                ref.instance.context = this.injector.get(SearchQueryBuilderService);\n            }\n            if (this.value) {\n                ref.instance.isActive = true;\n                ref.instance.startValue = this.value;\n            }\n        }\n    }\n\n    ngOnDestroy() {\n        if (this.componentRef) {\n            this.componentRef.destroy();\n            this.componentRef = null;\n        }\n    }\n\n    applyInnerWidget() {\n        this.componentRef.instance.submitValues();\n    }\n\n    setValue(currentValue: string | any) {\n        this.componentRef.instance.isActive = true;\n        this.componentRef.instance.setValue(currentValue);\n    }\n\n    hasValueSelected() {\n        return this.componentRef.instance.hasValidValue();\n    }\n\n    getCurrentValue() {\n        return this.componentRef.instance.getCurrentValue();\n    }\n\n    getDisplayValue(): Observable<string> | null {\n        if (!this.componentRef?.instance) {\n            return null;\n        }\n        return this.componentRef.instance.displayValue$;\n    }\n\n    resetInnerWidget() {\n        if (this.componentRef?.instance) {\n            this.componentRef.instance.reset();\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,152 @@
+/*!
+ * @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 { SearchService } from '../services/search.service';
+import { Component, ContentChild, ElementRef, EventEmitter, Input, Output, TemplateRef, ViewChild, ViewEncapsulation } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/search.service";
+import * as i2 from "@angular/common";
+export class SearchComponent {
+    /** CSS class for display. */
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    set classList(classList) {
+        if (classList?.length) {
+            classList.split(' ').forEach((className) => (this._classList[className.trim()] = true));
+            this._elementRef.nativeElement.className = '';
+        }
+    }
+    get isOpen() {
+        return this._isOpen && this.showPanel;
+    }
+    set isOpen(value) {
+        this._isOpen = value;
+    }
+    constructor(searchService, _elementRef) {
+        this.searchService = searchService;
+        this._elementRef = _elementRef;
+        /** Function that maps an option's value to its display value in the trigger. */
+        this.displayWith = null;
+        /** Maximum number of results to show in the search. */
+        this.maxResults = 20;
+        /** Number of results to skip from the results pagination. */
+        this.skipResults = 0;
+        /**
+         * Search term to use when executing the search. Updating this value will
+         * run a new search and update the results.
+         */
+        this.searchTerm = '';
+        /** Emitted when search results have fully loaded. */
+        this.resultLoaded = new EventEmitter();
+        /** Emitted when an error occurs. */
+        this.error = new EventEmitter();
+        this.showPanel = false;
+        this._isOpen = false;
+        this.keyPressedStream = new Subject();
+        this._classList = {};
+        this.keyPressedStream.pipe(debounceTime(200), takeUntilDestroyed()).subscribe((searchedWord) => {
+            this.loadSearchResults(searchedWord);
+        });
+        searchService.dataLoaded.pipe(takeUntilDestroyed()).subscribe((nodePaging) => this.onSearchDataLoaded(nodePaging), (error) => this.onSearchDataError(error));
+    }
+    ngAfterContentInit() {
+        this.setVisibility();
+    }
+    ngOnChanges(changes) {
+        if (changes.searchTerm?.currentValue) {
+            this.loadSearchResults(changes.searchTerm.currentValue);
+        }
+    }
+    resetResults() {
+        this.cleanResults();
+        this.setVisibility();
+    }
+    reload() {
+        this.loadSearchResults(this.searchTerm);
+    }
+    cleanResults() {
+        if (this.results) {
+            this.results = {};
+        }
+    }
+    loadSearchResults(searchTerm) {
+        this.resetResults();
+        if (searchTerm) {
+            this.searchService.search(searchTerm, this.maxResults, this.skipResults).subscribe((result) => this.onSearchDataLoaded(result), (err) => this.onSearchDataError(err));
+        }
+        else {
+            this.cleanResults();
+        }
+    }
+    onSearchDataLoaded(resultSetPaging) {
+        if (resultSetPaging) {
+            this.results = resultSetPaging;
+            this.resultLoaded.emit(this.results);
+            this.isOpen = true;
+            this.setVisibility();
+        }
+    }
+    onSearchDataError(error) {
+        if (error?.status !== 400) {
+            this.results = null;
+            this.error.emit(error);
+        }
+    }
+    hidePanel() {
+        if (this.isOpen) {
+            this._classList['adf-search-show'] = false;
+            this._classList['adf-search-hide'] = true;
+            this.isOpen = false;
+        }
+    }
+    setVisibility() {
+        this.showPanel = !!this.results && !!this.results.list;
+        this._classList['adf-search-show'] = this.showPanel;
+        this._classList['adf-search-hide'] = !this.showPanel;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchComponent, deps: [{ token: i1.SearchService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchComponent, isStandalone: true, selector: "adf-search", inputs: { displayWith: "displayWith", maxResults: "maxResults", skipResults: "skipResults", searchTerm: "searchTerm", classList: ["class", "classList"] }, outputs: { resultLoaded: "resultLoaded", error: "error" }, host: { classAttribute: "adf-search" }, queries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true }], viewQueries: [{ propertyName: "panel", first: true, predicate: ["panel"], descendants: true, static: true }], exportAs: ["searchAutocomplete"], usesOnChanges: true, ngImport: i0, template: "<div id=\"adf-search-results-content\" title=\"{{'PERMISSION_MANAGER.ADD-PERMISSION.USER-GROUP-LIST' | translate}}\"\n    [ngClass]=\"_classList\" #panel>\n    <ng-template\n        [ngTemplateOutlet]=\"template\"\n        [ngTemplateOutletContext]=\"{ $implicit: results }\" />\n</div>\n", styles: [".adf-search-hide{visibility:hidden}.adf-search-show{visibility:visible}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-search', standalone: true, imports: [CommonModule, TranslatePipe], encapsulation: ViewEncapsulation.None, preserveWhitespaces: false, exportAs: 'searchAutocomplete', host: { class: 'adf-search' }, template: "<div id=\"adf-search-results-content\" title=\"{{'PERMISSION_MANAGER.ADD-PERMISSION.USER-GROUP-LIST' | translate}}\"\n    [ngClass]=\"_classList\" #panel>\n    <ng-template\n        [ngTemplateOutlet]=\"template\"\n        [ngTemplateOutletContext]=\"{ $implicit: results }\" />\n</div>\n", styles: [".adf-search-hide{visibility:hidden}.adf-search-show{visibility:visible}\n"] }]
+        }], ctorParameters: () => [{ type: i1.SearchService }, { type: i0.ElementRef }], propDecorators: { panel: [{
+                type: ViewChild,
+                args: ['panel', { static: true }]
+            }], template: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }], displayWith: [{
+                type: Input
+            }], maxResults: [{
+                type: Input
+            }], skipResults: [{
+                type: Input
+            }], searchTerm: [{
+                type: Input
+            }], classList: [{
+                type: Input,
+                args: ['class']
+            }], resultLoaded: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.component.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/search/components/search.component.ts","../../../../../../../lib/content-services/src/lib/search/components/search.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 { SearchService } from '../services/search.service';\nimport {\n    AfterContentInit,\n    Component,\n    ContentChild,\n    ElementRef,\n    EventEmitter,\n    Input,\n    OnChanges,\n    Output,\n    SimpleChanges,\n    TemplateRef,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport { NodePaging, ResultSetPaging } from '@alfresco/js-api';\nimport { Subject } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\nimport { SearchComponentInterface } from '@alfresco/adf-core';\nimport { CommonModule } from '@angular/common';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Component({\n    selector: 'adf-search',\n    standalone: true,\n    imports: [CommonModule, TranslatePipe],\n    templateUrl: './search.component.html',\n    styleUrls: ['./search.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    preserveWhitespaces: false,\n    exportAs: 'searchAutocomplete',\n    host: { class: 'adf-search' }\n})\nexport class SearchComponent implements SearchComponentInterface, AfterContentInit, OnChanges {\n    @ViewChild('panel', { static: true })\n    panel: ElementRef;\n\n    @ContentChild(TemplateRef)\n    template: TemplateRef<any>;\n\n    /** Function that maps an option's value to its display value in the trigger. */\n    @Input()\n    displayWith: ((value: any) => string) | null = null;\n\n    /** Maximum number of results to show in the search. */\n    @Input()\n    maxResults: number = 20;\n\n    /** Number of results to skip from the results pagination. */\n    @Input()\n    skipResults: number = 0;\n\n    /**\n     * Search term to use when executing the search. Updating this value will\n     * run a new search and update the results.\n     */\n    @Input()\n    searchTerm: string = '';\n\n    /** CSS class for display. */\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('class')\n    set classList(classList: string) {\n        if (classList?.length) {\n            classList.split(' ').forEach((className) => (this._classList[className.trim()] = true));\n            this._elementRef.nativeElement.className = '';\n        }\n    }\n\n    /** Emitted when search results have fully loaded. */\n    @Output()\n    resultLoaded: EventEmitter<NodePaging> = new EventEmitter();\n\n    /** Emitted when an error occurs. */\n    @Output()\n    error: EventEmitter<any> = new EventEmitter();\n\n    showPanel: boolean = false;\n    results: NodePaging;\n\n    get isOpen(): boolean {\n        return this._isOpen && this.showPanel;\n    }\n\n    set isOpen(value: boolean) {\n        this._isOpen = value;\n    }\n\n    _isOpen: boolean = false;\n    keyPressedStream = new Subject<string>();\n    _classList: { [key: string]: boolean } = {};\n    constructor(private searchService: SearchService, private _elementRef: ElementRef) {\n        this.keyPressedStream.pipe(debounceTime(200), takeUntilDestroyed()).subscribe((searchedWord) => {\n            this.loadSearchResults(searchedWord);\n        });\n\n        searchService.dataLoaded.pipe(takeUntilDestroyed()).subscribe(\n            (nodePaging) => this.onSearchDataLoaded(nodePaging),\n            (error) => this.onSearchDataError(error)\n        );\n    }\n\n    ngAfterContentInit() {\n        this.setVisibility();\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes.searchTerm?.currentValue) {\n            this.loadSearchResults(changes.searchTerm.currentValue);\n        }\n    }\n    resetResults() {\n        this.cleanResults();\n        this.setVisibility();\n    }\n\n    reload() {\n        this.loadSearchResults(this.searchTerm);\n    }\n\n    private cleanResults() {\n        if (this.results) {\n            this.results = {};\n        }\n    }\n\n    private loadSearchResults(searchTerm?: string) {\n        this.resetResults();\n        if (searchTerm) {\n            this.searchService.search(searchTerm, this.maxResults, this.skipResults).subscribe(\n                (result) => this.onSearchDataLoaded(result),\n                (err) => this.onSearchDataError(err)\n            );\n        } else {\n            this.cleanResults();\n        }\n    }\n\n    onSearchDataLoaded(resultSetPaging: ResultSetPaging) {\n        if (resultSetPaging) {\n            this.results = resultSetPaging as NodePaging;\n            this.resultLoaded.emit(this.results);\n            this.isOpen = true;\n            this.setVisibility();\n        }\n    }\n\n    onSearchDataError(error: { status: number }) {\n        if (error?.status !== 400) {\n            this.results = null;\n            this.error.emit(error);\n        }\n    }\n\n    hidePanel() {\n        if (this.isOpen) {\n            this._classList['adf-search-show'] = false;\n            this._classList['adf-search-hide'] = true;\n            this.isOpen = false;\n        }\n    }\n\n    setVisibility() {\n        this.showPanel = !!this.results && !!this.results.list;\n        this._classList['adf-search-show'] = this.showPanel;\n        this._classList['adf-search-hide'] = !this.showPanel;\n    }\n}\n","<div id=\"adf-search-results-content\" title=\"{{'PERMISSION_MANAGER.ADD-PERMISSION.USER-GROUP-LIST' | translate}}\"\n    [ngClass]=\"_classList\" #panel>\n    <ng-template\n        [ngTemplateOutlet]=\"template\"\n        [ngTemplateOutletContext]=\"{ $implicit: results }\" />\n</div>\n"]}

package/esm2022/lib/search/forms/index.mjs

@@ -0,0 +1,19 @@
+/*!
+ * @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 './live-error-state-matcher';
+export * from './search-term-validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9mb3Jtcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGl2ZS1lcnJvci1zdGF0ZS1tYXRjaGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXRlcm0tdmFsaWRhdG9yJztcbiJdfQ==

package/esm2022/lib/search/forms/live-error-state-matcher.mjs

@@ -0,0 +1,23 @@
+/*!
+ * @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 class LiveErrorStateMatcher {
+    isErrorState(control, form) {
+        const isSubmitted = form?.submitted;
+        return !!(control?.invalid && (control.dirty || control.touched || (!control.pristine && isSubmitted)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/forms/search-term-validator.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @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 class SearchTermValidator {
+    static minAlphanumericChars(minChars) {
+        return (control) => ('' + control.value).replace(/[^0-9a-zA-Z]+/g, '').length >= minChars
+            ? null
+            : {
+                hasMinAlphanumericChars: false
+            };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/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 './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/search/mocks/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.service.mock';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3NlYXJjaC9tb2Nrcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC5zZXJ2aWNlLm1vY2snO1xuIl19