@quidgest/ui 0.27.1 → 0.28.0

package/esm/components/QTextField/QTextField.d.ts

@@ -23,6 +23,10 @@ declare function __VLS_template(): {
                 readonly required?: boolean | undefined;
                 readonly for?: string | undefined;
                 readonly labelPosition?: import('..').QLabelPosition | undefined;
+                readonly help?: string | undefined;
+                readonly helpDisplay?: import('../..').QHelpDisplay | undefined;
+                readonly icons?: typeof import('../QField/constants').DEFAULT_ICONS | undefined;
+                readonly texts?: typeof import('../QField/constants').DEFAULT_TEXTS | undefined;
                 readonly size?: import('..').QFieldSize | undefined;
                 readonly readonly?: boolean | undefined;
                 readonly disabled?: boolean | undefined;
@@ -32,7 +36,115 @@ declare function __VLS_template(): {
             $refs: {
                 [x: string]: unknown;
             } & {
+                controlAnchor: HTMLDivElement;
                 field: HTMLDivElement;
+                standaloneHelp: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../__internal__/QHelpPopover').QHelpPopoverProps> & Readonly<{}>, {
+                    triggerEl: import('vue').ComputedRef<HTMLElement | undefined>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    icons: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_ICONS;
+                    texts: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_TEXTS;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                    trigger: ({
+                        $: import('vue').ComponentInternalInstance;
+                        $data: {};
+                        $props: {
+                            readonly id?: string | undefined;
+                            readonly class?: string | unknown[] | undefined;
+                            readonly label?: string | undefined;
+                            readonly help?: string | undefined;
+                            readonly helpDisplay?: import('../..').QHelpDisplay | undefined;
+                            readonly icons?: typeof import('../QButton/constants').DEFAULT_ICONS | undefined;
+                            readonly texts?: typeof import('../QButton/constants').DEFAULT_TEXTS | undefined;
+                            readonly variant?: import('..').QButtonVariant | undefined;
+                            readonly color?: string | undefined;
+                            readonly surface?: string | undefined;
+                            readonly borderless?: boolean | undefined;
+                            readonly elevated?: boolean | undefined;
+                            readonly block?: boolean | undefined;
+                            readonly size?: import('../..').QComponentSize | undefined;
+                            readonly iconPos?: import('..').QButtonIconPosition | undefined;
+                            readonly pill?: boolean | undefined;
+                            readonly effect?: import('..').QButtonEffect | undefined;
+                            readonly disabled?: boolean | undefined;
+                            readonly loading?: boolean | undefined;
+                            readonly tabindex?: number | undefined;
+                            readonly onClick?: ((event: MouseEvent) => any) | undefined;
+                        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                        $attrs: import('vue').Attrs;
+                        $refs: {
+                            [x: string]: unknown;
+                        } & {
+                            buttonEl: HTMLButtonElement;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: import('vue').Slot<any> | undefined;
+                        }>;
+                        $root: import('vue').ComponentPublicInstance | null;
+                        $parent: import('vue').ComponentPublicInstance | null;
+                        $host: Element | null;
+                        $emit: (event: "click", event: MouseEvent) => void;
+                        $el: any;
+                        $options: import('vue').ComponentOptionsBase<Readonly<import('..').QButtonProps> & Readonly<{
+                            onClick?: ((event: MouseEvent) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                            click: (event: MouseEvent) => any;
+                        }, string, {
+                            effect: import('..').QButtonEffect;
+                            color: string;
+                            variant: import('..').QButtonVariant;
+                            icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+                            texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+                            helpDisplay: import('../..').QHelpDisplay;
+                            iconPos: import('..').QButtonIconPosition;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                            beforeCreate?: (() => void) | (() => void)[];
+                            created?: (() => void) | (() => void)[];
+                            beforeMount?: (() => void) | (() => void)[];
+                            mounted?: (() => void) | (() => void)[];
+                            beforeUpdate?: (() => void) | (() => void)[];
+                            updated?: (() => void) | (() => void)[];
+                            activated?: (() => void) | (() => void)[];
+                            deactivated?: (() => void) | (() => void)[];
+                            beforeDestroy?: (() => void) | (() => void)[];
+                            beforeUnmount?: (() => void) | (() => void)[];
+                            destroyed?: (() => void) | (() => void)[];
+                            unmounted?: (() => void) | (() => void)[];
+                            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof import('vue').nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                    } & Readonly<{
+                        effect: import('..').QButtonEffect;
+                        color: string;
+                        variant: import('..').QButtonVariant;
+                        icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+                        texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+                        helpDisplay: import('../..').QHelpDisplay;
+                        iconPos: import('..').QButtonIconPosition;
+                    }> & Omit<Readonly<import('..').QButtonProps> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, "effect" | "color" | "variant" | "icons" | "texts" | "helpDisplay" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
+                        $slots: {
+                            default?(_: {}): any;
+                            append?(_: {}): any;
+                        };
+                    }) | null;
+                }, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('../__internal__/QHelpPopover').QHelpPopoverProps> & Readonly<{}>, {
+                    triggerEl: import('vue').ComputedRef<HTMLElement | undefined>;
+                }, {}, {}, {}, {
+                    icons: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_ICONS;
+                    texts: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_TEXTS;
+                }> | null;
             };
             $slots: Readonly<{
                 [name: string]: import('vue').Slot<any> | undefined;
@@ -43,9 +155,13 @@ declare function __VLS_template(): {
             $emit: (event: string, ...args: any[]) => void;
             $el: any;
             $options: import('vue').ComponentOptionsBase<Readonly<import('..').QFieldProps> & Readonly<{}>, {
-                fieldRef: Readonly<import('vue').ShallowRef<HTMLDivElement | null>>;
+                fieldRef: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+                helpDescribedBy: import('vue').ComputedRef<string | undefined>;
             }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
                 size: import('..').QFieldSize;
+                icons: typeof import('../QField/constants').DEFAULT_ICONS;
+                texts: typeof import('../QField/constants').DEFAULT_TEXTS;
+                helpDisplay: import('../..').QHelpDisplay;
                 labelPosition: import('..').QLabelPosition;
             }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
@@ -69,16 +185,24 @@ declare function __VLS_template(): {
             $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
         } & Readonly<{
             size: import('..').QFieldSize;
+            icons: typeof import('../QField/constants').DEFAULT_ICONS;
+            texts: typeof import('../QField/constants').DEFAULT_TEXTS;
+            helpDisplay: import('../..').QHelpDisplay;
             labelPosition: import('..').QLabelPosition;
-        }> & Omit<Readonly<import('..').QFieldProps> & Readonly<{}>, "fieldRef" | ("size" | "labelPosition")> & {
-            fieldRef: HTMLDivElement | null;
+        }> & Omit<Readonly<import('..').QFieldProps> & Readonly<{}>, "helpDescribedBy" | "fieldRef" | ("size" | "icons" | "texts" | "helpDisplay" | "labelPosition")> & {
+            fieldRef: HTMLElement | null;
+            helpDescribedBy: string | undefined;
         } & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
                 'label.prepend'?(_: {}): any;
                 'label.append'?(_: {}): any;
-                control?(_: {}): any;
+                control?(_: {
+                    describedBy: string | undefined;
+                }): any;
                 prepend?(_: {}): any;
-                default?(_: {}): any;
+                default?(_: {
+                    describedBy: string | undefined;
+                }): any;
                 append?(_: {}): any;
                 extras?(_: {}): any;
             };
@@ -89,7 +213,7 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
-    fieldRef: import('vue').ComputedRef<HTMLDivElement | null | undefined>;
+    fieldRef: import('vue').ComputedRef<HTMLElement | null | undefined>;
     inputRef: Readonly<import('vue').ShallowRef<HTMLInputElement | null>>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
@@ -100,6 +224,24 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     "onClick:clear"?: ((event: Event) => any) | undefined;
 }>, {
     type: string;
+    icons: {
+        help: {
+            icon: string;
+        };
+    } & {
+        clear: {
+            icon: string;
+        };
+        help: {
+            icon: string;
+        };
+    };
+    texts: {
+        showHelp: string;
+    } & {
+        clearValue: string;
+        showHelp: string;
+    };
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     field: ({
         $: import('vue').ComponentInternalInstance;
@@ -111,6 +253,10 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
             readonly required?: boolean | undefined;
             readonly for?: string | undefined;
             readonly labelPosition?: import('..').QLabelPosition | undefined;
+            readonly help?: string | undefined;
+            readonly helpDisplay?: import('../..').QHelpDisplay | undefined;
+            readonly icons?: typeof import('../QField/constants').DEFAULT_ICONS | undefined;
+            readonly texts?: typeof import('../QField/constants').DEFAULT_TEXTS | undefined;
             readonly size?: import('..').QFieldSize | undefined;
             readonly readonly?: boolean | undefined;
             readonly disabled?: boolean | undefined;
@@ -120,7 +266,115 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
         $refs: {
             [x: string]: unknown;
         } & {
+            controlAnchor: HTMLDivElement;
             field: HTMLDivElement;
+            standaloneHelp: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../__internal__/QHelpPopover').QHelpPopoverProps> & Readonly<{}>, {
+                triggerEl: import('vue').ComputedRef<HTMLElement | undefined>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                icons: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_ICONS;
+                texts: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_TEXTS;
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                trigger: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly id?: string | undefined;
+                        readonly class?: string | unknown[] | undefined;
+                        readonly label?: string | undefined;
+                        readonly help?: string | undefined;
+                        readonly helpDisplay?: import('../..').QHelpDisplay | undefined;
+                        readonly icons?: typeof import('../QButton/constants').DEFAULT_ICONS | undefined;
+                        readonly texts?: typeof import('../QButton/constants').DEFAULT_TEXTS | undefined;
+                        readonly variant?: import('..').QButtonVariant | undefined;
+                        readonly color?: string | undefined;
+                        readonly surface?: string | undefined;
+                        readonly borderless?: boolean | undefined;
+                        readonly elevated?: boolean | undefined;
+                        readonly block?: boolean | undefined;
+                        readonly size?: import('../..').QComponentSize | undefined;
+                        readonly iconPos?: import('..').QButtonIconPosition | undefined;
+                        readonly pill?: boolean | undefined;
+                        readonly effect?: import('..').QButtonEffect | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly loading?: boolean | undefined;
+                        readonly tabindex?: number | undefined;
+                        readonly onClick?: ((event: MouseEvent) => any) | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $attrs: import('vue').Attrs;
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        buttonEl: HTMLButtonElement;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "click", event: MouseEvent) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('..').QButtonProps> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                        click: (event: MouseEvent) => any;
+                    }, string, {
+                        effect: import('..').QButtonEffect;
+                        color: string;
+                        variant: import('..').QButtonVariant;
+                        icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+                        texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+                        helpDisplay: import('../..').QHelpDisplay;
+                        iconPos: import('..').QButtonIconPosition;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import('vue').nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                } & Readonly<{
+                    effect: import('..').QButtonEffect;
+                    color: string;
+                    variant: import('..').QButtonVariant;
+                    icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+                    texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+                    helpDisplay: import('../..').QHelpDisplay;
+                    iconPos: import('..').QButtonIconPosition;
+                }> & Omit<Readonly<import('..').QButtonProps> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, "effect" | "color" | "variant" | "icons" | "texts" | "helpDisplay" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                        append?(_: {}): any;
+                    };
+                }) | null;
+            }, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('../__internal__/QHelpPopover').QHelpPopoverProps> & Readonly<{}>, {
+                triggerEl: import('vue').ComputedRef<HTMLElement | undefined>;
+            }, {}, {}, {}, {
+                icons: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_ICONS;
+                texts: typeof import('../__internal__/QHelpPopover/constants').DEFAULT_TEXTS;
+            }> | null;
         };
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
@@ -131,9 +385,13 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<import('..').QFieldProps> & Readonly<{}>, {
-            fieldRef: Readonly<import('vue').ShallowRef<HTMLDivElement | null>>;
+            fieldRef: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+            helpDescribedBy: import('vue').ComputedRef<string | undefined>;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
             size: import('..').QFieldSize;
+            icons: typeof import('../QField/constants').DEFAULT_ICONS;
+            texts: typeof import('../QField/constants').DEFAULT_TEXTS;
+            helpDisplay: import('../..').QHelpDisplay;
             labelPosition: import('..').QLabelPosition;
         }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
