@qualcomm-ui/angular-core 1.0.2 → 1.0.4

package/fesm2022/qualcomm-ui-angular-core-input.mjs

@@ -0,0 +1,598 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, signal, computed, input, booleanAttribute, Injector, linkedSignal, afterNextRender, isDevMode, effect, runInInjectionContext, Directive } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { NgControl, NgModel, Validators, PristineChangeEvent, FormSubmittedEvent, NgForm, FormGroupDirective } from '@angular/forms';
+import { useOnDestroy } from '@qualcomm-ui/angular-core/common';
+import { allEventsSignal } from '@qualcomm-ui/angular-core/forms';
+import { defined, isDefined } from '@qualcomm-ui/utils/guard';
+import '@qualcomm-ui/utils/collection';
+
+// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+const defaultErrors = {
+    email: () => "Invalid email",
+    max: (err) => `Max: ${err.max}`,
+    maxLength: (err) => `Max length: ${err.maxLength}`,
+    min: (err) => `Min: ${err.min}`,
+    minLength: (err) => `Min length: ${err.requiredLength}`,
+    pattern: () => "Invalid format",
+    required: () => "This field is required",
+    requiredTrue: () => "Required",
+};
+/**
+ * Override the default error messages for known form control errors.
+ *
+ * The defaults are as follows:
+ * ```angular-html
+ * const defaultKnownErrors: FormControlKnownErrors = {
+ *   email: () => "Invalid email",
+ *   max: (err) => `Max: ${err.max}`,
+ *   maxLength: (err) => `Max length: ${err.maxLength}`,
+ *   min: (err) => `Min: ${err.min}`,
+ *   minLength: (err) => `Min length: ${err.requiredLength}`,
+ *   pattern: () => "Invalid format",
+ *   required: () => "This field is required",
+ *   requiredTrue: () => "This field is required",
+ * }
+ * ```
+ */
+const FORM_CONTROL_ERROR_MESSAGE_PROVIDER = new InjectionToken("FormControlErrorProvider");
+const INPUT_FORM_CONTROL_CONTEXT = new InjectionToken("InputFormControl");
+function initInputFormControl() {
+    const ngControl = inject(NgControl, {
+        optional: true,
+        self: true,
+    });
+    const knownErrors = {
+        ...defaultErrors,
+        ...(inject(FORM_CONTROL_ERROR_MESSAGE_PROVIDER, { optional: true }) ?? {}),
+    };
+    const formEventData = signal(null, ...(ngDevMode ? [{ debugName: "formEventData" }] : []));
+    function isTemplateDrivenForm() {
+        return ngControl instanceof NgModel;
+    }
+    function isReactiveForm() {
+        // Any NgControl that is *not* NgModel belongs to the reactive-forms package
+        return !!ngControl && !isTemplateDrivenForm();
+    }
+    return {
+        control: ngControl?.control ?? null,
+        errorText: computed(() => {
+            // make this reactive so that the error message is updated when the form state
+            // changes.
+            formEventData();
+            const errors = ngControl?.control?.errors ?? {};
+            const [errorKey, errorValue] = Object.entries(errors)[0] ?? [];
+            if (errorKey && knownErrors[errorKey]) {
+                return knownErrors[errorKey](errorValue);
+            }
+            return errors["errorText"] ?? errors["error"] ?? null;
+        }),
+        formEventData,
+        isReactiveForm,
+        isTemplateDrivenForm,
+        ngControl,
+    };
+}
+
+// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+class AbstractInputFormControlDirective {
+    /**
+     * The initial state of the input when rendered. Use when you don't
+     * need to control the checked state of the input. This property will be
+     * ignored if you opt into controlled state via form control bindings.
+     */
+    defaultValue = input(undefined, ...(ngDevMode ? [{ debugName: "defaultValue" }] : []));
+    /**
+     * Controls whether the input is disabled in template-driven forms. When true,
+     * prevents user interaction and applies visual styling to indicate the disabled
+     * state.
+     */
+    disabled = input(undefined, ...(ngDevMode ? [{ debugName: "disabled", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /**
+     * Controls the visual error state of the input. When true, applies semantic error
+     * styling to indicate validation failure.
+     */
+    invalid = input(undefined, ...(ngDevMode ? [{ debugName: "invalid", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /**
+     * The name of the input field. Useful for form submission.
+     */
+    name = input(...(ngDevMode ? [undefined, { debugName: "name" }] : []));
+    /**
+     * Whether the input is read-only. When true, prevents user interaction while
+     * keeping the input focusable and visible.
+     */
+    readOnly = input(undefined, ...(ngDevMode ? [{ debugName: "readOnly", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /**
+     * Controls whether the input is required in template-driven forms. When
+     * true, the input must have a value for form validation to pass.
+     */
+    required = input(undefined, ...(ngDevMode ? [{ debugName: "required", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /* the internal "value" state of the input */
+    value = signal("", ...(ngDevMode ? [{ debugName: "value" }] : []));
+    onDestroy = useOnDestroy();
+    injector = inject(Injector);
+    formControlStatus = signal(undefined, ...(ngDevMode ? [{ debugName: "formControlStatus" }] : []));
+    formSubmitted = signal(false, ...(ngDevMode ? [{ debugName: "formSubmitted" }] : []));
+    formControlContext = initInputFormControl();
+    /**
+     * If the component is bound to an Angular AbstractControl, its state wins.
+     * If not, fall back to the host attribute.
+     */
+    isDisabled = linkedSignal(() => {
+        /**
+         * When the component is bound to any AbstractControl, status is guaranteed to
+         * be non-undefined.
+         */
+        const status = this.formControlStatus();
+        const disabled = this.disabled();
+        if (status !== undefined) {
+            return status === "DISABLED";
+        }
+        return !!disabled;
+    }, ...(ngDevMode ? [{ debugName: "isDisabled" }] : []));
+    isInvalid = computed(() => {
+        const formEventData = this.formControlContext.formEventData();
+        this.formSubmitted();
+        const isInvalidDefined = defined(this.invalid());
+        const invalidProp = this.invalid() || false;
+        if (!this.control) {
+            return invalidProp;
+        }
+        let invalid, touched, dirty;
+        if (this.formControlContext.isTemplateDrivenForm()) {
+            invalid = isInvalidDefined ? invalidProp : this.control.invalid;
+            touched = this.control.touched;
+            dirty = this.control.dirty;
+        }
+        else if (formEventData) {
+            invalid = formEventData.invalid;
+            touched = formEventData.touched;
+            dirty = formEventData.dirty;
+        }
+        else {
+            return invalidProp;
+        }
+        switch (this.control.updateOn) {
+            case "submit":
+                return invalid;
+            case "blur":
+                return invalid && touched;
+            default:
+                // "change"
+                return dirty && invalid;
+        }
+    }, ...(ngDevMode ? [{ debugName: "isInvalid" }] : []));
+    isRequired = linkedSignal(() => {
+        const control = this.control;
+        const required = this.required();
+        if (!control || !this.formControlContext.isReactiveForm()) {
+            return required;
+        }
+        if (typeof control.hasValidator === "function") {
+            return (control.hasValidator(Validators.required) ||
+                control.hasValidator(Validators.requiredTrue));
+        }
+        return false;
+    }, ...(ngDevMode ? [{ debugName: "isRequired" }] : []));
+    constructor() {
+        if (this.formControlContext.ngControl) {
+            this.formControlContext.ngControl.valueAccessor = this;
+            this.value.set(this.formControlContext.ngControl.control?.value || "");
+        }
+        afterNextRender(() => {
+            if (isDefined(this.required()) &&
+                this.formControlContext.isReactiveForm() &&
+                isDevMode()) {
+                console.warn("The required attribute is not supported on reactive forms. Use Validators instead. https://angular.dev/guide/forms/form-validation#validating-input-in-reactive-forms");
+            }
+        });
+        effect(() => {
+            const required = this.required();
+            if (this.control && this.formControlContext.isTemplateDrivenForm()) {
+                if (required) {
+                    this.control.addValidators(Validators.required);
+                }
+                else if (this.control.hasValidator(Validators.required)) {
+                    this.control.removeValidators(Validators.required);
+                }
+            }
+        });
+    }
+    ngOnInit() {
+        // Ensure the form control receives the initial value
+        const defaultValue = this.defaultValue();
+        if (!this.control && defaultValue) {
+            this.value.set(defaultValue);
+        }
+        else if (this.control) {
+            const subscription = this.control.statusChanges.subscribe((status) => {
+                this.formControlStatus.set(status);
+            });
+            this.onDestroy(() => {
+                subscription.unsubscribe();
+            });
+            const parent = this.getParentForm();
+            runInInjectionContext(this.injector, () => {
+                if (this.control) {
+                    const formSignal = allEventsSignal(this.control);
+                    effect(() => {
+                        this.formControlContext.formEventData.set(formSignal());
+                    });
+                }
+                if (parent) {
+                    let prevPristine = this.control?.pristine || false;
+                    parent.form.events.pipe(takeUntilDestroyed()).subscribe((event) => {
+                        if (event instanceof PristineChangeEvent) {
+                            if (event.pristine && !prevPristine) {
+                                // if this event fires with pristine status and the control was
+                                // previously not pristine, this means that the form was reset. There
+                                // isn't another way to determine form resets programmatically,
+                                // unfortunately.
+                                this.formSubmitted.set(false);
+                            }
+                            prevPristine = event.pristine;
+                        }
+                        else if (event instanceof FormSubmittedEvent) {
+                            this.formSubmitted.set(true);
+                            this.control?.markAsDirty();
+                        }
+                    });
+                    parent.ngSubmit.pipe(takeUntilDestroyed()).subscribe(() => {
+                        if (this.formControlContext.isReactiveForm()) {
+                            // already accounted for in the above event subscription.
+                            return;
+                        }
+                        this.formSubmitted.set(true);
+                        this.control?.markAsDirty();
+                    });
+                }
+            });
+        }
+    }
+    /** Convenience access to the underlying AbstractControl (can be null). */
+    get control() {
+        return this.formControlContext.ngControl?.control ?? null;
+    }
+    /**
+     * Used to subscribe to form submit events.
+     */
+    getParentForm() {
+        if (!this.control) {
+            return null;
+        }
+        // Try to find NgForm first
+        try {
+            const ngForm = this.injector.get(NgForm, null);
+            if (ngForm) {
+                return ngForm;
+            }
+        }
+        catch { }
+        // Fall back to FormGroupDirective
+        try {
+            const formGroupDirective = this.injector.get(FormGroupDirective, null);
+            if (formGroupDirective) {
+                return formGroupDirective;
+            }
+        }
+        catch { }
+        return null;
+    }
+    /*
+     * Control value accessor methods
+     */
+    writeValue(value) {
+        this.value.set(value);
+    }
+    // placeholder
+    onChange = (_value) => { };
+    registerOnChange(fn) {
+        this.onChange = (_value) => {
+            fn(_value);
+            this.value.set(_value);
+        };
+    }
+    onTouched = () => { };
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * NgModel never calls setDisabledState, but ReactiveForms does. Everything else
+     * (writeValue, registerOnChange, registerOnTouched) is identical between Reactive
+     * and Template forms.
+     */
+    setDisabledState(isDisabled) {
+        this.isDisabled.set(isDisabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AbstractInputFormControlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.12", type: AbstractInputFormControlDirective, isStandalone: true, inputs: { defaultValue: { classPropertyName: "defaultValue", publicName: "defaultValue", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, invalid: { classPropertyName: "invalid", publicName: "invalid", isSignal: true, isRequired: false, transformFunction: null }, name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: false, transformFunction: null }, readOnly: { classPropertyName: "readOnly", publicName: "readOnly", isSignal: true, isRequired: false, transformFunction: null }, required: { classPropertyName: "required", publicName: "required", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AbstractInputFormControlDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { defaultValue: [{ type: i0.Input, args: [{ isSignal: true, alias: "defaultValue", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], invalid: [{ type: i0.Input, args: [{ isSignal: true, alias: "invalid", required: false }] }], name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: false }] }], readOnly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readOnly", required: false }] }], required: [{ type: i0.Input, args: [{ isSignal: true, alias: "required", required: false }] }] } });
+
+// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+class AbstractListCollectionFormControlDirective {
+    /**
+     * The item collection
+     *
+     * @inheritDoc
+     */
+    collection = input.required(...(ngDevMode ? [{ debugName: "collection" }] : []));
+    /**
+     * The initial state of the input when rendered. Use when you don't need to
+     * control the checked state of the input. This property will be ignored if you
+     * opt into controlled state via form control bindings.
+     *
+     * @inheritDoc
+     */
+    defaultValue = input(undefined, ...(ngDevMode ? [{ debugName: "defaultValue" }] : []));
+    /**
+     * Controls whether the input is disabled in template-driven forms. When true,
+     * prevents user interaction and applies visual styling to indicate the disabled
+     * state.
+     */
+    disabled = input(undefined, ...(ngDevMode ? [{ debugName: "disabled", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /**
+     * Controls the visual error state of the input. When true, applies semantic error
+     * styling to indicate validation failure.
+     */
+    invalid = input(undefined, ...(ngDevMode ? [{ debugName: "invalid", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /**
+     * The name of the input field. Useful for form submission.
+     */
+    name = input(...(ngDevMode ? [undefined, { debugName: "name" }] : []));
+    /**
+     * Whether the input is read-only. When true, prevents user interaction while
+     * keeping the input focusable and visible.
+     */
+    readOnly = input(undefined, ...(ngDevMode ? [{ debugName: "readOnly", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /**
+     * Controls whether the input is required in template-driven forms. When
+     * true, the input must have a value for form validation to pass.
+     */
+    required = input(undefined, ...(ngDevMode ? [{ debugName: "required", transform: booleanAttribute }] : [{
+            transform: booleanAttribute,
+        }]));
+    /* the internal "value" state of the input */
+    value = signal([], ...(ngDevMode ? [{ debugName: "value" }] : []));
+    onDestroy = useOnDestroy();
+    injector = inject(Injector);
+    formControlStatus = signal(undefined, ...(ngDevMode ? [{ debugName: "formControlStatus" }] : []));
+    formSubmitted = signal(false, ...(ngDevMode ? [{ debugName: "formSubmitted" }] : []));
+    formControlContext = initInputFormControl();
+    /**
+     * If the component is bound to an Angular AbstractControl, its state wins.
+     * If not, fall back to the host attribute.
+     */
+    isDisabled = linkedSignal(() => {
+        /**
+         * When the component is bound to any AbstractControl, status is guaranteed to
+         * be non-undefined.
+         */
+        const status = this.formControlStatus();
+        const disabled = this.disabled();
+        if (status !== undefined) {
+            return status === "DISABLED";
+        }
+        return !!disabled;
+    }, ...(ngDevMode ? [{ debugName: "isDisabled" }] : []));
+    isInvalid = computed(() => {
+        const formEventData = this.formControlContext.formEventData();
+        this.formSubmitted();
+        const isInvalidDefined = defined(this.invalid());
+        const invalidProp = this.invalid() || false;
+        if (!this.control) {
+            return invalidProp;
+        }
+        let invalid, touched, dirty;
+        if (this.formControlContext.isTemplateDrivenForm()) {
+            invalid = isInvalidDefined ? invalidProp : this.control.invalid;
+            touched = this.control.touched;
+            dirty = this.control.dirty;
+        }
+        else if (formEventData) {
+            invalid = formEventData.invalid;
+            touched = formEventData.touched;
+            dirty = formEventData.dirty;
+        }
+        else {
+            return invalidProp;
+        }
+        switch (this.control.updateOn) {
+            case "submit":
+                return invalid;
+            case "blur":
+                return invalid && touched;
+            default:
+                // "change"
+                return dirty && invalid;
+        }
+    }, ...(ngDevMode ? [{ debugName: "isInvalid" }] : []));
+    isRequired = linkedSignal(() => {
+        const control = this.control;
+        const required = this.required();
+        if (!control || !this.formControlContext.isReactiveForm()) {
+            return required;
+        }
+        if (typeof control.hasValidator === "function") {
+            return (control.hasValidator(Validators.required) ||
+                control.hasValidator(Validators.requiredTrue));
+        }
+        return false;
+    }, ...(ngDevMode ? [{ debugName: "isRequired" }] : []));
+    constructor() {
+        if (this.formControlContext.ngControl) {
+            this.formControlContext.ngControl.valueAccessor = this;
+            this.value.set(this.formControlContext.ngControl.control?.value || []);
+        }
+        afterNextRender(() => {
+            if (isDefined(this.required()) &&
+                this.formControlContext.isReactiveForm() &&
+                isDevMode()) {
+                console.warn("The required attribute is not supported on reactive forms. Use Validators instead. https://angular.dev/guide/forms/form-validation#validating-input-in-reactive-forms");
+            }
+        });
+        effect(() => {
+            const required = this.required();
+            const isRequired = this.isRequired();
+            if (!this.control) {
+                return;
+            }
+            if (this.formControlContext.isTemplateDrivenForm()) {
+                if (required) {
+                    this.control.addValidators([
+                        Validators.required,
+                        Validators.minLength(1),
+                    ]);
+                }
+                else if (this.control.hasValidator(Validators.required) &&
+                    this.control.hasValidator(Validators.minLength(1))) {
+                    this.control.removeValidators([
+                        Validators.required,
+                        Validators.minLength(1),
+                    ]);
+                }
+            }
+            else if (isRequired) {
+                this.control.addValidators(Validators.minLength(1));
+            }
+        });
+    }
+    ngOnInit() {
+        // Ensure the form control receives the initial value
+        const defaultValue = this.defaultValue();
+        if (!this.control) {
+            if (defaultValue) {
+                this.value.set(defaultValue);
+            }
+            return;
+        }
+        const subscription = this.control.statusChanges.subscribe((status) => {
+            this.formControlStatus.set(status);
+        });
+        this.onDestroy(() => {
+            subscription.unsubscribe();
+        });
+        const parent = this.getParentForm();
+        runInInjectionContext(this.injector, () => {
+            if (this.control) {
+                const formSignal = allEventsSignal(this.control);
+                effect(() => {
+                    this.formControlContext.formEventData.set(formSignal());
+                });
+            }
+            if (parent) {
+                let prevPristine = this.control?.pristine || false;
+                parent.form.events.pipe(takeUntilDestroyed()).subscribe((event) => {
+                    if (event instanceof PristineChangeEvent) {
+                        if (event.pristine && !prevPristine) {
+                            // if this event fires with pristine status and the control was
+                            // previously not pristine, this means that the form was reset. There
+                            // isn't another way to determine form resets programmatically,
+                            // unfortunately.
+                            this.formSubmitted.set(false);
+                        }
+                        prevPristine = event.pristine;
+                    }
+                    else if (event instanceof FormSubmittedEvent) {
+                        this.formSubmitted.set(true);
+                        this.control?.markAsDirty();
+                    }
+                });
+                parent.ngSubmit.pipe(takeUntilDestroyed()).subscribe(() => {
+                    if (this.formControlContext.isReactiveForm()) {
+                        // already accounted for in the above event subscription.
+                        return;
+                    }
+                    this.formSubmitted.set(true);
+                    this.control?.markAsDirty();
+                });
+            }
+        });
+    }
+    /** Convenience access to the underlying AbstractControl (can be null). */
+    get control() {
+        return this.formControlContext.ngControl?.control ?? null;
+    }
+    /**
+     * Used to subscribe to form submit events.
+     */
+    getParentForm() {
+        if (!this.control) {
+            return null;
+        }
+        // Try to find NgForm first
+        try {
+            const ngForm = this.injector.get(NgForm, null);
+            if (ngForm) {
+                return ngForm;
+            }
+        }
+        catch { }
+        // Fall back to FormGroupDirective
+        try {
+            const formGroupDirective = this.injector.get(FormGroupDirective, null);
+            if (formGroupDirective) {
+                return formGroupDirective;
+            }
+        }
+        catch { }
+        return null;
+    }
+    /*
+     * Control value accessor methods
+     */
+    writeValue(value) {
+        this.value.set(value ?? []);
+    }
+    // placeholder
+    onChange = (_value) => { };
+    registerOnChange(fn) {
+        this.onChange = (_value) => {
+            fn(_value);
+            this.value.set(_value ?? []);
+        };
+    }
+    onTouched = () => { };
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * NgModel never calls setDisabledState, but ReactiveForms does. Everything else
+     * (writeValue, registerOnChange, registerOnTouched) is identical between Reactive
+     * and Template forms.
+     */
+    setDisabledState(isDisabled) {
+        this.isDisabled.set(isDisabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AbstractListCollectionFormControlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.12", type: AbstractListCollectionFormControlDirective, isStandalone: true, inputs: { collection: { classPropertyName: "collection", publicName: "collection", isSignal: true, isRequired: true, transformFunction: null }, defaultValue: { classPropertyName: "defaultValue", publicName: "defaultValue", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, invalid: { classPropertyName: "invalid", publicName: "invalid", isSignal: true, isRequired: false, transformFunction: null }, name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: false, transformFunction: null }, readOnly: { classPropertyName: "readOnly", publicName: "readOnly", isSignal: true, isRequired: false, transformFunction: null }, required: { classPropertyName: "required", publicName: "required", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AbstractListCollectionFormControlDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { collection: [{ type: i0.Input, args: [{ isSignal: true, alias: "collection", required: true }] }], defaultValue: [{ type: i0.Input, args: [{ isSignal: true, alias: "defaultValue", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], invalid: [{ type: i0.Input, args: [{ isSignal: true, alias: "invalid", required: false }] }], name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: false }] }], readOnly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readOnly", required: false }] }], required: [{ type: i0.Input, args: [{ isSignal: true, alias: "required", required: false }] }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AbstractInputFormControlDirective, AbstractListCollectionFormControlDirective, FORM_CONTROL_ERROR_MESSAGE_PROVIDER, INPUT_FORM_CONTROL_CONTEXT, initInputFormControl };
+//# sourceMappingURL=qualcomm-ui-angular-core-input.mjs.map