@alfresco/adf-process-services-cloud 8.1.0-15730481703 → 8.1.0-15782677066

package/esm2022/lib/form/components/widgets/dropdown/dropdown-cloud.widget.mjs

@@ -0,0 +1,464 @@
+/*!
+ * @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 { AppConfigService, ErrorMessageModel, ErrorWidgetComponent, FormFieldEvent, FormFieldTypes, FormService, SelectFilterInputComponent, WidgetComponent } from '@alfresco/adf-core';
+import { AsyncPipe, NgFor, NgIf } from '@angular/common';
+import { Component, DestroyRef, inject, ViewEncapsulation } from '@angular/core';
+import { FormControl, ReactiveFormsModule, Validators } from '@angular/forms';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatSelectModule } from '@angular/material/select';
+import { TranslateModule } from '@ngx-translate/core';
+import { BehaviorSubject } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { FormCloudService } from '../../../services/form-cloud.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { FormUtilsService } from '../../../services/form-utils.service';
+import { defaultValueValidator } from './validators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/select";
+import * as i4 from "@angular/material/core";
+import * as i5 from "@ngx-translate/core";
+export const DEFAULT_OPTION = {
+    id: 'empty',
+    name: 'Choose one...'
+};
+export const HIDE_FILTER_LIMIT = 5;
+/* eslint-disable @angular-eslint/component-selector */
+export class DropdownCloudWidgetComponent extends WidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.formService = inject(FormService);
+        this.formCloudService = inject(FormCloudService);
+        this.appConfig = inject(AppConfigService);
+        this.formUtilsService = inject(FormUtilsService);
+        this.destroyRef = inject(DestroyRef);
+        this.typeId = 'DropdownCloudWidgetComponent';
+        this.showInputFilter = false;
+        this.isRestApiFailed = false;
+        this.variableOptionsFailed = false;
+        this.previewState = false;
+        this.dropdownControl = new FormControl(undefined);
+        this.list$ = new BehaviorSubject([]);
+        this.filter$ = new BehaviorSubject('');
+        this.defaultVariableOptionId = 'id';
+        this.defaultVariableOptionLabel = 'name';
+        this.defaultVariableOptionPath = 'data';
+    }
+    get showRequiredMessage() {
+        return this.dropdownControl.touched && this.dropdownControl.errors?.required && !this.isRestApiFailed && !this.variableOptionsFailed;
+    }
+    get isReadOnlyType() {
+        return this.field.type === 'readonly';
+    }
+    get isLinkedWidget() {
+        return !!this.linkedWidgetId;
+    }
+    get linkedWidgetId() {
+        return this.field?.rule?.ruleOn;
+    }
+    get isReadOnlyForm() {
+        return !!this.field?.form?.readOnly;
+    }
+    get hasRestUrl() {
+        return !!this.field?.restUrl;
+    }
+    get isValidRestConfig() {
+        return this.isRestOptionType && this.hasRestUrl;
+    }
+    get isRestOptionType() {
+        return this.field?.optionType === 'rest';
+    }
+    get isVariableOptionType() {
+        return this.field?.optionType === 'variable';
+    }
+    ngOnInit() {
+        this.setupDropdown();
+        this.formService.onFormVariableChanged.subscribe(({ field }) => {
+            if (field.id === this.field.id) {
+                this.setupDropdown();
+            }
+        });
+    }
+    updateReactiveFormControl() {
+        this.updateFormControlState();
+        this.handleErrors();
+    }
+    compareDropdownValues(opt1, opt2) {
+        if (!opt1 || !opt2) {
+            return false;
+        }
+        if (typeof opt1 === 'string' && typeof opt2 === 'object') {
+            return opt1 === opt2.id || opt1 === opt2.name;
+        }
+        if (typeof opt1 === 'object' && typeof opt2 === 'string') {
+            return opt1.id === opt2 || opt1.name === opt2;
+        }
+        if (typeof opt1 === 'object' && typeof opt2 === 'object') {
+            return opt1.id === opt2.id || opt1.name === opt2.name;
+        }
+        return opt1 === opt2;
+    }
+    selectionChangedForField(field) {
+        const formFieldValueChangedEvent = new FormFieldEvent(field.form, field);
+        this.formService.formFieldValueChanged.next(formFieldValueChangedEvent);
+        this.onFieldChanged(field);
+    }
+    setupDropdown() {
+        this.setPreviewState();
+        this.checkFieldOptionsSource();
+        this.updateOptions();
+        this.setFormControlValue();
+        this.updateFormControlState();
+        this.subscribeToInputChanges();
+        this.initFilter();
+        this.handleErrors();
+    }
+    subscribeToInputChanges() {
+        this.dropdownControl.valueChanges
+            .pipe(filter(() => !!this.field), takeUntilDestroyed(this.destroyRef))
+            .subscribe((value) => {
+            this.setOptionValue(value, this.field);
+            this.handleErrors();
+            this.selectionChangedForField(this.field);
+        });
+    }
+    setFormControlValue() {
+        if (Array.isArray(this.field.value)) {
+            this.dropdownControl.setValue(this.field?.value, { emitEvent: false });
+        }
+        else if (this.field?.value && typeof this.field?.value === 'object') {
+            this.dropdownControl.setValue({ id: this.field?.value.id, name: this.field?.value.name }, { emitEvent: false });
+        }
+        else if (this.field.value === null) {
+            this.dropdownControl.setValue(this.field?.value, { emitEvent: false });
+        }
+        else {
+            this.dropdownControl.setValue({ id: this.field?.value, name: '' }, { emitEvent: false });
+        }
+    }
+    updateFormControlState() {
+        this.updateDropdownValidationRules();
+        this.updateDropdownReadonlyRules();
+        this.dropdownControl.updateValueAndValidity({ emitEvent: false });
+    }
+    updateDropdownValidationRules() {
+        this.dropdownControl.setValidators([]);
+        if (!this.field?.isVisible) {
+            return;
+        }
+        if (this.isRequired()) {
+            this.dropdownControl.addValidators([Validators.required]);
+            if (this.field.hasEmptyValue) {
+                this.dropdownControl.addValidators([defaultValueValidator(this.field)]);
+            }
+        }
+    }
+    updateDropdownReadonlyRules() {
+        if (this.field?.readOnly || this.readOnly) {
+            this.dropdownControl.disable({ emitEvent: false });
+        }
+        else {
+            this.dropdownControl.enable({ emitEvent: false });
+        }
+    }
+    handleErrors() {
+        if (this.dropdownControl.valid) {
+            this.field.validationSummary = new ErrorMessageModel('');
+            this.field.markAsValid();
+            return;
+        }
+        if (this.dropdownControl.invalid && this.dropdownControl.errors.required) {
+            this.field.validationSummary = new ErrorMessageModel({ message: 'FORM.FIELD.REQUIRED' });
+            this.field.markAsInvalid();
+        }
+    }
+    initFilter() {
+        this.filter$
+            .pipe(filter((search) => search !== undefined), map((search) => search ? this.field.options.filter(({ name }) => name.toLowerCase().includes(search.toLowerCase())) : this.field.options), takeUntilDestroyed(this.destroyRef))
+            .subscribe((result) => this.list$.next(result));
+    }
+    checkFieldOptionsSource() {
+        switch (true) {
+            case this.isReadOnlyForm:
+                break;
+            case this.isValidRestConfig && !this.isLinkedWidget:
+                this.persistFieldOptionsFromRestApi();
+                break;
+            case this.isLinkedWidget:
+                this.loadFieldOptionsForLinkedWidget();
+                break;
+            case this.isVariableOptionType:
+                this.persistFieldOptionsFromVariable();
+                break;
+            default:
+                break;
+        }
+    }
+    persistFieldOptionsFromVariable() {
+        const optionsPath = this.field?.variableConfig?.optionsPath ?? this.defaultVariableOptionPath;
+        const variableName = this.field?.variableConfig?.variableName;
+        const processVariables = this.field?.form?.processVariables;
+        const formVariables = this.field?.form?.variables;
+        const dropdownOptions = this.getOptionsFromVariable(processVariables, formVariables, variableName);
+        if (dropdownOptions) {
+            const formVariableOptions = this.getOptionsFromPath(dropdownOptions, optionsPath);
+            this.updateOptions(formVariableOptions);
+            this.resetInvalidValue();
+            this.field.updateForm();
+        }
+        else {
+            this.handleError(`${variableName} not found`);
+            this.resetOptions();
+            this.variableOptionsFailed = true;
+        }
+    }
+    getOptionsFromPath(data, path) {
+        const optionsId = this.field?.variableConfig?.optionsId ?? this.defaultVariableOptionId;
+        const optionsLabel = this.field?.variableConfig?.optionsLabel ?? this.defaultVariableOptionLabel;
+        const properties = path.split('.');
+        const currentProperty = properties.shift();
+        if (!Object.prototype.hasOwnProperty.call(data, currentProperty)) {
+            this.handleError(`${currentProperty} not found in ${JSON.stringify(data)}`);
+            this.variableOptionsFailed = true;
+            return [];
+        }
+        const nestedData = data[currentProperty];
+        if (Array.isArray(nestedData)) {
+            return this.getOptionsFromArray(nestedData, optionsId, optionsLabel);
+        }
+        return this.getOptionsFromPath(nestedData, properties.join('.'));
+    }
+    getOptionsFromArray(nestedData, id, label) {
+        const options = nestedData.map((item) => this.createOption(item, id, label));
+        const hasInvalidOption = options.some((option) => !option);
+        if (hasInvalidOption) {
+            this.variableOptionsFailed = true;
+            return [];
+        }
+        this.variableOptionsFailed = false;
+        return options;
+    }
+    createOption(item, id, label) {
+        const option = {
+            id: item[id],
+            name: item[label]
+        };
+        if (!option.id || !option.name) {
+            this.handleError(`'id' or 'label' is not properly defined`);
+            return undefined;
+        }
+        return option;
+    }
+    getOptionsFromVariable(processVariables, formVariables, variableName) {
+        const processVariableDropdownOptions = this.getVariableValueByName(processVariables, variableName);
+        const formVariableDropdownOptions = this.getVariableValueByName(formVariables, variableName);
+        return processVariableDropdownOptions ?? formVariableDropdownOptions;
+    }
+    getVariableValueByName(variables, variableName) {
+        return variables?.find((variable) => variable?.name === `variables.${variableName}` || variable?.name === variableName)
+            ?.value;
+    }
+    persistFieldOptionsFromRestApi() {
+        if (this.isValidRestConfig) {
+            this.resetRestApiErrorMessage();
+            const bodyParam = this.buildBodyParam();
+            this.formCloudService
+                .getRestWidgetData(this.field.form.id, this.field.id, bodyParam)
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe({
+                next: (result) => {
+                    this.resetRestApiErrorMessage();
+                    this.updateOptions(result);
+                    this.field.updateForm();
+                    this.resetInvalidValue();
+                },
+                error: (err) => {
+                    this.resetRestApiOptions();
+                    this.handleError(err);
+                }
+            });
+        }
+    }
+    buildBodyParam() {
+        const bodyParam = Object.assign({});
+        if (this.isLinkedWidget) {
+            const parentWidgetValue = this.getParentWidgetValue();
+            const parentWidgetId = this.linkedWidgetId;
+            bodyParam[parentWidgetId] = parentWidgetValue;
+        }
+        return this.formUtilsService.getRestUrlVariablesMap(this.field.form, this.field.restUrl, bodyParam);
+    }
+    loadFieldOptionsForLinkedWidget() {
+        const parentWidgetValue = this.getParentWidgetValue();
+        this.parentValueChanged(parentWidgetValue);
+        this.formService.formFieldValueChanged
+            .pipe(filter((event) => this.isFormFieldEventOfTypeDropdown(event) && this.isParentFormFieldEvent(event)), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            const valueOfParentWidget = event.field.value;
+            this.parentValueChanged(valueOfParentWidget);
+        });
+    }
+    getParentWidgetValue() {
+        const parentWidgetId = this.linkedWidgetId;
+        const parentWidget = this.getFormFieldById(parentWidgetId);
+        return parentWidget?.value;
+    }
+    parentValueChanged(value) {
+        if (value && !this.isNoneValueSelected(value)) {
+            this.isValidRestConfig ? this.persistFieldOptionsFromRestApi() : this.persistFieldOptionsFromManualList(value);
+        }
+        else if (this.isNoneValueSelected(value)) {
+            this.resetRestApiErrorMessage();
+            this.resetOptions();
+            this.resetInvalidValue();
+        }
+        else {
+            this.updateOptions([]);
+            this.resetInvalidValue();
+        }
+    }
+    isNoneValueSelected(value) {
+        return value === undefined;
+    }
+    getFormFieldById(fieldId) {
+        return this.field.form.getFormFields().filter((field) => field.id === fieldId)[0];
+    }
+    persistFieldOptionsFromManualList(value) {
+        if (this.hasRuleEntries()) {
+            const rulesEntries = this.field.rule.entries;
+            rulesEntries.forEach((ruleEntry) => {
+                if (ruleEntry.key === value) {
+                    this.updateOptions(ruleEntry.options);
+                    this.resetInvalidValue();
+                    this.field.updateForm();
+                }
+            });
+        }
+    }
+    resetInvalidValue() {
+        if (!this.isValidValue()) {
+            this.resetValue();
+        }
+    }
+    resetValue() {
+        this.field.value = '';
+        this.selectionChangedForField(this.field);
+        this.updateOptions();
+        this.field.updateForm();
+    }
+    isValidValue() {
+        return this.field.value && this.isSelectedValueInOptions();
+    }
+    isSelectedValueInOptions() {
+        if (Array.isArray(this.field.value)) {
+            const optionIdList = [...this.field.options].map((option) => option.id);
+            const fieldValueIds = this.field.value.map((valueOption) => valueOption.id);
+            return fieldValueIds.every((valueOptionId) => optionIdList.includes(valueOptionId));
+        }
+        else {
+            if (this.field?.value && typeof this.field?.value === 'object') {
+                return [...this.field.options].map((option) => option.id).includes(this.field.value.id);
+            }
+            else {
+                return [...this.field.options].map((option) => option.id).includes(this.field.value);
+            }
+        }
+    }
+    hasRuleEntries() {
+        return !!this.field.rule.entries.length;
+    }
+    resetOptions() {
+        this.updateOptions([]);
+    }
+    isParentFormFieldEvent(event) {
+        return event.field.id === this.linkedWidgetId;
+    }
+    isFormFieldEventOfTypeDropdown(event) {
+        return event.field.type === FormFieldTypes.DROPDOWN;
+    }
+    setOptionValue(option, field) {
+        if (Array.isArray(option) || field.hasMultipleValues) {
+            field.value = option;
+            return;
+        }
+        let optionValue = '';
+        if (option.id === DEFAULT_OPTION.id) {
+            optionValue = undefined;
+        }
+        else if (option.name !== field.value) {
+            optionValue = option.id;
+        }
+        else {
+            optionValue = option.name;
+        }
+        field.value = optionValue;
+    }
+    setPreviewState() {
+        this.previewState = this.formCloudService.getPreviewState();
+    }
+    handleError(error) {
+        if (!this.previewState) {
+            this.widgetError.emit(error);
+        }
+    }
+    updateOptions(options) {
+        if (!this.field) {
+            return;
+        }
+        if (options) {
+            this.field.options = options;
+        }
+        this.list$.next(this.field.options);
+        this.showInputFilter = this.field.options.length > this.appConfig.get('form.dropDownFilterLimit', HIDE_FILTER_LIMIT);
+    }
+    resetRestApiErrorMessage() {
+        this.isRestApiFailed = false;
+        this.restApiHostName = '';
+    }
+    resetRestApiOptions() {
+        this.updateOptions([]);
+        this.resetValue();
+        this.isRestApiFailed = true;
+        this.restApiHostName = this.getRestUrlHostName();
+    }
+    getRestUrlHostName() {
+        try {
+            return new URL(this.field?.restUrl).hostname;
+        }
+        catch {
+            return this.field?.restUrl;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DropdownCloudWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DropdownCloudWidgetComponent, isStandalone: true, selector: "dropdown-cloud-widget", usesInheritance: true, ngImport: i0, template: "<div\n    class=\"adf-dropdown-widget {{field.className}}\"\n    [class.adf-invalid]=\"dropdownControl.invalid && dropdownControl.touched\"\n    [class.adf-readonly]=\"field.readOnly\"\n    [class.adf-left-label-input-container]=\"field.leftLabels\"\n>\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\" [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div>\n        <mat-form-field>\n            <mat-label *ngIf=\"!field.leftLabels\" class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n            <mat-select\n                class=\"adf-select\"\n                [formControl]=\"dropdownControl\"\n                [id]=\"field.id\"\n                [compareWith]=\"compareDropdownValues\"\n                [title]=\"field.tooltip\"\n                panelClass=\"adf-select-filter\"\n                [multiple]=\"field.hasMultipleValues\"\n                [required]=\"isRequired()\"\n            >\n                <adf-select-filter-input *ngIf=\"showInputFilter\" (change)=\"filter$.next($event)\" />\n\n                <mat-option *ngFor=\"let opt of list$ | async\" [value]=\"opt\" [id]=\"opt.id\">{{opt.name}}</mat-option>\n                <mat-option id=\"readonlyOption\" *ngIf=\"isReadOnlyType\" [value]=\"field.value\">{{field.value}}</mat-option>\n            </mat-select>\n        </mat-form-field>\n        <div *ngIf=\"!previewState && !field.readOnly\">\n            <error-widget\n                class=\"adf-dropdown-required-message\"\n                *ngIf=\"showRequiredMessage\"\n                required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\"\n            />\n            <error-widget\n                class=\"adf-dropdown-failed-message\"\n                *ngIf=\"isRestApiFailed\"\n                required=\"{{ 'FORM.FIELD.REST_API_FAILED' | translate: { hostname: restApiHostName } }}\"\n            />\n            <error-widget\n                class=\"adf-dropdown-failed-message\"\n                *ngIf=\"variableOptionsFailed\"\n                required=\"{{ 'FORM.FIELD.VARIABLE_DROPDOWN_OPTIONS_FAILED' | translate }}\"\n            />\n        </div>\n    </div>\n</div>\n", styles: [".adf-dropdown-widget{width:100%}.adf-dropdown-widget .adf-select{padding-top:0;width:100%}.adf-dropdown-widget .adf-select-filter{font-size:var(--theme-body-1-font-size)}.adf-dropdown-widget-select{width:100%}.adf-dropdown-widget-dropdown-required-message .adf-error-container,.adf-dropdown-widget-dropdown-failed-message .adf-error-container{margin-top:1px}.adf-dropdown-widget .mat-mdc-select-arrow-wrapper{height:auto}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { 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: "ngmodule", type: MatSelectModule }, { kind: "component", type: i3.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i4.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: ErrorWidgetComponent, selector: "error-widget", inputs: ["error", "required"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "component", type: SelectFilterInputComponent, selector: "adf-select-filter-input", outputs: ["change"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DropdownCloudWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dropdown-cloud-widget', encapsulation: ViewEncapsulation.None, standalone: true, imports: [
+                        NgIf,
+                        NgFor,
+                        AsyncPipe,
+                        ReactiveFormsModule,
+                        MatFormFieldModule,
+                        MatSelectModule,
+                        ErrorWidgetComponent,
+                        TranslateModule,
+                        SelectFilterInputComponent
+                    ], template: "<div\n    class=\"adf-dropdown-widget {{field.className}}\"\n    [class.adf-invalid]=\"dropdownControl.invalid && dropdownControl.touched\"\n    [class.adf-readonly]=\"field.readOnly\"\n    [class.adf-left-label-input-container]=\"field.leftLabels\"\n>\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\" [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div>\n        <mat-form-field>\n            <mat-label *ngIf=\"!field.leftLabels\" class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n            <mat-select\n                class=\"adf-select\"\n                [formControl]=\"dropdownControl\"\n                [id]=\"field.id\"\n                [compareWith]=\"compareDropdownValues\"\n                [title]=\"field.tooltip\"\n                panelClass=\"adf-select-filter\"\n                [multiple]=\"field.hasMultipleValues\"\n                [required]=\"isRequired()\"\n            >\n                <adf-select-filter-input *ngIf=\"showInputFilter\" (change)=\"filter$.next($event)\" />\n\n                <mat-option *ngFor=\"let opt of list$ | async\" [value]=\"opt\" [id]=\"opt.id\">{{opt.name}}</mat-option>\n                <mat-option id=\"readonlyOption\" *ngIf=\"isReadOnlyType\" [value]=\"field.value\">{{field.value}}</mat-option>\n            </mat-select>\n        </mat-form-field>\n        <div *ngIf=\"!previewState && !field.readOnly\">\n            <error-widget\n                class=\"adf-dropdown-required-message\"\n                *ngIf=\"showRequiredMessage\"\n                required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\"\n            />\n            <error-widget\n                class=\"adf-dropdown-failed-message\"\n                *ngIf=\"isRestApiFailed\"\n                required=\"{{ 'FORM.FIELD.REST_API_FAILED' | translate: { hostname: restApiHostName } }}\"\n            />\n            <error-widget\n                class=\"adf-dropdown-failed-message\"\n                *ngIf=\"variableOptionsFailed\"\n                required=\"{{ 'FORM.FIELD.VARIABLE_DROPDOWN_OPTIONS_FAILED' | translate }}\"\n            />\n        </div>\n    </div>\n</div>\n", styles: [".adf-dropdown-widget{width:100%}.adf-dropdown-widget .adf-select{padding-top:0;width:100%}.adf-dropdown-widget .adf-select-filter{font-size:var(--theme-body-1-font-size)}.adf-dropdown-widget-select{width:100%}.adf-dropdown-widget-dropdown-required-message .adf-error-container,.adf-dropdown-widget-dropdown-failed-message .adf-error-container{margin-top:1px}.adf-dropdown-widget .mat-mdc-select-arrow-wrapper{height:auto}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-cloud.widget.js","sourceRoot":"","sources":["../../../../../../../../../lib/process-services-cloud/src/lib/form/components/widgets/dropdown/dropdown-cloud.widget.ts","../../../../../../../../../lib/process-services-cloud/src/lib/form/components/widgets/dropdown/dropdown-cloud.widget.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACH,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EAGd,cAAc,EACd,WAAW,EAGX,0BAA0B,EAC1B,eAAe,EAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;;;;;;;AAErD,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,EAAE,EAAE,OAAO;IACX,IAAI,EAAE,eAAe;CACxB,CAAC;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC,uDAAuD;AAoBvD,MAAM,OAAO,4BAA6B,SAAQ,eAAe;IAlBjE;;QAmBW,gBAAW,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QACxB,qBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAC5C,cAAS,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACrC,qBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACrD,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAExC,WAAM,GAAG,8BAA8B,CAAC;QACxC,oBAAe,GAAG,KAAK,CAAC;QACxB,oBAAe,GAAG,KAAK,CAAC;QACxB,0BAAqB,GAAG,KAAK,CAAC;QAC9B,iBAAY,GAAG,KAAK,CAAC;QAErB,oBAAe,GAAG,IAAI,WAAW,CAAsC,SAAS,CAAC,CAAC;QAElF,UAAK,GAAG,IAAI,eAAe,CAAoB,EAAE,CAAC,CAAC;QACnD,YAAO,GAAG,IAAI,eAAe,CAAS,EAAE,CAAC,CAAC;QAEzB,4BAAuB,GAAG,IAAI,CAAC;QAC/B,+BAA0B,GAAG,MAAM,CAAC;QACpC,8BAAyB,GAAG,MAAM,CAAC;KAwdvD;IAtdG,IAAI,mBAAmB;QACnB,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,QAAQ,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC;IACzI,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC;IAC1C,CAAC;IAED,IAAY,cAAc;QACtB,OAAO,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;IACjC,CAAC;IAED,IAAY,cAAc;QACtB,OAAO,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC;IACpC,CAAC;IAED,IAAY,cAAc;QACtB,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC;IACxC,CAAC;IAED,IAAY,UAAU;QAClB,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC;IACjC,CAAC;IAED,IAAY,iBAAiB;QACzB,OAAO,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,UAAU,CAAC;IACpD,CAAC;IAED,IAAY,gBAAgB;QACxB,OAAO,IAAI,CAAC,KAAK,EAAE,UAAU,KAAK,MAAM,CAAC;IAC7C,CAAC;IAED,IAAY,oBAAoB;QAC5B,OAAO,IAAI,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,CAAC;IACjD,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,aAAa,EAAE,CAAC;QAErB,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;YAC3D,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;gBAC7B,IAAI,CAAC,aAAa,EAAE,CAAC;YACzB,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,yBAAyB;QACrB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,YAAY,EAAE,CAAC;IACxB,CAAC;IAED,qBAAqB,CAAC,IAA8B,EAAE,IAA8B;QAChF,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACjB,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvD,OAAO,IAAI,KAAK,IAAI,CAAC,EAAE,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC;QAClD,CAAC;QAED,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvD,OAAO,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC;QAClD,CAAC;QAED,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvD,OAAO,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC;QAC1D,CAAC;QAED,OAAO,IAAI,KAAK,IAAI,CAAC;IACzB,CAAC;IAED,wBAAwB,CAAC,KAAqB;QAC1C,MAAM,0BAA0B,GAAG,IAAI,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACzE,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;QACxE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEO,aAAa;QACjB,IAAI,CAAC,eAAe,EAAE,CAAC;QAEvB,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,aAAa,EAAE,CAAC;QAErB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,YAAY,EAAE,CAAC;IACxB,CAAC;IAEO,uBAAuB;QAC3B,IAAI,CAAC,eAAe,CAAC,YAAY;aAC5B,IAAI,CACD,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAC1B,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CACtC;aACA,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACjB,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACvC,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACX,CAAC;IAEO,mBAAmB;QACvB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAClC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC3E,CAAC;aAAM,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,IAAI,OAAO,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,QAAQ,EAAE,CAAC;YACpE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QACpH,CAAC;aAAM,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACnC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC3E,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC7F,CAAC;IACL,CAAC;IAEO,sBAAsB;QAC1B,IAAI,CAAC,6BAA6B,EAAE,CAAC;QACrC,IAAI,CAAC,2BAA2B,EAAE,CAAC;QACnC,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAEO,6BAA6B;QACjC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QAEvC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;YACzB,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC1D,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;gBAC3B,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5E,CAAC;QACL,CAAC;IACL,CAAC;IAEO,2BAA2B;QAC/B,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACxC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QACvD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QACtD,CAAC;IACL,CAAC;IAEO,YAAY;QAChB,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,iBAAiB,GAAG,IAAI,iBAAiB,CAAC,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YACzB,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACvE,IAAI,CAAC,KAAK,CAAC,iBAAiB,GAAG,IAAI,iBAAiB,CAAC,EAAE,OAAO,EAAE,qBAAqB,EAAE,CAAC,CAAC;YACzF,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAC/B,CAAC;IACL,CAAC;IAEO,UAAU;QACd,IAAI,CAAC,OAAO;aACP,IAAI,CACD,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,SAAS,CAAC,EACxC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CACX,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAC3H,EACD,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CACtC;aACA,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAEO,uBAAuB;QAC3B,QAAQ,IAAI,EAAE,CAAC;YACX,KAAK,IAAI,CAAC,cAAc;gBACpB,MAAM;YACV,KAAK,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,cAAc;gBAC/C,IAAI,CAAC,8BAA8B,EAAE,CAAC;gBACtC,MAAM;YAEV,KAAK,IAAI,CAAC,cAAc;gBACpB,IAAI,CAAC,+BAA+B,EAAE,CAAC;gBACvC,MAAM;YAEV,KAAK,IAAI,CAAC,oBAAoB;gBAC1B,IAAI,CAAC,+BAA+B,EAAE,CAAC;gBACvC,MAAM;YAEV;gBACI,MAAM;QACd,CAAC;IACL,CAAC;IAEO,+BAA+B;QACnC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,WAAW,IAAI,IAAI,CAAC,yBAAyB,CAAC;QAC9F,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,YAAY,CAAC;QAC9D,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,gBAAgB,CAAC;QAC5D,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC;QAElD,MAAM,eAAe,GAAG,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;QAEnG,IAAI,eAAe,EAAE,CAAC;YAClB,MAAM,mBAAmB,GAAsB,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;YACrG,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;YACxC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;QAC5B,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,WAAW,CAAC,GAAG,YAAY,YAAY,CAAC,CAAC;YAC9C,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QACtC,CAAC;IACL,CAAC;IAEO,kBAAkB,CAAC,IAAS,EAAE,IAAY;QAC9C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,IAAI,IAAI,CAAC,uBAAuB,CAAC;QACxF,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,YAAY,IAAI,IAAI,CAAC,0BAA0B,CAAC;QAEjG,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnC,MAAM,eAAe,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC;QAE3C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,eAAe,CAAC,EAAE,CAAC;YAC/D,IAAI,CAAC,WAAW,CAAC,GAAG,eAAe,iBAAiB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC5E,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;YAClC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC;QAEzC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;QACzE,CAAC;QAED,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACrE,CAAC;IAEO,mBAAmB,CAAC,UAAiB,EAAE,EAAU,EAAE,KAAa;QACpE,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;QAC7E,MAAM,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;QAE3D,IAAI,gBAAgB,EAAE,CAAC;YACnB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;YAClC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,OAAO,OAAO,CAAC;IACnB,CAAC;IAEO,YAAY,CAAC,IAAS,EAAE,EAAU,EAAE,KAAa;QACrD,MAAM,MAAM,GAAoB;YAC5B,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC;YACZ,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC;SACpB,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YAC7B,IAAI,CAAC,WAAW,CAAC,yCAAyC,CAAC,CAAC;YAC5D,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,sBAAsB,CAC1B,gBAAqC,EACrC,aAAkC,EAClC,YAAoB;QAEpB,MAAM,8BAA8B,GAAsB,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;QACtH,MAAM,2BAA2B,GAAsB,IAAI,CAAC,sBAAsB,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QAEhH,OAAO,8BAA8B,IAAI,2BAA2B,CAAC;IACzE,CAAC;IAEO,sBAAsB,CAAC,SAA8B,EAAE,YAAoB;QAC/E,OAAO,SAAS,EAAE,IAAI,CAAC,CAAC,QAA2B,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,KAAK,aAAa,YAAY,EAAE,IAAI,QAAQ,EAAE,IAAI,KAAK,YAAY,CAAC;YACtI,EAAE,KAAK,CAAC;IAChB,CAAC;IAEO,8BAA8B;QAClC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACxC,IAAI,CAAC,gBAAgB;iBAChB,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,SAAS,CAAC;iBAC/D,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;iBACzC,SAAS,CAAC;gBACP,IAAI,EAAE,CAAC,MAAyB,EAAE,EAAE;oBAChC,IAAI,CAAC,wBAAwB,EAAE,CAAC;oBAChC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;oBAC3B,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;oBACxB,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC7B,CAAC;gBACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;oBACX,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC3B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;gBAC1B,CAAC;aACJ,CAAC,CAAC;QACX,CAAC;IACL,CAAC;IAEO,cAAc;QAClB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACpC,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,MAAM,iBAAiB,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACtD,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;YAC3C,SAAS,CAAC,cAAc,CAAC,GAAG,iBAAiB,CAAC;QAClD,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACxG,CAAC;IAEO,+BAA+B;QACnC,MAAM,iBAAiB,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACtD,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;QAE3C,IAAI,CAAC,WAAW,CAAC,qBAAqB;aACjC,IAAI,CACD,MAAM,CAAC,CAAC,KAAqB,EAAE,EAAE,CAAC,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,EACnH,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CACtC;aACA,SAAS,CAAC,CAAC,KAAqB,EAAE,EAAE;YACjC,MAAM,mBAAmB,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC;YAC9C,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;IACX,CAAC;IAEO,oBAAoB;QACxB,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QAC3D,OAAO,YAAY,EAAE,KAAK,CAAC;IAC/B,CAAC;IAEO,kBAAkB,CAAC,KAAa;QACpC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,iCAAiC,CAAC,KAAK,CAAC,CAAC;QACnH,CAAC;aAAM,IAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7B,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YACvB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7B,CAAC;IACL,CAAC;IAEO,mBAAmB,CAAC,KAAa;QACrC,OAAO,KAAK,KAAK,SAAS,CAAC;IAC/B,CAAC;IAEO,gBAAgB,CAAC,OAAO;QAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,MAAM,CAAC,CAAC,KAAqB,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACtG,CAAC;IAEO,iCAAiC,CAAC,KAAa;QACnD,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACxB,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;YAC7C,YAAY,CAAC,OAAO,CAAC,CAAC,SAAoB,EAAE,EAAE;gBAC1C,IAAI,SAAS,CAAC,GAAG,KAAK,KAAK,EAAE,CAAC;oBAC1B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;oBACtC,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACzB,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;gBAC5B,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAEO,iBAAiB;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;YACvB,IAAI,CAAC,UAAU,EAAE,CAAC;QACtB,CAAC;IACL,CAAC;IAEO,UAAU;QACd,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;QACtB,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;IAC5B,CAAC;IAEO,YAAY;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAC/D,CAAC;IAEO,wBAAwB;QAC5B,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAClC,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACxE,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;YAC5E,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;QACxF,CAAC;aAAM,CAAC;YACJ,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,IAAI,OAAO,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC7D,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC5F,CAAC;iBAAM,CAAC;gBACJ,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzF,CAAC;QACL,CAAC;IACL,CAAC;IAEO,cAAc;QAClB,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC5C,CAAC;IAEO,YAAY;QAChB,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;IAEO,sBAAsB,CAAC,KAAqB;QAChD,OAAO,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,cAAc,CAAC;IAClD,CAAC;IAEO,8BAA8B,CAAC,KAAqB;QACxD,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,cAAc,CAAC,QAAQ,CAAC;IACxD,CAAC;IAEO,cAAc,CAAC,MAA2C,EAAE,KAAqB;QACrF,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;YACnD,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC;YACrB,OAAO;QACX,CAAC;QAED,IAAI,WAAW,GAAW,EAAE,CAAC;QAC7B,IAAI,MAAM,CAAC,EAAE,KAAK,cAAc,CAAC,EAAE,EAAE,CAAC;YAClC,WAAW,GAAG,SAAS,CAAC;QAC5B,CAAC;aAAM,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC;YACrC,WAAW,GAAG,MAAM,CAAC,EAAE,CAAC;QAC5B,CAAC;aAAM,CAAC;YACJ,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC;QAC9B,CAAC;QAED,KAAK,CAAC,KAAK,GAAG,WAAW,CAAC;IAC9B,CAAC;IAEO,eAAe;QACnB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,eAAe,EAAE,CAAC;IAChE,CAAC;IAEO,WAAW,CAAC,KAAU;QAC1B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACrB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;IACL,CAAC;IAEO,aAAa,CAAC,OAA2B;QAC7C,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YACd,OAAO;QACX,CAAC;QAED,IAAI,OAAO,EAAE,CAAC;YACV,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;QACjC,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAS,0BAA0B,EAAE,iBAAiB,CAAC,CAAC;IACjI,CAAC;IAEO,wBAAwB;QAC5B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC7B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;IAC9B,CAAC;IAEO,mBAAmB;QACvB,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACvB,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;IACrD,CAAC;IAEO,kBAAkB;QACtB,IAAI,CAAC;YACD,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC;QACjD,CAAC;QAAC,MAAM,CAAC;YACL,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC;QAC/B,CAAC;IACL,CAAC;+GA3eQ,4BAA4B;mGAA5B,4BAA4B,wGCvEzC,q0EAmDA,ieDSQ,IAAI,6FACJ,KAAK,8GACL,SAAS,6CACT,mBAAmB,shBACnB,kBAAkB,0SAClB,eAAe,orBACf,oBAAoB,uFACpB,eAAe,4FACf,0BAA0B;;4FAGrB,4BAA4B;kBAlBxC,SAAS;+BACI,uBAAuB,iBAGlB,iBAAiB,CAAC,IAAI,cACzB,IAAI,WACP;wBACL,IAAI;wBACJ,KAAK;wBACL,SAAS;wBACT,mBAAmB;wBACnB,kBAAkB;wBAClB,eAAe;wBACf,oBAAoB;wBACpB,eAAe;wBACf,0BAA0B;qBAC7B","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 {\n    AppConfigService,\n    ErrorMessageModel,\n    ErrorWidgetComponent,\n    FormFieldEvent,\n    FormFieldModel,\n    FormFieldOption,\n    FormFieldTypes,\n    FormService,\n    ReactiveFormWidget,\n    RuleEntry,\n    SelectFilterInputComponent,\n    WidgetComponent\n} from '@alfresco/adf-core';\nimport { AsyncPipe, NgFor, NgIf } from '@angular/common';\nimport { Component, DestroyRef, inject, OnInit, ViewEncapsulation } from '@angular/core';\nimport { FormControl, ReactiveFormsModule, Validators } from '@angular/forms';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatSelectModule } from '@angular/material/select';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { filter, map } from 'rxjs/operators';\nimport { TaskVariableCloud } from '../../../models/task-variable-cloud.model';\nimport { FormCloudService } from '../../../services/form-cloud.service';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { FormUtilsService } from '../../../services/form-utils.service';\nimport { defaultValueValidator } from './validators';\n\nexport const DEFAULT_OPTION = {\n    id: 'empty',\n    name: 'Choose one...'\n};\nexport const HIDE_FILTER_LIMIT = 5;\n\n/* eslint-disable @angular-eslint/component-selector */\n\n@Component({\n    selector: 'dropdown-cloud-widget',\n    templateUrl: './dropdown-cloud.widget.html',\n    styleUrls: ['./dropdown-cloud.widget.scss'],\n    encapsulation: ViewEncapsulation.None,\n    standalone: true,\n    imports: [\n        NgIf,\n        NgFor,\n        AsyncPipe,\n        ReactiveFormsModule,\n        MatFormFieldModule,\n        MatSelectModule,\n        ErrorWidgetComponent,\n        TranslateModule,\n        SelectFilterInputComponent\n    ]\n})\nexport class DropdownCloudWidgetComponent extends WidgetComponent implements OnInit, ReactiveFormWidget {\n    public formService = inject(FormService);\n    private readonly formCloudService = inject(FormCloudService);\n    private readonly appConfig = inject(AppConfigService);\n    private readonly formUtilsService = inject(FormUtilsService);\n    private destroyRef = inject(DestroyRef);\n\n    typeId = 'DropdownCloudWidgetComponent';\n    showInputFilter = false;\n    isRestApiFailed = false;\n    variableOptionsFailed = false;\n    previewState = false;\n    restApiHostName: string;\n    dropdownControl = new FormControl<FormFieldOption | FormFieldOption[]>(undefined);\n\n    list$ = new BehaviorSubject<FormFieldOption[]>([]);\n    filter$ = new BehaviorSubject<string>('');\n\n    private readonly defaultVariableOptionId = 'id';\n    private readonly defaultVariableOptionLabel = 'name';\n    private readonly defaultVariableOptionPath = 'data';\n\n    get showRequiredMessage(): boolean {\n        return this.dropdownControl.touched && this.dropdownControl.errors?.required && !this.isRestApiFailed && !this.variableOptionsFailed;\n    }\n\n    get isReadOnlyType(): boolean {\n        return this.field.type === 'readonly';\n    }\n\n    private get isLinkedWidget(): boolean {\n        return !!this.linkedWidgetId;\n    }\n\n    private get linkedWidgetId(): string {\n        return this.field?.rule?.ruleOn;\n    }\n\n    private get isReadOnlyForm(): boolean {\n        return !!this.field?.form?.readOnly;\n    }\n\n    private get hasRestUrl(): boolean {\n        return !!this.field?.restUrl;\n    }\n\n    private get isValidRestConfig(): boolean {\n        return this.isRestOptionType && this.hasRestUrl;\n    }\n\n    private get isRestOptionType(): boolean {\n        return this.field?.optionType === 'rest';\n    }\n\n    private get isVariableOptionType(): boolean {\n        return this.field?.optionType === 'variable';\n    }\n\n    ngOnInit() {\n        this.setupDropdown();\n\n        this.formService.onFormVariableChanged.subscribe(({ field }) => {\n            if (field.id === this.field.id) {\n                this.setupDropdown();\n            }\n        });\n    }\n\n    updateReactiveFormControl(): void {\n        this.updateFormControlState();\n        this.handleErrors();\n    }\n\n    compareDropdownValues(opt1: FormFieldOption | string, opt2: FormFieldOption | string): boolean {\n        if (!opt1 || !opt2) {\n            return false;\n        }\n\n        if (typeof opt1 === 'string' && typeof opt2 === 'object') {\n            return opt1 === opt2.id || opt1 === opt2.name;\n        }\n\n        if (typeof opt1 === 'object' && typeof opt2 === 'string') {\n            return opt1.id === opt2 || opt1.name === opt2;\n        }\n\n        if (typeof opt1 === 'object' && typeof opt2 === 'object') {\n            return opt1.id === opt2.id || opt1.name === opt2.name;\n        }\n\n        return opt1 === opt2;\n    }\n\n    selectionChangedForField(field: FormFieldModel): void {\n        const formFieldValueChangedEvent = new FormFieldEvent(field.form, field);\n        this.formService.formFieldValueChanged.next(formFieldValueChangedEvent);\n        this.onFieldChanged(field);\n    }\n\n    private setupDropdown(): void {\n        this.setPreviewState();\n\n        this.checkFieldOptionsSource();\n        this.updateOptions();\n\n        this.setFormControlValue();\n        this.updateFormControlState();\n        this.subscribeToInputChanges();\n        this.initFilter();\n        this.handleErrors();\n    }\n\n    private subscribeToInputChanges(): void {\n        this.dropdownControl.valueChanges\n            .pipe(\n                filter(() => !!this.field),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((value) => {\n                this.setOptionValue(value, this.field);\n                this.handleErrors();\n                this.selectionChangedForField(this.field);\n            });\n    }\n\n    private setFormControlValue(): void {\n        if (Array.isArray(this.field.value)) {\n            this.dropdownControl.setValue(this.field?.value, { emitEvent: false });\n        } else if (this.field?.value && typeof this.field?.value === 'object') {\n            this.dropdownControl.setValue({ id: this.field?.value.id, name: this.field?.value.name }, { emitEvent: false });\n        } else if (this.field.value === null) {\n            this.dropdownControl.setValue(this.field?.value, { emitEvent: false });\n        } else {\n            this.dropdownControl.setValue({ id: this.field?.value, name: '' }, { emitEvent: false });\n        }\n    }\n\n    private updateFormControlState(): void {\n        this.updateDropdownValidationRules();\n        this.updateDropdownReadonlyRules();\n        this.dropdownControl.updateValueAndValidity({ emitEvent: false });\n    }\n\n    private updateDropdownValidationRules() {\n        this.dropdownControl.setValidators([]);\n\n        if (!this.field?.isVisible) {\n            return;\n        }\n\n        if (this.isRequired()) {\n            this.dropdownControl.addValidators([Validators.required]);\n            if (this.field.hasEmptyValue) {\n                this.dropdownControl.addValidators([defaultValueValidator(this.field)]);\n            }\n        }\n    }\n\n    private updateDropdownReadonlyRules() {\n        if (this.field?.readOnly || this.readOnly) {\n            this.dropdownControl.disable({ emitEvent: false });\n        } else {\n            this.dropdownControl.enable({ emitEvent: false });\n        }\n    }\n\n    private handleErrors(): void {\n        if (this.dropdownControl.valid) {\n            this.field.validationSummary = new ErrorMessageModel('');\n            this.field.markAsValid();\n            return;\n        }\n\n        if (this.dropdownControl.invalid && this.dropdownControl.errors.required) {\n            this.field.validationSummary = new ErrorMessageModel({ message: 'FORM.FIELD.REQUIRED' });\n            this.field.markAsInvalid();\n        }\n    }\n\n    private initFilter(): void {\n        this.filter$\n            .pipe(\n                filter((search) => search !== undefined),\n                map((search) =>\n                    search ? this.field.options.filter(({ name }) => name.toLowerCase().includes(search.toLowerCase())) : this.field.options\n                ),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((result) => this.list$.next(result));\n    }\n\n    private checkFieldOptionsSource(): void {\n        switch (true) {\n            case this.isReadOnlyForm:\n                break;\n            case this.isValidRestConfig && !this.isLinkedWidget:\n                this.persistFieldOptionsFromRestApi();\n                break;\n\n            case this.isLinkedWidget:\n                this.loadFieldOptionsForLinkedWidget();\n                break;\n\n            case this.isVariableOptionType:\n                this.persistFieldOptionsFromVariable();\n                break;\n\n            default:\n                break;\n        }\n    }\n\n    private persistFieldOptionsFromVariable(): void {\n        const optionsPath = this.field?.variableConfig?.optionsPath ?? this.defaultVariableOptionPath;\n        const variableName = this.field?.variableConfig?.variableName;\n        const processVariables = this.field?.form?.processVariables;\n        const formVariables = this.field?.form?.variables;\n\n        const dropdownOptions = this.getOptionsFromVariable(processVariables, formVariables, variableName);\n\n        if (dropdownOptions) {\n            const formVariableOptions: FormFieldOption[] = this.getOptionsFromPath(dropdownOptions, optionsPath);\n            this.updateOptions(formVariableOptions);\n            this.resetInvalidValue();\n            this.field.updateForm();\n        } else {\n            this.handleError(`${variableName} not found`);\n            this.resetOptions();\n            this.variableOptionsFailed = true;\n        }\n    }\n\n    private getOptionsFromPath(data: any, path: string): FormFieldOption[] {\n        const optionsId = this.field?.variableConfig?.optionsId ?? this.defaultVariableOptionId;\n        const optionsLabel = this.field?.variableConfig?.optionsLabel ?? this.defaultVariableOptionLabel;\n\n        const properties = path.split('.');\n        const currentProperty = properties.shift();\n\n        if (!Object.prototype.hasOwnProperty.call(data, currentProperty)) {\n            this.handleError(`${currentProperty} not found in ${JSON.stringify(data)}`);\n            this.variableOptionsFailed = true;\n            return [];\n        }\n\n        const nestedData = data[currentProperty];\n\n        if (Array.isArray(nestedData)) {\n            return this.getOptionsFromArray(nestedData, optionsId, optionsLabel);\n        }\n\n        return this.getOptionsFromPath(nestedData, properties.join('.'));\n    }\n\n    private getOptionsFromArray(nestedData: any[], id: string, label: string): FormFieldOption[] {\n        const options = nestedData.map((item) => this.createOption(item, id, label));\n        const hasInvalidOption = options.some((option) => !option);\n\n        if (hasInvalidOption) {\n            this.variableOptionsFailed = true;\n            return [];\n        }\n\n        this.variableOptionsFailed = false;\n        return options;\n    }\n\n    private createOption(item: any, id: string, label: string): FormFieldOption {\n        const option: FormFieldOption = {\n            id: item[id],\n            name: item[label]\n        };\n\n        if (!option.id || !option.name) {\n            this.handleError(`'id' or 'label' is not properly defined`);\n            return undefined;\n        }\n\n        return option;\n    }\n\n    private getOptionsFromVariable(\n        processVariables: TaskVariableCloud[],\n        formVariables: TaskVariableCloud[],\n        variableName: string\n    ): TaskVariableCloud {\n        const processVariableDropdownOptions: TaskVariableCloud = this.getVariableValueByName(processVariables, variableName);\n        const formVariableDropdownOptions: TaskVariableCloud = this.getVariableValueByName(formVariables, variableName);\n\n        return processVariableDropdownOptions ?? formVariableDropdownOptions;\n    }\n\n    private getVariableValueByName(variables: TaskVariableCloud[], variableName: string): any {\n        return variables?.find((variable: TaskVariableCloud) => variable?.name === `variables.${variableName}` || variable?.name === variableName)\n            ?.value;\n    }\n\n    private persistFieldOptionsFromRestApi() {\n        if (this.isValidRestConfig) {\n            this.resetRestApiErrorMessage();\n            const bodyParam = this.buildBodyParam();\n            this.formCloudService\n                .getRestWidgetData(this.field.form.id, this.field.id, bodyParam)\n                .pipe(takeUntilDestroyed(this.destroyRef))\n                .subscribe({\n                    next: (result: FormFieldOption[]) => {\n                        this.resetRestApiErrorMessage();\n                        this.updateOptions(result);\n                        this.field.updateForm();\n                        this.resetInvalidValue();\n                    },\n                    error: (err) => {\n                        this.resetRestApiOptions();\n                        this.handleError(err);\n                    }\n                });\n        }\n    }\n\n    private buildBodyParam(): any {\n        const bodyParam = Object.assign({});\n        if (this.isLinkedWidget) {\n            const parentWidgetValue = this.getParentWidgetValue();\n            const parentWidgetId = this.linkedWidgetId;\n            bodyParam[parentWidgetId] = parentWidgetValue;\n        }\n\n        return this.formUtilsService.getRestUrlVariablesMap(this.field.form, this.field.restUrl, bodyParam);\n    }\n\n    private loadFieldOptionsForLinkedWidget() {\n        const parentWidgetValue = this.getParentWidgetValue();\n        this.parentValueChanged(parentWidgetValue);\n\n        this.formService.formFieldValueChanged\n            .pipe(\n                filter((event: FormFieldEvent) => this.isFormFieldEventOfTypeDropdown(event) && this.isParentFormFieldEvent(event)),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((event: FormFieldEvent) => {\n                const valueOfParentWidget = event.field.value;\n                this.parentValueChanged(valueOfParentWidget);\n            });\n    }\n\n    private getParentWidgetValue(): string {\n        const parentWidgetId = this.linkedWidgetId;\n        const parentWidget = this.getFormFieldById(parentWidgetId);\n        return parentWidget?.value;\n    }\n\n    private parentValueChanged(value: string) {\n        if (value && !this.isNoneValueSelected(value)) {\n            this.isValidRestConfig ? this.persistFieldOptionsFromRestApi() : this.persistFieldOptionsFromManualList(value);\n        } else if (this.isNoneValueSelected(value)) {\n            this.resetRestApiErrorMessage();\n            this.resetOptions();\n            this.resetInvalidValue();\n        } else {\n            this.updateOptions([]);\n            this.resetInvalidValue();\n        }\n    }\n\n    private isNoneValueSelected(value: string): boolean {\n        return value === undefined;\n    }\n\n    private getFormFieldById(fieldId): FormFieldModel {\n        return this.field.form.getFormFields().filter((field: FormFieldModel) => field.id === fieldId)[0];\n    }\n\n    private persistFieldOptionsFromManualList(value: string) {\n        if (this.hasRuleEntries()) {\n            const rulesEntries = this.field.rule.entries;\n            rulesEntries.forEach((ruleEntry: RuleEntry) => {\n                if (ruleEntry.key === value) {\n                    this.updateOptions(ruleEntry.options);\n                    this.resetInvalidValue();\n                    this.field.updateForm();\n                }\n            });\n        }\n    }\n\n    private resetInvalidValue() {\n        if (!this.isValidValue()) {\n            this.resetValue();\n        }\n    }\n\n    private resetValue() {\n        this.field.value = '';\n        this.selectionChangedForField(this.field);\n        this.updateOptions();\n        this.field.updateForm();\n    }\n\n    private isValidValue(): boolean {\n        return this.field.value && this.isSelectedValueInOptions();\n    }\n\n    private isSelectedValueInOptions(): boolean {\n        if (Array.isArray(this.field.value)) {\n            const optionIdList = [...this.field.options].map((option) => option.id);\n            const fieldValueIds = this.field.value.map((valueOption) => valueOption.id);\n            return fieldValueIds.every((valueOptionId) => optionIdList.includes(valueOptionId));\n        } else {\n            if (this.field?.value && typeof this.field?.value === 'object') {\n                return [...this.field.options].map((option) => option.id).includes(this.field.value.id);\n            } else {\n                return [...this.field.options].map((option) => option.id).includes(this.field.value);\n            }\n        }\n    }\n\n    private hasRuleEntries(): boolean {\n        return !!this.field.rule.entries.length;\n    }\n\n    private resetOptions() {\n        this.updateOptions([]);\n    }\n\n    private isParentFormFieldEvent(event: FormFieldEvent): boolean {\n        return event.field.id === this.linkedWidgetId;\n    }\n\n    private isFormFieldEventOfTypeDropdown(event: FormFieldEvent): boolean {\n        return event.field.type === FormFieldTypes.DROPDOWN;\n    }\n\n    private setOptionValue(option: FormFieldOption | FormFieldOption[], field: FormFieldModel) {\n        if (Array.isArray(option) || field.hasMultipleValues) {\n            field.value = option;\n            return;\n        }\n\n        let optionValue: string = '';\n        if (option.id === DEFAULT_OPTION.id) {\n            optionValue = undefined;\n        } else if (option.name !== field.value) {\n            optionValue = option.id;\n        } else {\n            optionValue = option.name;\n        }\n\n        field.value = optionValue;\n    }\n\n    private setPreviewState(): void {\n        this.previewState = this.formCloudService.getPreviewState();\n    }\n\n    private handleError(error: any) {\n        if (!this.previewState) {\n            this.widgetError.emit(error);\n        }\n    }\n\n    private updateOptions(options?: FormFieldOption[]): void {\n        if (!this.field) {\n            return;\n        }\n\n        if (options) {\n            this.field.options = options;\n        }\n\n        this.list$.next(this.field.options);\n        this.showInputFilter = this.field.options.length > this.appConfig.get<number>('form.dropDownFilterLimit', HIDE_FILTER_LIMIT);\n    }\n\n    private resetRestApiErrorMessage(): void {\n        this.isRestApiFailed = false;\n        this.restApiHostName = '';\n    }\n\n    private resetRestApiOptions(): void {\n        this.updateOptions([]);\n        this.resetValue();\n        this.isRestApiFailed = true;\n        this.restApiHostName = this.getRestUrlHostName();\n    }\n\n    private getRestUrlHostName(): string {\n        try {\n            return new URL(this.field?.restUrl).hostname;\n        } catch {\n            return this.field?.restUrl;\n        }\n    }\n}\n","<div\n    class=\"adf-dropdown-widget {{field.className}}\"\n    [class.adf-invalid]=\"dropdownControl.invalid && dropdownControl.touched\"\n    [class.adf-readonly]=\"field.readOnly\"\n    [class.adf-left-label-input-container]=\"field.leftLabels\"\n>\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\" [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div>\n        <mat-form-field>\n            <mat-label *ngIf=\"!field.leftLabels\" class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n            <mat-select\n                class=\"adf-select\"\n                [formControl]=\"dropdownControl\"\n                [id]=\"field.id\"\n                [compareWith]=\"compareDropdownValues\"\n                [title]=\"field.tooltip\"\n                panelClass=\"adf-select-filter\"\n                [multiple]=\"field.hasMultipleValues\"\n                [required]=\"isRequired()\"\n            >\n                <adf-select-filter-input *ngIf=\"showInputFilter\" (change)=\"filter$.next($event)\" />\n\n                <mat-option *ngFor=\"let opt of list$ | async\" [value]=\"opt\" [id]=\"opt.id\">{{opt.name}}</mat-option>\n                <mat-option id=\"readonlyOption\" *ngIf=\"isReadOnlyType\" [value]=\"field.value\">{{field.value}}</mat-option>\n            </mat-select>\n        </mat-form-field>\n        <div *ngIf=\"!previewState && !field.readOnly\">\n            <error-widget\n                class=\"adf-dropdown-required-message\"\n                *ngIf=\"showRequiredMessage\"\n                required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\"\n            />\n            <error-widget\n                class=\"adf-dropdown-failed-message\"\n                *ngIf=\"isRestApiFailed\"\n                required=\"{{ 'FORM.FIELD.REST_API_FAILED' | translate: { hostname: restApiHostName } }}\"\n            />\n            <error-widget\n                class=\"adf-dropdown-failed-message\"\n                *ngIf=\"variableOptionsFailed\"\n                required=\"{{ 'FORM.FIELD.VARIABLE_DROPDOWN_OPTIONS_FAILED' | translate }}\"\n            />\n        </div>\n    </div>\n</div>\n"]}

package/esm2022/lib/form/components/widgets/dropdown/validators.mjs

@@ -0,0 +1,29 @@
+/*!
+ * @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 { DEFAULT_OPTION } from './dropdown-cloud.widget';
+export const defaultValueValidator = (filed) => (control) => {
+    const optionsWithNoDefaultValue = filed.options.filter((dropdownOption) => {
+        const isDefaultValue = dropdownOption.id === DEFAULT_OPTION.id;
+        return !isDefaultValue;
+    });
+    const isSomeOptionSelected = optionsWithNoDefaultValue.some((dropdownOption) => {
+        const isOptionSelected = dropdownOption.id === control.value?.id;
+        return isOptionSelected;
+    });
+    return isSomeOptionSelected ? null : { required: true };
+};
+//# sourceMappingURL=data:application/json;base64,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