@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/forms/shared/components/form-viewonly/form-viewonly.component.mjs

@@ -0,0 +1,50 @@
+import { Component, Input } from '@angular/core';
+import { QdFormsActionEmitterService } from '../../services/action-emitter.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/action-emitter.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+export class QdFormViewonlyComponent {
+    actionEmitterService;
+    values = [];
+    viewonlyAction;
+    testId = '-viewonly';
+    get classes() {
+        return `qd-input-viewonly${this.viewonlyAction ? ' viewonly-action' : ''}`;
+    }
+    constructor(actionEmitterService) {
+        this.actionEmitterService = actionEmitterService;
+    }
+    handleClick() {
+        if (!this.viewonlyAction)
+            return;
+        this.actionEmitterService.viewonlyEventEmitterSubject.next(null);
+    }
+    formatValue(value) {
+        if (value === '' || value === undefined || value === null) {
+            return '-';
+        }
+        return this.getTranslationKey(value);
+    }
+    getTranslationKey(value) {
+        if (!value)
+            return '';
+        if (!(typeof value === 'string'))
+            return value.i18n;
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormViewonlyComponent, deps: [{ token: i1.QdFormsActionEmitterService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFormViewonlyComponent, selector: "qd-form-viewonly", inputs: { values: "values", viewonlyAction: "viewonlyAction", testId: ["data-test-id", "testId"] }, host: { properties: { "attr.class": "classes" } }, ngImport: i0, template: "<div (click)=\"handleClick()\" *ngIf=\"values?.length > 0\">\n  <span *ngFor=\"let value of values; let last = last\">\n    {{ (formatValue(value) | translate) + (last ? \"\" : \", \") }}\n  </span>\n</div>\n\n<div *ngIf=\"!values?.length\">&nbsp;</div>\n", styles: [":host{color:#171717;font-size:.875rem;font-weight:400;line-height:1rem!important;display:block;margin-bottom:.5rem}:host.viewonly-action{color:#069;cursor:pointer}:host.viewonly-action:hover,:host.viewonly-action:active,:host.viewonly-action:focus{text-decoration:underline}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormViewonlyComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-form-viewonly', host: { '[attr.class]': 'classes' }, template: "<div (click)=\"handleClick()\" *ngIf=\"values?.length > 0\">\n  <span *ngFor=\"let value of values; let last = last\">\n    {{ (formatValue(value) | translate) + (last ? \"\" : \", \") }}\n  </span>\n</div>\n\n<div *ngIf=\"!values?.length\">&nbsp;</div>\n", styles: [":host{color:#171717;font-size:.875rem;font-weight:400;line-height:1rem!important;display:block;margin-bottom:.5rem}:host.viewonly-action{color:#069;cursor:pointer}:host.viewonly-action:hover,:host.viewonly-action:active,:host.viewonly-action:focus{text-decoration:underline}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdFormsActionEmitterService }], propDecorators: { values: [{
+                type: Input
+            }], viewonlyAction: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/shared/helpers/forms-options.helpers.mjs

@@ -0,0 +1,21 @@
+export const setOptionsByValue = (options, value) => options.map(option => {
+    if (option.value === value)
+        return { ...option, ...{ active: true } };
+    return { ...option, ...{ active: false } };
+});
+export const setOptionsByValues = (options, values) => options.map(option => {
+    if (values.indexOf(option.value) !== -1)
+        return { ...option, ...{ active: true } };
+    return { ...option, ...{ active: false } };
+});
+export const setMultiSelectOptions = (options, optionIndex) => options.map((option, index) => {
+    if (index !== optionIndex)
+        return { ...option, ...{ active: option.active || false } };
+    return { ...option, ...{ active: !option.active } };
+});
+export const setSingleSelectOptions = (options, optionIndex) => options.map((option, index) => {
+    if (index === optionIndex)
+        return { ...option, ...{ active: true } };
+    return { ...option, ...{ active: false } };
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/shared/helpers/forms.helpers.mjs

@@ -0,0 +1,87 @@
+// @ts-strict-ignore
+import _defaultTo from 'lodash/defaultTo';
+import _get from 'lodash/get';
+function get(object, path, defaultValue) {
+    return _defaultTo(_get(object, path, defaultValue), defaultValue);
+}
+/**
+ * Base form properties
+ *
+ * * @param config: QdFormConfiguration
+ */
+export const getLabel = (config) => get(config, 'label.i18n', '');
+export const getIsLabelDisabled = (config) => !!get(config, 'label', { disabled: true }).disabled;
+export const getHint = (config) => get(config, 'hint.i18n', '');
+export const getIsHintDisabled = (config) => !!get(config, 'hint', { disabled: true }).disabled;
+export const getDisabled = (config) => get(config, 'disabled', false);
+export const getReadonly = (config, defaultValue) => get(config, 'readonly', defaultValue === true);
+export const getViewonly = (config, defaultValue) => get(config, 'viewonly', defaultValue === true);
+export const getHintAction = (config) => get(config, 'hintAction', false);
+export const getReadonlyAction = (config) => get(config, 'readonlyAction', false);
+export const getViewonlyAction = (config) => get(config, 'viewonlyAction', false);
+/**
+ * Input form properties
+ *
+ * * @param config: QdFormInputConfiguration
+ */
+export const getInputType = (config) => get(config, 'inputType', 'text');
+export const getInputMode = (config) => get(config, 'inputMode', null);
+export const getClearable = (config) => get(config, 'clearable', false);
+export const getValue = (config) => get(config, 'value', '');
+export const getPlaceholder = (config) => get(config, 'placeholder.i18n', '');
+export const getHasAutofocus = (config) => get(config, 'hasAutofocus', false);
+/**
+ * Textarea form properties
+ *
+ * * @param config: QdFormTextAreaConfiguration
+ */
+export const getRows = (config) => get(config, 'rows', 4);
+/**
+ * Checkboxes form properties
+ *
+ * * @param config: QdFormCheckboxesConfiguration
+ */
+export const getCheckboxesOptions = (config) => get(config, 'options', []);
+export const getCheckboxesFilter = (config) => get(config, 'filter', false);
+export const getCheckboxesAlign = (config) => get(config, 'align', 'horizontal');
+/**
+ * Dropdown form properties
+ *
+ * * @param config: QdFormDropdownConfiguration
+ */
+export const getDropdownFilter = (config) => get(config, 'filter', false);
+export const getDropdownOptions = (config) => get(config, 'options', []);
+/**
+ * MultiInput form properties
+ *
+ * * @param config: QdFormMultiInputConfiguration
+ */
+export const getMultiInputOptions = (config) => get(config, 'options', []);
+/**
+ * Pincode form properties
+ *
+ * * @param config: QdFormPinCodeConfiguration
+ */
+export const getDigitsOnly = (config) => get(config, 'digitsOnly', false);
+export const getCodeLength = (config) => get(config, 'codeLength', 6);
+export const getFocusOnInit = (config) => get(config, 'focusOnInit', false);
+export const getCodeHidden = (config) => get(config, 'codeHidden', false);
+/**
+ * Common Checkboxes & Radiobuttons form properties
+ *
+ * * @param config: QdFormCheckboxesConfiguration | QdFormRadioButtonsConfiguration
+ */
+export const getAlign = (config) => get(config, 'align', 'horizontal');
+/**
+ * Common Checkboxes, Dropdown & Radiobuttons form properties
+ *
+ * * @param config: QdFormCheckboxesConfiguration | QdFormDropdownConfiguration | QdFormRadioButtonsConfiguration
+ */
+export const getFilter = (config) => get(config, 'filter', false);
+/**
+ * Common Checkboxes, CheckboxChips, Dropdown & Radiobuttons form properties
+ *
+ * * @param config: QdFormCheckboxesConfiguration | QdFormCheckboxChipsConfiguration | QdFormDropdownConfiguration | QdFormRadioButtonsConfiguration
+ */
+export const getOptions = (config) => get(config, 'options', []);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forms.helpers.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/forms/shared/helpers/forms.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport _defaultTo from 'lodash/defaultTo';\nimport _get from 'lodash/get';\n\nimport {\n  QdFormCheckboxChipsConfiguration,\n  QdFormCheckboxesConfiguration,\n  QdFormConfiguration,\n  QdFormDropdownConfiguration,\n  QdFormInputConfiguration,\n  QdFormMultiInputConfiguration,\n  QdFormOption,\n  QdFormPinCodeConfiguration,\n  QdFormRadioButtonsConfiguration,\n  QdFormTextAreaConfiguration,\n  QdInputMode,\n  QdInputType,\n  QdInputValue,\n  QdMultiInputOption\n} from '../../model/forms.interface';\n\nfunction get(object: object, path: string, defaultValue: any): any {\n  return _defaultTo(_get(object, path, defaultValue), defaultValue);\n}\n\n/**\n * Base form properties\n *\n * * @param config: QdFormConfiguration\n */\nexport const getLabel = (config: QdFormConfiguration): string => get(config, 'label.i18n', '');\n\nexport const getIsLabelDisabled = (config: QdFormConfiguration): boolean =>\n  !!get(config, 'label', { disabled: true }).disabled;\n\nexport const getHint = (config: QdFormConfiguration): string => get(config, 'hint.i18n', '');\n\nexport const getIsHintDisabled = (config: QdFormConfiguration): boolean =>\n  !!get(config, 'hint', { disabled: true }).disabled;\n\nexport const getDisabled = (config: QdFormConfiguration): boolean => get(config, 'disabled', false);\n\nexport const getReadonly = (config: QdFormConfiguration, defaultValue?: boolean): boolean =>\n  get(config, 'readonly', defaultValue === true);\n\nexport const getViewonly = (config: QdFormConfiguration, defaultValue?: boolean): boolean =>\n  get(config, 'viewonly', defaultValue === true);\n\nexport const getHintAction = (config: QdFormConfiguration): boolean => get(config, 'hintAction', false);\n\nexport const getReadonlyAction = (config: QdFormConfiguration): boolean => get(config, 'readonlyAction', false);\n\nexport const getViewonlyAction = (config: QdFormConfiguration): boolean => get(config, 'viewonlyAction', false);\n\n/**\n * Input form properties\n *\n * * @param config: QdFormInputConfiguration\n */\nexport const getInputType = (config: QdFormInputConfiguration): QdInputType => get(config, 'inputType', 'text');\n\nexport const getInputMode = (config: QdFormInputConfiguration): QdInputMode => get(config, 'inputMode', null);\n\nexport const getClearable = (config: QdFormInputConfiguration): boolean => get(config, 'clearable', false);\n\nexport const getValue = (config: QdFormInputConfiguration | QdFormTextAreaConfiguration): QdInputValue =>\n  get(config, 'value', '');\n\nexport const getPlaceholder = (config: QdFormInputConfiguration | QdFormTextAreaConfiguration): string =>\n  get(config, 'placeholder.i18n', '');\n\nexport const getHasAutofocus = (config: QdFormInputConfiguration): boolean => get(config, 'hasAutofocus', false);\n\n/**\n * Textarea form properties\n *\n * * @param config: QdFormTextAreaConfiguration\n */\nexport const getRows = (config: QdFormTextAreaConfiguration): number => get(config, 'rows', 4);\n\n/**\n * Checkboxes form properties\n *\n * * @param config: QdFormCheckboxesConfiguration\n */\nexport const getCheckboxesOptions = (config: QdFormCheckboxesConfiguration): QdFormOption[] =>\n  get(config, 'options', []);\n\nexport const getCheckboxesFilter = (config: QdFormCheckboxesConfiguration): boolean => get(config, 'filter', false);\n\nexport const getCheckboxesAlign = (config: QdFormCheckboxesConfiguration): string => get(config, 'align', 'horizontal');\n\n/**\n * Dropdown form properties\n *\n * * @param config: QdFormDropdownConfiguration\n */\nexport const getDropdownFilter = (config: QdFormDropdownConfiguration): boolean => get(config, 'filter', false);\n\nexport const getDropdownOptions = (config: QdFormDropdownConfiguration): QdFormOption[] => get(config, 'options', []);\n\n/**\n * MultiInput form properties\n *\n * * @param config: QdFormMultiInputConfiguration\n */\nexport const getMultiInputOptions = (config: QdFormMultiInputConfiguration): QdMultiInputOption[] =>\n  get(config, 'options', []);\n\n/**\n * Pincode form properties\n *\n * * @param config: QdFormPinCodeConfiguration\n */\nexport const getDigitsOnly = (config: QdFormPinCodeConfiguration): boolean => get(config, 'digitsOnly', false);\n\nexport const getCodeLength = (config: QdFormPinCodeConfiguration): number => get(config, 'codeLength', 6);\n\nexport const getFocusOnInit = (config: QdFormPinCodeConfiguration): boolean => get(config, 'focusOnInit', false);\n\nexport const getCodeHidden = (config: QdFormPinCodeConfiguration): boolean => get(config, 'codeHidden', false);\n\n/**\n * Common Checkboxes & Radiobuttons form properties\n *\n * * @param config: QdFormCheckboxesConfiguration | QdFormRadioButtonsConfiguration\n */\nexport const getAlign = (\n  config: QdFormCheckboxesConfiguration | QdFormRadioButtonsConfiguration\n): 'vertical' | 'horizontal' => get(config, 'align', 'horizontal');\n\n/**\n * Common Checkboxes, Dropdown & Radiobuttons form properties\n *\n * * @param config: QdFormCheckboxesConfiguration | QdFormDropdownConfiguration | QdFormRadioButtonsConfiguration\n */\nexport const getFilter = (\n  config: QdFormCheckboxesConfiguration | QdFormDropdownConfiguration | QdFormRadioButtonsConfiguration\n): boolean => get(config, 'filter', false);\n\n/**\n * Common Checkboxes, CheckboxChips, Dropdown & Radiobuttons form properties\n *\n * * @param config: QdFormCheckboxesConfiguration | QdFormCheckboxChipsConfiguration | QdFormDropdownConfiguration | QdFormRadioButtonsConfiguration\n */\nexport const getOptions = (\n  config:\n    | QdFormCheckboxesConfiguration\n    | QdFormCheckboxChipsConfiguration\n    | QdFormDropdownConfiguration\n    | QdFormRadioButtonsConfiguration\n): QdFormOption[] => get(config, 'options', []);\n"]}

package/esm2022/lib/forms/shared/helpers/has-validators.helpers.mjs

@@ -0,0 +1,10 @@
+export const hasValidationKey = (abstractControl, validationKey) => {
+    if (abstractControl.validator) {
+        const validator = abstractControl.validator({});
+        if (validator && validator[validationKey]) {
+            return true;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzLXZhbGlkYXRvcnMuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9mb3Jtcy9zaGFyZWQvaGVscGVycy9oYXMtdmFsaWRhdG9ycy5oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsZUFBZ0MsRUFBRSxhQUFxQixFQUFXLEVBQUU7SUFDbkcsSUFBSSxlQUFlLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDOUIsTUFBTSxTQUFTLEdBQUcsZUFBZSxDQUFDLFNBQVMsQ0FBQyxFQUFxQixDQUFDLENBQUM7UUFFbkUsSUFBSSxTQUFTLElBQUksU0FBUyxDQUFDLGFBQWEsQ0FBQyxFQUFFLENBQUM7WUFDMUMsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5leHBvcnQgY29uc3QgaGFzVmFsaWRhdGlvbktleSA9IChhYnN0cmFjdENvbnRyb2w6IEFic3RyYWN0Q29udHJvbCwgdmFsaWRhdGlvbktleTogc3RyaW5nKTogYm9vbGVhbiA9PiB7XG4gIGlmIChhYnN0cmFjdENvbnRyb2wudmFsaWRhdG9yKSB7XG4gICAgY29uc3QgdmFsaWRhdG9yID0gYWJzdHJhY3RDb250cm9sLnZhbGlkYXRvcih7fSBhcyBBYnN0cmFjdENvbnRyb2wpO1xuXG4gICAgaWYgKHZhbGlkYXRvciAmJiB2YWxpZGF0b3JbdmFsaWRhdGlvbktleV0pIHtcbiAgICAgIHJldHVybiB0cnVlO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBmYWxzZTtcbn07XG4iXX0=

package/esm2022/lib/forms/shared/services/action-emitter.service.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class QdFormsActionEmitterService {
+    hintEventEmitterSubject = new Subject();
+    readonlyEventEmitterSubject = new Subject();
+    viewonlyEventEmitterSubject = new Subject();
+    hintEventEmitter$ = this.hintEventEmitterSubject.asObservable();
+    readonlyEventEmitter$ = this.readonlyEventEmitterSubject.asObservable();
+    viewonlyEventEmitter$ = this.viewonlyEventEmitterSubject.asObservable();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormsActionEmitterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormsActionEmitterService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormsActionEmitterService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLWVtaXR0ZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9mb3Jtcy9zaGFyZWQvc2VydmljZXMvYWN0aW9uLWVtaXR0ZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBRy9CLE1BQU0sT0FBTywyQkFBMkI7SUFDdEMsdUJBQXVCLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztJQUM5QywyQkFBMkIsR0FBRyxJQUFJLE9BQU8sRUFBUSxDQUFDO0lBQ2xELDJCQUEyQixHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7SUFFbEQsaUJBQWlCLEdBQUcsSUFBSSxDQUFDLHVCQUF1QixDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ2hFLHFCQUFxQixHQUFHLElBQUksQ0FBQywyQkFBMkIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUN4RSxxQkFBcUIsR0FBRyxJQUFJLENBQUMsMkJBQTJCLENBQUMsWUFBWSxFQUFFLENBQUM7dUdBUDdELDJCQUEyQjsyR0FBM0IsMkJBQTJCOzsyRkFBM0IsMkJBQTJCO2tCQUR2QyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgUWRGb3Jtc0FjdGlvbkVtaXR0ZXJTZXJ2aWNlIHtcbiAgaGludEV2ZW50RW1pdHRlclN1YmplY3QgPSBuZXcgU3ViamVjdDxudWxsPigpO1xuICByZWFkb25seUV2ZW50RW1pdHRlclN1YmplY3QgPSBuZXcgU3ViamVjdDxudWxsPigpO1xuICB2aWV3b25seUV2ZW50RW1pdHRlclN1YmplY3QgPSBuZXcgU3ViamVjdDxudWxsPigpO1xuXG4gIGhpbnRFdmVudEVtaXR0ZXIkID0gdGhpcy5oaW50RXZlbnRFbWl0dGVyU3ViamVjdC5hc09ic2VydmFibGUoKTtcbiAgcmVhZG9ubHlFdmVudEVtaXR0ZXIkID0gdGhpcy5yZWFkb25seUV2ZW50RW1pdHRlclN1YmplY3QuYXNPYnNlcnZhYmxlKCk7XG4gIHZpZXdvbmx5RXZlbnRFbWl0dGVyJCA9IHRoaXMudmlld29ubHlFdmVudEVtaXR0ZXJTdWJqZWN0LmFzT2JzZXJ2YWJsZSgpO1xufVxuIl19

package/esm2022/lib/forms/shared/services/form-keyboard.service.mjs

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import * as i0 from "@angular/core";
+export class QdFormKeyboardService {
+    _keyManager;
+    _components = [];
+    init(components) {
+        const setupKeyManager = () => {
+            this._components = components.toArray();
+            this._keyManager = new ActiveDescendantKeyManager(components)
+                .withWrap()
+                .withTypeAhead()
+                .skipPredicate(item => item.option?.disabled ?? false);
+            if (this._components.length)
+                setTimeout(() => this._keyManager?.setFirstItemActive());
+        };
+        if (components.length)
+            setupKeyManager();
+        components.changes.subscribe(() => setupKeyManager());
+    }
+    handleKeydown(event) {
+        this._keyManager?.onKeydown(event);
+        this._keyManager?.activeItem?.scrollIntoView();
+    }
+    focusFirstOption() {
+        if (!this._keyManager)
+            return;
+        this._keyManager.setFirstItemActive();
+        this._keyManager.activeItem?.scrollIntoView();
+    }
+    getActiveOption() {
+        return this._keyManager?.activeItem ?? null;
+    }
+    setActiveOptionByValue(value) {
+        if (!this._keyManager || this.getActiveOption())
+            return;
+        const index = this._components.findIndex(c => c.option?.value === value);
+        if (index >= 0) {
+            this._keyManager.setActiveItem(index);
+            this._keyManager.activeItem?.scrollIntoView();
+        }
+    }
+    reset() {
+        this._keyManager = undefined;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormKeyboardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormKeyboardService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormKeyboardService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/shared/services/form-options.service.mjs

@@ -0,0 +1,102 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, NEVER, Subject } from 'rxjs';
+import { catchError, take, takeUntil } from 'rxjs/operators';
+import { TranslateService } from '@ngx-translate/core';
+import { qdDelayAndHold } from '../../../core/rxjs/delay-and-hold.operator';
+import { QdFormOptionsResolverRegistry } from './options-resolver.registry';
+import { QdFormOptionsRequestState } from '../../model/form-options-resolver';
+import * as i0 from "@angular/core";
+import * as i1 from "./options-resolver.registry";
+import * as i2 from "@ngx-translate/core";
+export class QdFormOptionsService {
+    resolverRegistry;
+    translate;
+    _options = new BehaviorSubject([]);
+    _requestState = new BehaviorSubject(QdFormOptionsRequestState.IDLE);
+    _resolver = null;
+    _destroyed$ = new Subject();
+    _lastLoadedValue = null;
+    _config = null;
+    constructor(resolverRegistry, translate) {
+        this.resolverRegistry = resolverRegistry;
+        this.translate = translate;
+    }
+    filteredOptions$ = this._options.asObservable();
+    requestState$ = this._requestState.asObservable();
+    delayedRequestState$ = this.requestState$.pipe(qdDelayAndHold());
+    ngOnDestroy() {
+        this._destroyed$.next(true);
+        this._destroyed$.complete();
+    }
+    initialize(config) {
+        this._config = config;
+        this.resolverRegistry.initialize(config.optionsResolverName);
+        this._resolver = this.resolverRegistry.findResolver();
+        this.load('');
+    }
+    updateStaticOptions(options) {
+        if (!this._config)
+            return;
+        this._config.options = options.map(opt => ({ ...opt }));
+        const lastValue = this._lastLoadedValue ?? '';
+        this.filterStaticOptions(lastValue, this._config.options);
+    }
+    hasOptions() {
+        if (!this._config)
+            return false;
+        const hasStatic = (this._config.options?.length ?? 0) > 0;
+        const hasDynamic = !!this._resolver;
+        return hasStatic || hasDynamic;
+    }
+    hasResolver() {
+        return !!this._resolver;
+    }
+    validateOptionsSetup(componentName) {
+        if (!this.hasOptions())
+            console.warn(`QD-UI | ${componentName} - No options defined. Either provide 'options' or configure a resolver via 'optionsResolverName'.`);
+        if (this._config?.options?.length && this._resolver)
+            console.warn(`QD-UI | ${componentName} - Config key 'options' ignored because QD_FORM_OPTIONS_RESOLVER is configured.`);
+    }
+    load(value) {
+        if (value === this._lastLoadedValue)
+            return;
+        this._lastLoadedValue = value;
+        this.reset();
+        if (this._resolver) {
+            this.loadFromResolver(value);
+        }
+        else {
+            this.filterStaticOptions(value, this._config?.options || []);
+        }
+    }
+    reset() {
+        this._options.next([]);
+        this._requestState.next(QdFormOptionsRequestState.IDLE);
+    }
+    loadFromResolver(value) {
+        this._requestState.next(QdFormOptionsRequestState.PENDING);
+        this._resolver.resolve(value.toString())
+            .pipe(take(1), takeUntil(this._destroyed$), catchError(() => {
+            this._requestState.next(QdFormOptionsRequestState.ERROR);
+            return NEVER;
+        }))
+            .subscribe((options) => {
+            this._options.next(options);
+            this._requestState.next(QdFormOptionsRequestState.SUCCESS);
+        });
+    }
+    filterStaticOptions(value, options) {
+        const input = value.toString().toLowerCase();
+        const filtered = options
+            .filter(opt => this.translate.instant(opt.i18n).toLowerCase().includes(input))
+            .map(opt => ({ ...opt, disabled: opt.disabled ?? false }));
+        this._options.next(filtered);
+        this._requestState.next(QdFormOptionsRequestState.SUCCESS);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormOptionsService, deps: [{ token: i1.QdFormOptionsResolverRegistry }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormOptionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormOptionsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.QdFormOptionsResolverRegistry }, { type: i2.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-options.service.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/forms/shared/services/form-options.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { BehaviorSubject, NEVER, Observable, Subject } from 'rxjs';\nimport { catchError, take, takeUntil } from 'rxjs/operators';\nimport { TranslateService } from '@ngx-translate/core';\n\nimport { qdDelayAndHold } from '../../../core/rxjs/delay-and-hold.operator';\n\nimport { QdFormOptionsResolverRegistry } from './options-resolver.registry';\nimport {\n  QdFormOptionsRequestState,\n  QdFormOptionsResolver,\n  QdFormResolvedOption\n} from '../../model/form-options-resolver';\nimport { QdFormInputConfiguration, QdFormOption, QdInputValue } from '../../model/forms.interface';\n\n@Injectable()\nexport class QdFormOptionsService implements OnDestroy {\n  private readonly _options = new BehaviorSubject<QdFormResolvedOption[]>([]);\n  private readonly _requestState = new BehaviorSubject<QdFormOptionsRequestState>(QdFormOptionsRequestState.IDLE);\n\n  private _resolver: QdFormOptionsResolver | null = null;\n  private _destroyed$ = new Subject<boolean>();\n  private _lastLoadedValue: QdInputValue | null = null;\n  private _config: QdFormInputConfiguration | null = null;\n\n  constructor(\n    private readonly resolverRegistry: QdFormOptionsResolverRegistry,\n    private readonly translate: TranslateService\n  ) {}\n\n  readonly filteredOptions$ = this._options.asObservable();\n  readonly requestState$ = this._requestState.asObservable();\n\n  readonly delayedRequestState$: Observable<QdFormOptionsRequestState> = this.requestState$.pipe(\n    qdDelayAndHold<QdFormOptionsRequestState>()\n  );\n\n  ngOnDestroy(): void {\n    this._destroyed$.next(true);\n    this._destroyed$.complete();\n  }\n\n  initialize(config: QdFormInputConfiguration): void {\n    this._config = config;\n    this.resolverRegistry.initialize(config.optionsResolverName);\n    this._resolver = this.resolverRegistry.findResolver();\n    this.load('');\n  }\n\n  updateStaticOptions(options: QdFormOption[]): void {\n    if (!this._config) return;\n\n    this._config.options = options.map(opt => ({ ...opt }));\n\n    const lastValue = this._lastLoadedValue ?? '';\n    this.filterStaticOptions(lastValue, this._config.options);\n  }\n\n  hasOptions(): boolean {\n    if (!this._config) return false;\n\n    const hasStatic = (this._config.options?.length ?? 0) > 0;\n    const hasDynamic = !!this._resolver;\n\n    return hasStatic || hasDynamic;\n  }\n\n  hasResolver(): boolean {\n    return !!this._resolver;\n  }\n\n  validateOptionsSetup(componentName: string): void {\n    if (!this.hasOptions())\n      console.warn(\n        `QD-UI | ${componentName} - No options defined. Either provide 'options' or configure a resolver via 'optionsResolverName'.`\n      );\n\n    if (this._config?.options?.length && this._resolver)\n      console.warn(\n        `QD-UI | ${componentName} - Config key 'options' ignored because QD_FORM_OPTIONS_RESOLVER is configured.`\n      );\n  }\n\n  load(value: QdInputValue): void {\n    if (value === this._lastLoadedValue) return;\n\n    this._lastLoadedValue = value;\n    this.reset();\n\n    if (this._resolver) {\n      this.loadFromResolver(value);\n    } else {\n      this.filterStaticOptions(value, this._config?.options || []);\n    }\n  }\n\n  reset(): void {\n    this._options.next([]);\n    this._requestState.next(QdFormOptionsRequestState.IDLE);\n  }\n\n  private loadFromResolver(value: QdInputValue): void {\n    this._requestState.next(QdFormOptionsRequestState.PENDING);\n\n    this._resolver!.resolve(value.toString())\n      .pipe(\n        take(1),\n        takeUntil(this._destroyed$),\n\n        catchError(() => {\n          this._requestState.next(QdFormOptionsRequestState.ERROR);\n          return NEVER;\n        })\n      )\n      .subscribe((options: QdFormResolvedOption[]) => {\n        this._options.next(options);\n        this._requestState.next(QdFormOptionsRequestState.SUCCESS);\n      });\n  }\n\n  private filterStaticOptions(value: QdInputValue, options: QdFormOption[]): void {\n    const input = value.toString().toLowerCase();\n    const filtered = options\n      .filter(opt => this.translate.instant(opt.i18n).toLowerCase().includes(input))\n      .map(opt => ({ ...opt, disabled: opt.disabled ?? false }));\n\n    this._options.next(filtered);\n    this._requestState.next(QdFormOptionsRequestState.SUCCESS);\n  }\n}\n"]}

package/esm2022/lib/forms/shared/services/options-resolver.registry.mjs

@@ -0,0 +1,32 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { QD_FORM_OPTIONS_RESOLVER } from '../../model/form-options-resolver';
+import * as i0 from "@angular/core";
+export class QdFormOptionsResolverRegistry {
+    resolverName;
+    resolvers;
+    constructor(providedResolvers) {
+        this.resolvers = Array.isArray(providedResolvers) ? providedResolvers : [providedResolvers];
+    }
+    initialize(name) {
+        this.resolverName = name;
+    }
+    findResolver() {
+        if (!this.resolverName)
+            return null;
+        const matches = this.resolvers.filter(r => r?.name === this.resolverName);
+        if (matches.length > 1)
+            throw new Error(`QD-UI | QdForms - Multiple QdFormOptionsResolvers with the name "${this.resolverName}" found. Resolver names must be unique.`);
+        return matches[0] ?? null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormOptionsResolverRegistry, deps: [{ token: QD_FORM_OPTIONS_RESOLVER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormOptionsResolverRegistry });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormOptionsResolverRegistry, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [QD_FORM_OPTIONS_RESOLVER]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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