@@ -157,16 +415,24 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
     } & Readonly<{
         size: import('..').QFieldSize;
+        icons: typeof import('../QField/constants').DEFAULT_ICONS;
+        texts: typeof import('../QField/constants').DEFAULT_TEXTS;
+        helpDisplay: import('../..').QHelpDisplay;
         labelPosition: import('..').QLabelPosition;
-    }> & Omit<Readonly<import('..').QFieldProps> & Readonly<{}>, "fieldRef" | ("size" | "labelPosition")> & {
-        fieldRef: HTMLDivElement | null;
+    }> & Omit<Readonly<import('..').QFieldProps> & Readonly<{}>, "helpDescribedBy" | "fieldRef" | ("size" | "icons" | "texts" | "helpDisplay" | "labelPosition")> & {
+        fieldRef: HTMLElement | null;
+        helpDescribedBy: string | undefined;
     } & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             'label.prepend'?(_: {}): any;
             'label.append'?(_: {}): any;
-            control?(_: {}): any;
+            control?(_: {
+                describedBy: string | undefined;
+            }): any;
             prepend?(_: {}): any;
-            default?(_: {}): any;
+            default?(_: {
+                describedBy: string | undefined;
+            }): any;
             append?(_: {}): any;
             extras?(_: {}): any;
         };

