@quidgest/ui 0.14.11 → 0.14.12

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;
@@ -100,15 +94,78 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => 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":"AA8CA;AAyFC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM9C,KAAK,WAAW,GAAG,eAAe,CAAC;AAoCpC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WA6GT,OAAO,IAA6B;;iCAjBb,GAAG;gCACJ,GAAG;yBACV,GAAG;wBACH,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAkE2ijB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;EAhDhsjB;AAgBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+BsjjB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;OArB/rjB,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,41 +1,41 @@
-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 { defineComponent as b, mergeModels as h, useModel as q, ref as f, computed as u, createBlock as $, openBlock as k, unref as o, normalizeClass as g, createSlots as v, withCtx as d, withDirectives as x, createElementVNode as R, mergeProps as z, vModelDynamic as B, renderSlot as a } 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({
   inheritAttrs: !1,
   __name: "QTextField",
   props: /* @__PURE__ */ h({
-    id: { default: void 0 },
-    placeholder: { default: "" },
-    label: { default: "" },
-    size: { default: void 0 },
-    maxLength: { default: void 0 },
+    id: {},
+    placeholder: {},
+    label: {},
+    size: {},
+    maxLength: {},
     readonly: { type: Boolean },
     disabled: { type: Boolean },
     required: { type: Boolean },
-    role: { default: void 0 },
+    role: {},
     type: { default: "text" },
-    class: { default: void 0 }
+    class: {}
   }, {
     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
+  setup(r, { expose: m }) {
+    const e = r, n = q(r, "modelValue"), s = M(e.id), t = f(null), i = f(null), y = u(
+      () => e.readonly || e.disabled ? void 0 : e.placeholder
     );
     return m({
       fieldRef: u(() => {
         var l;
-        return (l = s.value) == null ? void 0 : l.fieldRef;
+        return (l = t.value) == null ? void 0 : l.fieldRef;
       }),
       inputRef: i
-    }), (l, p) => ($(), k(n(V), {
+    }), (l, p) => (k(), $(o(V), {
       ref_key: "fieldRef",
-      ref: s,
+      ref: t,
       class: g(["q-text-field", e.class]),
-      for: n(t),
+      for: o(s),
       label: e.label,
       size: e.size,
       readonly: e.readonly,
@@ -50,10 +50,10 @@ const C = ["id", "type", "role", "required", "placeholder", "readonly", "disable
       ]),
       default: d(() => [
         x(R("input", z({
-          id: n(t),
+          id: o(s),
           ref_key: "inputRef",
           ref: i,
-          "onUpdate:modelValue": p[0] || (p[0] = (c) => r.value = c),
+          "onUpdate:modelValue": p[0] || (p[0] = (c) => n.value = c),
           class: "q-text-field__input",
           type: e.type,
           role: e.role,
@@ -63,7 +63,7 @@ const C = ["id", "type", "role", "required", "placeholder", "readonly", "disable
           disabled: e.disabled,
           maxlength: e.maxLength
         }, l.$attrs), null, 16, C), [
-          [B, r.value]
+          [B, n.value]
         ])
       ]),
       _: 2

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

@@ -1,4 +1,124 @@
-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;
+    }>, {
+        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;
+    }, 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;
+    }>, {
+        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;
+}>, {
+    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;
+}, 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/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"}

package/esm/components/QTooltip/QTooltip.vue.js

@@ -1,12 +1,12 @@
-import { defineComponent as s, mergeModels as p, useModel as u, openBlock as a, createElementBlock as l, Fragment as d, renderSlot as i, unref as t, createVNode as m, normalizeClass as f, withCtx as h, createBlock as y, normalizeProps as g, mergeProps as B, createCommentVNode as b, createTextVNode as v, toDisplayString as k } from "vue";
+import { defineComponent as s, mergeModels as p, useModel as m, createElementBlock as o, openBlock as a, Fragment as d, renderSlot as i, createVNode as u, unref as t, normalizeClass as f, withCtx as h, createBlock as y, createCommentVNode as g, normalizeProps as B, mergeProps as b, createTextVNode as v, toDisplayString as k } from "vue";
 import { QOverlay as V } from "../QOverlay/index.js";
 import { QIcon as w } from "../QIcon/index.js";
 import { useId as x } from "../../composables/uid.js";
 const M = ["innerHTML"], z = /* @__PURE__ */ s({
   __name: "QTooltip",
   props: /* @__PURE__ */ p({
-    id: { default: void 0 },
-    anchor: { default: void 0 },
+    id: {},
+    anchor: {},
     appearance: { default: "inverted" },
     arrow: { type: Boolean, default: !0 },
     attach: { default: "body" },
@@ -16,25 +16,25 @@ const M = ["innerHTML"], z = /* @__PURE__ */ s({
     html: { type: Boolean, default: !0 },
     placement: { default: "right" },
     text: {},
-    icon: { default: void 0 },
+    icon: {},
     trigger: { default: "hover" },
-    class: { default: void 0 }
+    class: {}
   }, {
     modelValue: { type: Boolean },
     modelModifiers: {}
   }),
   emits: ["update:modelValue"],
-  setup(o) {
-    const e = o, c = u(o, "modelValue"), n = x(e.id);
-    return (r, _) => (a(), l(
+  setup(l) {
+    const e = l, c = m(l, "modelValue"), r = x(e.id);
+    return (n, _) => (a(), o(
       d,
       null,
       [
-        i(r.$slots, "anchor", {
-          props: { "aria-describedby": t(n) }
+        i(n.$slots, "anchor", {
+          props: { "aria-describedby": t(r) }
         }),
-        m(t(V), {
-          id: t(n),
+        u(t(V), {
+          id: t(r),
           "model-value": c.value,
           anchor: e.anchor,
           role: "tooltip",
@@ -50,18 +50,18 @@ const M = ["innerHTML"], z = /* @__PURE__ */ s({
           trigger: e.trigger
         }, {
           default: h(() => [
-            i(r.$slots, "default", {}, () => [
+            i(n.$slots, "default", {}, () => [
               e.icon ? (a(), y(
                 t(w),
-                g(B({ key: 0 }, e.icon)),
+                B(b({ key: 0 }, e.icon)),
                 null,
                 16
                 /* FULL_PROPS */
-              )) : b("v-if", !0),
-              e.html ? (a(), l("span", {
+              )) : g("v-if", !0),
+              e.html ? (a(), o("span", {
                 key: 1,
                 innerHTML: e.text
-              }, null, 8, M)) : (a(), l(
+              }, null, 8, M)) : (a(), o(
                 d,
                 { key: 2 },
                 [

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

@@ -1,4 +1,64 @@
-import { default as _QTooltip } from './QTooltip';
-declare const QTooltip: typeof _QTooltip;
+declare const QTooltip: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: boolean;
+    } & import('./types').QTooltipProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: boolean) => any;
+    }, import('vue').PublicProps, {
+        html: boolean;
+        appearance: import('../../composables/overlay').Appearance;
+        arrow: boolean;
+        attach: string;
+        delay: number;
+        placement: import('../../composables/overlay').Placement;
+        trigger: import('../../composables/overlay').Trigger;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: boolean;
+    } & import('./types').QTooltipProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        html: boolean;
+        appearance: import('../../composables/overlay').Appearance;
+        arrow: boolean;
+        attach: string;
+        delay: number;
+        placement: import('../../composables/overlay').Placement;
+        trigger: import('../../composables/overlay').Trigger;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: boolean;
+} & import('./types').QTooltipProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, {
+    html: boolean;
+    appearance: import('../../composables/overlay').Appearance;
+    arrow: boolean;
+    attach: string;
+    delay: number;
+    placement: import('../../composables/overlay').Placement;
+    trigger: import('../../composables/overlay').Trigger;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        anchor?(_: {
+            props: {
+                'aria-describedby': string;
+            };
+        }): any;
+        default?(_: {}): any;
+    };
+});
 export { QTooltip };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QTooltip/index.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAKtC,QAAA,MAAM,QAAQ,EAAiC,OAAO,SAAS,CAAA;AAG/D,OAAO,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QTooltip/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAA;AAG3C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/esm/components/__internal__/QChevron/QChevron.d.ts

@@ -0,0 +1,14 @@
+import { DEFAULT_ICONS, QChevronProps } from './types';
+type __VLS_Props = QChevronProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    icons: typeof DEFAULT_ICONS;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=QChevron.vue.d.ts.map

package/esm/components/__internal__/QChevron/QChevron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QChevron.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/__internal__/QChevron/QChevron.vue"],"names":[],"mappings":"AAKA;AAyBC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAMvC,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,KAAK,WAAW,GAAG,aAAa,CAAC;AAalC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;;;;;;;;AAsDhB,wBASG"}