@quidgest/ui 0.14.11 → 0.14.13

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

@@ -6,8 +6,8 @@ type __VLS_PublicProps = {
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
-        "label.prepend"?(_: {}): any;
-        "label.append"?(_: {}): any;
+        'label.prepend'?(_: {}): any;
+        'label.append'?(_: {}): any;
         prepend?(_: {}): any;
         append?(_: {}): any;
         extras?(_: {}): any;
@@ -24,13 +24,15 @@ declare function __VLS_template(): {
                 readonly readonly?: boolean | undefined;
                 readonly disabled?: boolean | undefined;
                 readonly required?: boolean | undefined;
-                readonly class?: (string | unknown[]) | undefined;
+                readonly class?: string | unknown[] | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: {
                 [x: string]: unknown;
             };
             $refs: {
                 [x: string]: unknown;
+            } & {
+                fieldRef: HTMLDivElement;
             };
             $slots: Readonly<{
                 [name: string]: import('vue').Slot<any> | undefined;
@@ -44,10 +46,6 @@ declare function __VLS_template(): {
                 fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
             }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
                 size: import('../QField').QFieldSize;
-                class: string | unknown[];
-                label: string;
-                id: string;
-                for: string;
             }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
                 created?: (() => void) | (() => void)[];
@@ -70,16 +68,12 @@ 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('../QField').QFieldSize;
-            class: string | unknown[];
-            label: string;
-            id: string;
-            for: string;
-        }> & Omit<Readonly<import('../QField').QFieldProps> & Readonly<{}>, "fieldRef" | ("size" | "class" | "label" | "id" | "for")> & import('vue').ShallowUnwrapRef<{
+        }> & Omit<Readonly<import('../QField').QFieldProps> & Readonly<{}>, "size" | "fieldRef"> & import('vue').ShallowUnwrapRef<{
             fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
         }> & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
-                "label.prepend"?(_: {}): any;
-                "label.append"?(_: {}): any;
+                'label.prepend'?(_: {}): any;
+                'label.append'?(_: {}): any;
                 control?(_: {}): any;
                 prepend?(_: {}): any;
                 default?(_: {}): any;
@@ -97,18 +91,84 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     inputRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
+} & {
+    "click:clear": (event: Event) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onClick:clear"?: ((event: Event) => any) | undefined;
 }>, {
-    size: import('../QField').QFieldSize;
-    class: string | unknown[];
-    label: string;
     type: string;
-    role: string;
-    id: string;
-    placeholder: string;
-    maxLength: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    fieldRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string | undefined;
+            readonly label?: string | undefined;
+            readonly for?: string | undefined;
+            readonly size?: import('../QField').QFieldSize | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly required?: boolean | undefined;
+            readonly class?: string | unknown[] | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            fieldRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../QField').QFieldProps> & Readonly<{}>, {
+            fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            size: import('../QField').QFieldSize;
+        }, {}, 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<{
+        size: import('../QField').QFieldSize;
+    }> & Omit<Readonly<import('../QField').QFieldProps> & Readonly<{}>, "size" | "fieldRef"> & import('vue').ShallowUnwrapRef<{
+        fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            'label.prepend'?(_: {}): any;
+            'label.append'?(_: {}): any;
+            control?(_: {}): any;
+            prepend?(_: {}): any;
+            default?(_: {}): any;
+            append?(_: {}): any;
+            extras?(_: {}): any;
+        };
+    }) | null;
+    inputRef: HTMLInputElement;
+}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

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":"AA8CA;AAgGC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAQ/C,KAAK,WAAW,GAAG,eAAe,CAAC;AAsDnC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAyFT,OAAO,IAA6B;;iCAdb,GAAG;gCACJ,GAAG;yBACV,GAAG;wBACH,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAiEu9gB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;EAlD5mhB;AAgBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;6EASnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAgBpG,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":"AAoDA;AAoHC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM9C,KAAK,WAAW,GAAG,eAAe,CAAC;AAwDpC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAkIT,OAAO,IAA6B;;iCAjBb,GAAG;gCACJ,GAAG;yBACV,GAAG;wBACH,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAqE2je,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;EAnDhte;AAmBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+Bske,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;OArB/se,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,69 +1,75 @@
-import { defineComponent as b, mergeModels as h, useModel as q, ref as f, computed as u, openBlock as $, createBlock as k, unref as n, normalizeClass as g, createSlots as v, withCtx as d, renderSlot as a, withDirectives as x, createElementVNode as R, mergeProps as z, vModelDynamic as B } from "vue";
-import { QField as V } from "../QField/index.js";
-import { useId as M } from "../../composables/uid.js";
-const C = ["id", "type", "role", "required", "placeholder", "readonly", "disabled", "maxlength"], L = /* @__PURE__ */ b({
+import { defineComponent as C, mergeModels as c, useModel as g, ref as y, computed as o, createBlock as b, openBlock as h, unref as r, normalizeClass as R, createSlots as V, withCtx as a, withDirectives as z, createElementVNode as M, mergeProps as w, vModelDynamic as Q, renderSlot as d, createCommentVNode as D } from "vue";
+import { QField as F } from "../QField/index.js";
+import { QClearButton as L } from "../__internal__/QClearButton/index.js";
+import { useId as N } from "../../composables/uid.js";
+const S = ["id", "type", "role", "required", "placeholder", "readonly", "disabled", "maxlength"], P = /* @__PURE__ */ C({
   inheritAttrs: !1,
   __name: "QTextField",
-  props: /* @__PURE__ */ h({
-    id: { default: void 0 },
-    placeholder: { default: "" },
-    label: { default: "" },
-    size: { default: void 0 },
-    maxLength: { default: void 0 },
+  props: /* @__PURE__ */ c({
+    id: {},
+    placeholder: {},
+    label: {},
+    clearable: { type: Boolean },
+    size: {},
+    maxLength: {},
     readonly: { type: Boolean },
     disabled: { type: Boolean },
     required: { type: Boolean },
-    role: { default: void 0 },
+    role: {},
     type: { default: "text" },
-    class: { default: void 0 }
+    class: {},
+    texts: {}
   }, {
     modelValue: {},
     modelModifiers: {}
   }),
-  emits: ["update:modelValue"],
-  setup(o, { expose: m }) {
-    const e = o, r = q(o, "modelValue"), t = M(e.id), s = f(null), i = f(null), y = u(
-      () => e.readonly || e.disabled ? "" : e.placeholder
-    );
-    return m({
-      fieldRef: u(() => {
+  emits: /* @__PURE__ */ c(["click:clear"], ["update:modelValue"]),
+  setup(n, { expose: v, emit: k }) {
+    const e = n, x = k, t = g(n, "modelValue"), s = N(e.id), i = y(null), p = y(null), q = o(
+      () => e.readonly || e.disabled ? void 0 : e.placeholder
+    ), u = o(() => e.clearable && !e.readonly && !e.disabled), f = o(() => u.value && t.value);
+    function $(l) {
+      u.value && (t.value = "", x("click:clear", l));
+    }
+    return v({
+      fieldRef: o(() => {
         var l;
-        return (l = s.value) == null ? void 0 : l.fieldRef;
+        return (l = i.value) == null ? void 0 : l.fieldRef;
       }),
-      inputRef: i
-    }), (l, p) => ($(), k(n(V), {
+      inputRef: p
+    }), (l, m) => (h(), b(r(F), {
       ref_key: "fieldRef",
-      ref: s,
-      class: g(["q-text-field", e.class]),
-      for: n(t),
+      ref: i,
+      class: R(["q-text-field", e.class]),
+      for: r(s),
       label: e.label,
       size: e.size,
       readonly: e.readonly,
       disabled: e.disabled,
       required: e.required
-    }, v({
-      "label.prepend": d(() => [
-        a(l.$slots, "label.prepend")
+    }, V({
+      "label.prepend": a(() => [
+        d(l.$slots, "label.prepend")
       ]),
-      "label.append": d(() => [
-        a(l.$slots, "label.append")
+      "label.append": a(() => [
+        d(l.$slots, "label.append")
       ]),
-      default: d(() => [
-        x(R("input", z({
-          id: n(t),
+      default: a(() => [
+        z(M("input", w({
+          id: r(s),
           ref_key: "inputRef",
-          ref: i,
-          "onUpdate:modelValue": p[0] || (p[0] = (c) => r.value = c),
+          ref: p,
+          "onUpdate:modelValue": m[0] || (m[0] = (B) => t.value = B),
           class: "q-text-field__input",
           type: e.type,
           role: e.role,
           required: e.required,
-          placeholder: y.value,
+          placeholder: q.value,
           readonly: e.readonly,
           disabled: e.disabled,
           maxlength: e.maxLength
-        }, l.$attrs), null, 16, C), [
-          [B, r.value]
+        }, l.$attrs), null, 16, S), [
+          [Q, t.value]
         ])
       ]),
       _: 2
@@ -71,22 +77,28 @@ const C = ["id", "type", "role", "required", "placeholder", "readonly", "disable
     }, [
       l.$slots.prepend ? {
         name: "prepend",
-        fn: d(() => [
-          a(l.$slots, "prepend")
+        fn: a(() => [
+          d(l.$slots, "prepend")
         ]),
         key: "0"
       } : void 0,
-      l.$slots.append ? {
+      l.$slots.append || f.value ? {
         name: "append",
-        fn: d(() => [
-          a(l.$slots, "append")
+        fn: a(() => [
+          d(l.$slots, "append"),
+          f.value ? (h(), b(r(L), {
+            key: 0,
+            "data-testid": "q-text-field__clear-button",
+            texts: e.texts,
+            onClick: $
+          }, null, 8, ["texts"])) : D("v-if", !0)
         ]),
         key: "1"
       } : void 0,
       l.$slots.extras ? {
         name: "extras",
-        fn: d(() => [
-          a(l.$slots, "extras")
+        fn: a(() => [
+          d(l.$slots, "extras")
         ]),
         key: "2"
       } : void 0
@@ -94,5 +106,5 @@ const C = ["id", "type", "role", "required", "placeholder", "readonly", "disable
   }
 });
 export {
-  L as default
+  P as default
 };

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

@@ -1,4 +1,131 @@
-import { default as _QTextField } from './QTextField';
-declare const QTextField: typeof _QTextField;
+declare const QTextField: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: string;
+    } & import('./types').QTextFieldProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        "onClick:clear"?: ((event: Event) => any) | undefined;
+    }>, {
+        fieldRef: import('vue').ComputedRef<HTMLElement | null | undefined>;
+        inputRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: string) => any;
+    } & {
+        "click:clear": (event: Event) => any;
+    }, import('vue').PublicProps, {
+        type: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        fieldRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly id?: string | undefined;
+                readonly label?: string | undefined;
+                readonly for?: string | undefined;
+                readonly size?: import('..').QFieldSize | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly required?: boolean | undefined;
+                readonly class?: string | unknown[] | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                fieldRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').QFieldProps> & Readonly<{}>, {
+                fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                size: import('..').QFieldSize;
+            }, {}, 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<{
+            size: import('..').QFieldSize;
+        }> & Omit<Readonly<import('..').QFieldProps> & Readonly<{}>, "size" | "fieldRef"> & import('vue').ShallowUnwrapRef<{
+            fieldRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                'label.prepend'?(_: {}): any;
+                'label.append'?(_: {}): any;
+                control?(_: {}): any;
+                prepend?(_: {}): any;
+                default?(_: {}): any;
+                append?(_: {}): any;
+                extras?(_: {}): any;
+            };
+        }) | null;
+        inputRef: HTMLInputElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: string;
+    } & import('./types').QTextFieldProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        "onClick:clear"?: ((event: Event) => any) | undefined;
+    }>, {
+        fieldRef: import('vue').ComputedRef<HTMLElement | null | undefined>;
+        inputRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    }, {}, {}, {}, {
+        type: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: string;
+} & import('./types').QTextFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onClick:clear"?: ((event: Event) => any) | undefined;
+}>, {
+    fieldRef: import('vue').ComputedRef<HTMLElement | null | undefined>;
+    inputRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+} & {
+    "click:clear": (event: Event) => any;
+}, string, {
+    type: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        'label.prepend'?(_: {}): any;
+        'label.append'?(_: {}): any;
+        prepend?(_: {}): any;
+        append?(_: {}): any;
+        extras?(_: {}): any;
+    };
+});
 export { QTextField };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/index.ts"],"names":[],"mappings":"AACA,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAK1C,QAAA,MAAM,UAAU,EAAmC,OAAO,WAAW,CAAA;AAGrE,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAIyvzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAJh1zB,CAAA;AAG/C,OAAO,EAAE,UAAU,EAAE,CAAA"}

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

@@ -12,6 +12,10 @@ export type QTextFieldProps = {
      * The label of the input.
      */
     label?: string;
+    /**
+     * Whether the value of the field can be cleared.
+     */
+    clearable?: boolean;
     /**
      * The size of the text field.
      */
@@ -46,5 +50,12 @@ export type QTextFieldProps = {
      * Custom set of classes to apply to the component.
      */
     class?: string | unknown[];
+    /**
+     * Custom text configurations.
+     */
+    texts?: typeof DEFAULT_TEXTS;
+};
+export declare const DEFAULT_TEXTS: {
+    clearValue: string;
 };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD,MAAM,MAAM,eAAe,GAAG;IAC7B;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAA;IAEX;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IAEjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;CAC1B,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QTextField/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD,MAAM,MAAM,eAAe,GAAG;IAC7B;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAA;IAEX;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;OAEG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IAEjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;IAE1B;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;CAC5B,CAAA;AAGD,eAAO,MAAM,aAAa;;CAEQ,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"QThemeProvider.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QThemeProvider/QThemeProvider.vue"],"names":[],"mappings":"AAKA;AAeC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAYnD,iBAAS,cAAc;WAmCT,OAAO,IAA6B;;yBARrB,GAAG;;;;EAa/B;AAQD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,6TAOnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAWpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QThemeProvider.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QThemeProvider/QThemeProvider.vue"],"names":[],"mappings":"AAKA;AAyBC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAiBnD,iBAAS,cAAc;WAwBT,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AAQD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,6TAOnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/esm/components/QThemeProvider/QThemeProvider.vue.js

@@ -1,18 +1,19 @@
-import { defineComponent as r, openBlock as n, createElementBlock as s, normalizeClass as m, renderSlot as a } from "vue";
-const c = /* @__PURE__ */ r({
+import { defineComponent as m, toRef as n, createElementBlock as s, openBlock as p, normalizeClass as a, renderSlot as c } from "vue";
+import { provideTheme as l } from "../../composables/theme.js";
+const f = /* @__PURE__ */ m({
   __name: "QThemeProvider",
   props: {
     theme: {}
   },
-  setup(e) {
-    const t = e;
-    return (o, l) => (n(), s(
+  setup(t) {
+    const e = t, o = n(e, "theme");
+    return l(o), (r, h) => (p(), s(
       "div",
       {
-        class: m(["q-theme-provider", `q-theme--${t.theme}`])
+        class: a(["q-theme-provider", `q-theme--${e.theme}`])
       },
       [
-        a(o.$slots, "default")
+        c(r.$slots, "default")
       ],
       2
       /* CLASS */
@@ -20,5 +21,5 @@ const c = /* @__PURE__ */ r({
   }
 });
 export {
-  c as default
+  f as default
 };

package/esm/components/QThemeProvider/index.d.ts

@@ -1,4 +1,19 @@
-import { default as _QThemeProvider } from './QThemeProvider';
-declare const QThemeProvider: typeof _QThemeProvider;
+declare const QThemeProvider: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types').QThemeProviderProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./types').QThemeProviderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./types').QThemeProviderProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+});
 export { QThemeProvider };
 //# sourceMappingURL=index.d.ts.map

package/esm/components/QThemeProvider/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QThemeProvider/index.ts"],"names":[],"mappings":"AACA,OAAO,eAAe,MAAM,sBAAsB,CAAA;AAKlD,QAAA,MAAM,cAAc,EAAuC,OAAO,eAAe,CAAA;AAGjF,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QThemeProvider/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;EAAmC,CAAA;AAGvD,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/esm/components/QThemeProvider/types.d.ts

@@ -1,6 +1,6 @@
 export type QThemeProviderProps = {
     /**
-     * The theme to apply to the downstream components.
+     * The theme to apply to the descendant components.
      */
     theme: string;
 };

package/esm/components/QTooltip/QTooltip.d.ts

@@ -22,11 +22,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {
-    class: string | unknown[];
     html: boolean;
-    anchor: import('../../utils/getElement').Selector;
-    icon: import('../QIcon').Icon;
-    id: string;
     appearance: import('../../composables/overlay').Appearance;
     arrow: boolean;
     attach: string;

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

@@ -1 +1 @@
-{"version":3,"file":"QTooltip.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTooltip/QTooltip.vue"],"names":[],"mappings":"AAkCA;AAuEC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAO7C,KAAK,WAAW,GAAG,aAAa,CAAC;AAuCjC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WA6DT,OAAO,IAA6B;;;;;;YATtB,GAAG;yBACF,GAAG;;;;EAa/B;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;6EAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAgBpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QTooltip.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTooltip/QTooltip.vue"],"names":[],"mappings":"AAkCA;AAmEC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAK5C,KAAK,WAAW,GAAG,aAAa,CAAC;AA2BlC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAkFT,OAAO,IAA6B;;;;;;YAXtB,GAAG;yBACF,GAAG;;;;EAe/B;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;6EAQnB,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"}