package/esm/components/QTextField/QTextField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QTextField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/QTextField.vue"],"names":[],"mappings":"AAsDA;AAyIC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,GAAG,CAAA;AAKxC,KAAK,WAAW,GAAG,eAAe,CAAC;AAsEpC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAuIT,OAAO,IAA6B;;iCAjBb,GAAG;gCACJ,GAAG;yBACV,GAAG;wBACH,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAoE8nd,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;EAlDnxd;AAkBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+Byod,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;OArBlxd,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QTextField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/QTextField.vue"],"names":[],"mappings":"AA8DA;AA+JC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,GAAG,CAAA;AAMxC,KAAK,WAAW,GAAG,eAAe,CAAC;AA+EpC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAwJT,OAAO,IAA6B;;iCAjBb,GAAG;gCACJ,GAAG;yBACV,GAAG;wBACH,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAsEu0Z,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;EApD59Z;AAoBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA+Bk1Z,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;OArB39Z,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/esm/components/QTextField/QTextField.vue.js

@@ -1,26 +1,33 @@
 import { useId as e } from "../../composables/useId/index.js";
-import { QField as t } from "../QField/index.js";
-import { QClearButton as n } from "../__internal__/QClearButton/index.js";
-import { computed as r, createBlock as i, createCommentVNode as a, createElementVNode as o, createSlots as s, defineComponent as c, mergeModels as l, mergeProps as u, normalizeClass as d, openBlock as f, renderSlot as p, toRef as m, unref as h, useModel as g, useTemplateRef as _, vModelDynamic as v, watch as y, withCtx as b, withDirectives as x } from "vue";
+import { mergeDescribedBy as t } from "../__internal__/QHelpPopover/resolveHelp.js";
+import { QField as n } from "../QField/index.js";
+import { DEFAULT_ICONS as r, DEFAULT_TEXTS as i } from "./constants.js";
+import { QClearButton as a } from "../__internal__/QClearButton/index.js";
+import { computed as o, createBlock as s, createCommentVNode as c, createElementVNode as l, createSlots as u, defineComponent as d, mergeModels as f, mergeProps as p, normalizeClass as m, openBlock as h, renderSlot as g, toRef as _, unref as v, useAttrs as y, useModel as b, useTemplateRef as x, vModelDynamic as S, watch as C, withCtx as w, withDirectives as T } from "vue";
 //#region src/components/QTextField/QTextField.vue?vue&type=script&setup=true&lang.ts
-var S = [
+var E = [
 	"id",
 	"type",
 	"maxlength",
 	"required",
 	"placeholder",
 	"readonly",
-	"disabled"
-], C = /*@__PURE__*/ c({
+	"disabled",
+	"aria-describedby"
+], D = /*@__PURE__*/ d({
 	inheritAttrs: !1,
 	__name: "QTextField",
-	props: /*@__PURE__*/ l({
+	props: /*@__PURE__*/ f({
 		id: {},
 		class: {},
 		label: {},
 		required: { type: Boolean },
 		for: {},
 		labelPosition: {},
+		help: {},
+		helpDisplay: {},
+		icons: { default: () => r },
+		texts: { default: () => i },
 		size: {},
 		readonly: { type: Boolean },
 		disabled: { type: Boolean },
@@ -28,76 +35,80 @@ var S = [
 		placeholder: {},
 		maxLength: {},
 		clearable: { type: Boolean },
-		type: { default: "text" },
-		texts: {}
+		type: { default: "text" }
 	}, {
 		modelValue: {},
 		modelModifiers: {}
 	}),
-	emits: /*@__PURE__*/ l(["click:clear"], ["update:modelValue"]),
-	setup(c, { expose: l, emit: C }) {
-		let w = c, T = C, E = g(c, "modelValue"), D = r({
-			get: () => E.value,
+	emits: /*@__PURE__*/ f(["click:clear"], ["update:modelValue"]),
+	setup(r, { expose: i, emit: d }) {
+		let f = r, D = d, O = b(r, "modelValue"), k = o({
+			get: () => O.value,
 			set: (e) => {
-				let t = w.maxLength;
-				E.value = t ? e?.slice(0, t) : e;
+				let t = f.maxLength;
+				O.value = t ? e?.slice(0, t) : e;
 			}
 		});
-		y(E, (e) => D.value = e, { immediate: !0 });
-		let O = e(m(w, "id")), k = _("field"), A = _("input"), j = r(() => `${O.value}_input`), M = r(() => w.readonly || w.disabled ? void 0 : w.placeholder), N = r(() => w.clearable && !w.readonly && !w.disabled), P = r(() => N.value && E.value);
-		function F(e) {
-			N.value && (E.value = "", T("click:clear", e));
+		C(O, (e) => k.value = e, { immediate: !0 });
+		let A = e(_(f, "id")), j = y(), M = o(() => typeof j["aria-describedby"] == "string" ? j["aria-describedby"] : void 0), N = x("field"), P = x("input"), F = o(() => `${A.value}_input`), I = o(() => f.readonly || f.disabled ? void 0 : f.placeholder), L = o(() => f.clearable && !f.readonly && !f.disabled), R = o(() => L.value && O.value);
+		function z(e) {
+			L.value && (O.value = "", D("click:clear", e));
 		}
-		return l({
-			fieldRef: r(() => k.value?.fieldRef),
-			inputRef: A
-		}), (e, r) => (f(), i(h(t), {
-			id: h(O),
+		return i({
+			fieldRef: o(() => N.value?.fieldRef),
+			inputRef: P
+		}), (e, r) => (h(), s(v(n), {
+			id: v(A),
 			ref: "field",
-			class: d(["q-text-field", w.class]),
-			for: j.value,
-			label: w.label,
-			"label-position": w.labelPosition,
-			size: w.size,
-			readonly: w.readonly,
-			disabled: w.disabled,
-			required: w.required,
-			invalid: w.invalid
-		}, s({
-			"label.prepend": b(() => [p(e.$slots, "label.prepend")]),
-			"label.append": b(() => [p(e.$slots, "label.append")]),
-			default: b(() => [x(o("input", u({
-				id: j.value,
+			class: m(["q-text-field", f.class]),
+			for: F.value,
+			label: f.label,
+			"label-position": f.labelPosition,
+			size: f.size,
+			readonly: f.readonly,
+			disabled: f.disabled,
+			required: f.required,
+			invalid: f.invalid,
+			help: f.help,
+			"help-display": f.helpDisplay,
+			icons: f.icons,
+			texts: f.texts
+		}, u({
+			"label.prepend": w(() => [g(e.$slots, "label.prepend")]),
+			"label.append": w(() => [g(e.$slots, "label.append")]),
+			default: w(({ describedBy: n }) => [T(l("input", p({
+				id: F.value,
 				ref: "input",
-				"onUpdate:modelValue": r[0] ||= (e) => D.value = e,
+				"onUpdate:modelValue": r[0] ||= (e) => k.value = e,
 				class: "q-text-field__input",
-				type: w.type,
-				maxlength: w.maxLength,
-				required: w.required,
-				placeholder: M.value,
-				readonly: w.readonly,
-				disabled: w.disabled
-			}, e.$attrs), null, 16, S), [[v, D.value]])]),
+				type: f.type,
+				maxlength: f.maxLength,
+				required: f.required,
+				placeholder: I.value,
+				readonly: f.readonly,
+				disabled: f.disabled
+			}, e.$attrs, { "aria-describedby": v(t)(n, M.value) }), null, 16, E), [[S, k.value]])]),
 			_: 2
 		}, [
 			e.$slots.prepend ? {
 				name: "prepend",
-				fn: b(() => [p(e.$slots, "prepend")]),
+				fn: w(() => [g(e.$slots, "prepend")]),
 				key: "0"
 			} : void 0,
-			e.$slots.append || P.value ? {
+			e.$slots.append || R.value ? {
 				name: "append",
-				fn: b(() => [p(e.$slots, "append"), P.value ? (f(), i(h(n), {
+				fn: w(() => [g(e.$slots, "append"), R.value ? (h(), s(v(a), {
 					key: 0,
 					"data-testid": "q-text-field__clear-button",
-					texts: w.texts,
-					onClick: F
-				}, null, 8, ["texts"])) : a("v-if", !0)]),
+					icons: f.icons,
+					texts: f.texts,
+					onClick: z
+				}, null, 8, ["icons", "texts"])) : c("v-if", !0)]),
 				key: "1"
 			} : void 0,
 			e.$slots.extras ? {
 				name: "extras",
-				fn: b(() => [p(e.$slots, "extras")]),
+				fn: w(() => [g(e.$slots, "extras")]),
 				key: "2"
 			} : void 0
 		]), 1032, [
@@ -110,9 +121,13 @@ var S = [
 			"readonly",
 			"disabled",
 			"required",
-			"invalid"
+			"invalid",
+			"help",
+			"help-display",
+			"icons",
+			"texts"
 		]));
 	}
 });
 //#endregion
-export { C as default };
+export { D as default };

package/esm/components/QTextField/constants.d.ts

@@ -1,4 +1,13 @@
+export declare const DEFAULT_ICONS: {
+    clear: {
+        icon: string;
+    };
+    help: {
+        icon: string;
+    };
+};
 export declare const DEFAULT_TEXTS: {
     clearValue: string;
+    showHelp: string;
 };
 //# sourceMappingURL=constants.d.ts.map

package/esm/components/QTextField/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/constants.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;CAEQ,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/constants.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,aAAa;;;;;;;CAGY,CAAA;AAGtC,eAAO,MAAM,aAAa;;;CAGQ,CAAA"}

package/esm/components/QTextField/constants.js

@@ -1,5 +1,12 @@
-import { DEFAULT_TEXTS as e } from "../__internal__/QClearButton/constants.js";
+import { DEFAULT_ICONS as e, DEFAULT_TEXTS as t } from "../QField/constants.js";
+import { DEFAULT_ICONS as n, DEFAULT_TEXTS as r } from "../__internal__/QClearButton/constants.js";
 //#region src/components/QTextField/constants.ts
-var t = { ...e };
+var i = {
+	...e,
+	...n
+}, a = {
+	...t,
+	...r
+};
 //#endregion
-export { t as DEFAULT_TEXTS };
+export { i as DEFAULT_ICONS, a as DEFAULT_TEXTS };