@quidgest/ui 0.14.10 → 0.14.12

package/esm/components/QDropdownMenu/QDropdownMenuContent.d.ts

@@ -0,0 +1,369 @@
+import { QDropdownMenuContentProps, DEFAULT_ICONS } from './types';
+import { Primitive } from '../../types/primitive';
+type __VLS_Props = QDropdownMenuContentProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        item?(_: {
+            item: import('../QList/types').Item;
+        }): any;
+        'item.append'?(_: {
+            item: import('../QList/types').Item;
+        }): any;
+    };
+    refs: {
+        contentRef: HTMLDivElement;
+        listRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: any;
+                readonly highlighted?: Primitive | undefined;
+                readonly items: import('../QList/types').Item[];
+                readonly groups?: import('../QList/types').Group[] | undefined;
+                readonly itemValue?: string | undefined;
+                readonly itemLabel?: string | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly class?: string | unknown[] | undefined;
+                readonly selectable?: boolean | undefined;
+                readonly "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                listRef: unknown;
+                listItemsRef: (({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly value: Primitive;
+                        readonly label: string;
+                        readonly icon?: import('..').Icon | undefined;
+                        readonly selected?: boolean | undefined;
+                        readonly highlighted?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly description?: string | undefined;
+                        readonly icons?: typeof import('../QList/types').DEFAULT_ICONS | undefined;
+                        readonly onSelect?: ((value: Primitive) => any) | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "select", value: Primitive) => void;
+                    $el: HTMLLIElement;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('../QList').QListItemProps> & Readonly<{
+                        onSelect?: ((value: Primitive) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                        select: (value: Primitive) => any;
+                    }, string, {
+                        icons: typeof import('../QList/types').DEFAULT_ICONS;
+                    }, {}, 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<{
+                    icons: typeof import('../QList/types').DEFAULT_ICONS;
+                }> & Omit<Readonly<import('../QList').QListItemProps> & Readonly<{
+                    onSelect?: ((value: Primitive) => any) | undefined;
+                }>, "icons"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        prepend?(_: {}): any;
+                        default?(_: {}): any;
+                        append?(_: {}): any;
+                    };
+                }) | null)[];
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "update:modelValue", value: any) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                modelValue?: any;
+            } & import('../QList').QListProps> & Readonly<{
+                "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+            }>, {
+                focusItem: (itemIdx: number, preventScroll?: boolean) => void;
+                getItem: (idx: number) => HTMLElement | undefined;
+                getAdjacentItemIndex: (idx: number, direction: "next" | "prev") => number;
+                getFirstFocusableItemIndex: () => number;
+                getLastFocusableItemIndex: () => number;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: any) => any;
+            }, string, {
+                groups: import('../QList/types').Group[];
+                itemValue: string;
+                itemLabel: string;
+            }, {}, 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<{
+            groups: import('../QList/types').Group[];
+            itemValue: string;
+            itemLabel: string;
+        }> & Omit<Readonly<{
+            modelValue?: any;
+        } & import('../QList').QListProps> & Readonly<{
+            "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        }>, "focusItem" | "getItem" | "getAdjacentItemIndex" | "getFirstFocusableItemIndex" | "getLastFocusableItemIndex" | ("groups" | "itemValue" | "itemLabel")> & import('vue').ShallowUnwrapRef<{
+            focusItem: (itemIdx: number, preventScroll?: boolean) => void;
+            getItem: (idx: number) => HTMLElement | undefined;
+            getAdjacentItemIndex: (idx: number, direction: "next" | "prev") => number;
+            getFirstFocusableItemIndex: () => number;
+            getLastFocusableItemIndex: () => number;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                item?(_: {
+                    item: import('../QList/types').Item;
+                    element: HTMLLIElement | undefined;
+                }): any;
+                'item.append'?(_: {
+                    item: import('../QList/types').Item;
+                    element: HTMLLIElement | undefined;
+                }): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    select: (item: Primitive | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onSelect?: ((item: Primitive | undefined) => any) | undefined;
+}>, {
+    transition: string;
+    icons: typeof DEFAULT_ICONS;
+    groups: import('./types').QDropdownMenuGroupProps[];
+    itemValue: string;
+    itemLabel: string;
+    appearance: import('../../composables/overlay').Appearance;
+    delay: number;
+    offset: number;
+    crossOffset: number;
+    placement: import('../../composables/overlay').Placement;
+    trigger: import('../../composables/overlay').Trigger;
+    depth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    contentRef: HTMLDivElement;
+    listRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: any;
+            readonly highlighted?: Primitive | undefined;
+            readonly items: import('../QList/types').Item[];
+            readonly groups?: import('../QList/types').Group[] | undefined;
+            readonly itemValue?: string | undefined;
+            readonly itemLabel?: string | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly class?: string | unknown[] | undefined;
+            readonly selectable?: boolean | undefined;
+            readonly "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            listRef: unknown;
+            listItemsRef: (({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly value: Primitive;
+                    readonly label: string;
+                    readonly icon?: import('..').Icon | undefined;
+                    readonly selected?: boolean | undefined;
+                    readonly highlighted?: boolean | undefined;
+                    readonly disabled?: boolean | undefined;
+                    readonly description?: string | undefined;
+                    readonly icons?: typeof import('../QList/types').DEFAULT_ICONS | undefined;
+                    readonly onSelect?: ((value: Primitive) => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: "select", value: Primitive) => void;
+                $el: HTMLLIElement;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('../QList').QListItemProps> & Readonly<{
+                    onSelect?: ((value: Primitive) => any) | undefined;
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                    select: (value: Primitive) => any;
+                }, string, {
+                    icons: typeof import('../QList/types').DEFAULT_ICONS;
+                }, {}, 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<{
+                icons: typeof import('../QList/types').DEFAULT_ICONS;
+            }> & Omit<Readonly<import('../QList').QListItemProps> & Readonly<{
+                onSelect?: ((value: Primitive) => any) | undefined;
+            }>, "icons"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    prepend?(_: {}): any;
+                    default?(_: {}): any;
+                    append?(_: {}): any;
+                };
+            }) | null)[];
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "update:modelValue", value: any) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: any;
+        } & import('../QList').QListProps> & Readonly<{
+            "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        }>, {
+            focusItem: (itemIdx: number, preventScroll?: boolean) => void;
+            getItem: (idx: number) => HTMLElement | undefined;
+            getAdjacentItemIndex: (idx: number, direction: "next" | "prev") => number;
+            getFirstFocusableItemIndex: () => number;
+            getLastFocusableItemIndex: () => number;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (value: any) => any;
+        }, string, {
+            groups: import('../QList/types').Group[];
+            itemValue: string;
+            itemLabel: string;
+        }, {}, 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<{
+        groups: import('../QList/types').Group[];
+        itemValue: string;
+        itemLabel: string;
+    }> & Omit<Readonly<{
+        modelValue?: any;
+    } & import('../QList').QListProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    }>, "focusItem" | "getItem" | "getAdjacentItemIndex" | "getFirstFocusableItemIndex" | "getLastFocusableItemIndex" | ("groups" | "itemValue" | "itemLabel")> & import('vue').ShallowUnwrapRef<{
+        focusItem: (itemIdx: number, preventScroll?: boolean) => void;
+        getItem: (idx: number) => HTMLElement | undefined;
+        getAdjacentItemIndex: (idx: number, direction: "next" | "prev") => number;
+        getFirstFocusableItemIndex: () => number;
+        getLastFocusableItemIndex: () => number;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            item?(_: {
+                item: import('../QList/types').Item;
+                element: HTMLLIElement | undefined;
+            }): any;
+            'item.append'?(_: {
+                item: import('../QList/types').Item;
+                element: HTMLLIElement | undefined;
+            }): any;
+        };
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=QDropdownMenuContent.vue.d.ts.map

package/esm/components/QDropdownMenu/QDropdownMenuContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QDropdownMenuContent.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QDropdownMenu/QDropdownMenuContent.vue"],"names":[],"mappings":"AAqDA;AAgNC,OAAO,KAAK,EAAE,yBAAyB,EAA0B,MAAM,SAAS,CAAA;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAGlD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,KAAK,WAAW,GAAG,yBAAyB,CAAC;AAyJ9C,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAyIT,OAAO,IAA6B;;;;YAbvB,GAAG;;;YACM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAwE6oT,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAvDzyT;AAuBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA+B+pT,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;OArBxyT,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/QDropdownMenu/QDropdownMenuContent.vue.js

@@ -0,0 +1,153 @@
+import { defineComponent as B, mergeModels as v, useModel as M, ref as l, computed as g, createBlock as T, openBlock as h, unref as y, normalizeClass as N, withCtx as f, createElementVNode as R, withModifiers as S, createVNode as U, renderSlot as w, createElementBlock as $, createCommentVNode as A, toDisplayString as F } from "vue";
+import { QList as Q } from "../QList/index.js";
+import { QOverlay as q } from "../QOverlay/index.js";
+import { DEFAULT_ICONS as z } from "./types.js";
+const K = {
+  key: 0,
+  class: "q-dropdown-menu__extra"
+}, G = /* @__PURE__ */ B({
+  __name: "QDropdownMenuContent",
+  props: /* @__PURE__ */ v({
+    activator: {},
+    appearance: { default: "regular" },
+    inline: { type: Boolean },
+    delay: { default: 500 },
+    placement: { default: "right-start" },
+    transition: { default: "fade" },
+    class: {},
+    items: {},
+    groups: { default: () => [] },
+    itemValue: { default: "key" },
+    itemLabel: { default: "label" },
+    icons: { default: () => z },
+    trigger: { default: "click" },
+    offset: { default: 0 },
+    crossOffset: { default: -5 },
+    depth: { default: 0 }
+  }, {
+    modelValue: { type: Boolean },
+    modelModifiers: {}
+  }),
+  emits: /* @__PURE__ */ v(["select"], ["update:modelValue"]),
+  setup(d, { emit: k }) {
+    const e = d, _ = k, a = M(d, "modelValue"), s = l(void 0), c = l([]), r = l(""), b = g(() => e.depth !== 0 ? e.offset : 4), L = g(() => e.depth !== 0 ? e.crossOffset : void 0);
+    let m;
+    const u = l(null), p = l(null);
+    function V(t) {
+      s.value = t;
+      const o = e.items.find((n) => n[e.itemValue] === t);
+      o && (c.value = (o == null ? void 0 : o.items) ?? []), c.value.length || (_("select", t), s.value = void 0, i());
+    }
+    function C() {
+      a.value || (a.value = !0);
+    }
+    function i() {
+      a.value && (a.value = !1);
+    }
+    function E() {
+      a.value ? i() : C();
+    }
+    function I(t) {
+      if (t.key) {
+        if (window.clearTimeout(m), ["Escape", "Tab", "Delete"].includes(t.key)) {
+          i();
+          return;
+        }
+        if (["Enter", " ", "ArrowDown", "ArrowUp", "Home", "End"].includes(t.key) && (t.preventDefault(), t.stopPropagation()), /^[a-z]$/i.test(t.key)) {
+          r.value += t.key.toLowerCase();
+          for (let o = 0; o < e.items.length; o++) {
+            const n = e.items[o];
+            if (n[e.itemLabel] && n[e.itemLabel].toLowerCase().startsWith(r.value)) {
+              x(o);
+              break;
+            }
+          }
+        }
+        m = window.setTimeout(function() {
+          r.value = "";
+        }, 500);
+      }
+    }
+    function D(t) {
+      var o;
+      (o = p.value) != null && o.contains(t.relatedTarget) || i();
+    }
+    function O() {
+      var t;
+      (t = u.value) == null || t.$el.focus();
+    }
+    function x(t) {
+      var o;
+      (o = u.value) == null || o.focusItem(t);
+    }
+    return (t, o) => (h(), T(y(q), {
+      "model-value": a.value,
+      anchor: e.activator,
+      appearance: e.appearance,
+      inline: e.inline,
+      delay: e.delay,
+      offset: b.value,
+      "cross-offset": L.value,
+      placement: e.placement,
+      transition: e.transition,
+      class: N(e.class),
+      trigger: e.trigger,
+      "non-modal": "",
+      "scroll-lock": "",
+      persistent: "",
+      "onUpdate:modelValue": E,
+      onEnter: O
+    }, {
+      default: f(() => [
+        R(
+          "div",
+          {
+            ref_key: "contentRef",
+            ref: p,
+            "data-testid": "dropdown-content",
+            tabindex: "-1",
+            onFocusout: D,
+            onKeydown: S(I, ["stop"])
+          },
+          [
+            U(y(Q), {
+              ref_key: "listRef",
+              ref: u,
+              class: "q-dropdown-menu__items",
+              highlighted: s.value,
+              items: e.items,
+              groups: e.groups,
+              "item-label": e.itemLabel,
+              "item-value": e.itemValue,
+              "onUpdate:modelValue": V
+            }, {
+              item: f(({ item: n }) => [
+                w(t.$slots, "item", { item: n })
+              ]),
+              "item.append": f(({ item: n }) => [
+                w(t.$slots, "item.append", { item: n }, () => [
+                  n.extraInfo ? (h(), $(
+                    "span",
+                    K,
+                    F(n.extraInfo),
+                    1
+                    /* TEXT */
+                  )) : A("v-if", !0)
+                ])
+              ]),
+              _: 3
+              /* FORWARDED */
+            }, 8, ["highlighted", "items", "groups", "item-label", "item-value"])
+          ],
+          544
+          /* NEED_HYDRATION, NEED_PATCH */
+        )
+      ]),
+      _: 3
+      /* FORWARDED */
+    }, 8, ["model-value", "anchor", "appearance", "inline", "delay", "offset", "cross-offset", "placement", "transition", "class", "trigger"]));
+  }
+});
+export {
+  G as default
+};

package/esm/components/QDropdownMenu/QDropdownMenuContent.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QDropdownMenuContent.vue.js";
+export {
+  f as default
+};

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

@@ -0,0 +1,14 @@
+declare const QDropdownMenu: import('vue').DefineComponent<{
+    modelValue?: boolean;
+} & import('./types').QDropdownMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    select: (item: import('../../types/primitive').Primitive | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<{
+    modelValue?: boolean;
+} & import('./types').QDropdownMenuProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onSelect?: ((item: import('../../types/primitive').Primitive | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export { QDropdownMenu };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QDropdownMenu/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,aAAa;;;;;;;;;;;kFAAkC,CAAA;AAGrD,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/esm/components/QDropdownMenu/index.js

@@ -0,0 +1,6 @@
+import o from "./QDropdownMenu.vue.js";
+import { setupPropsProxy as r } from "../../utils/setupPropsProxy.js";
+const t = r(o);
+export {
+  t as QDropdownMenu
+};

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

@@ -0,0 +1,96 @@
+import { QListItemGroupProps, QListItemProps } from '../QList';
+import { Appearance, Placement, Trigger } from '../../composables/overlay';
+import { Selector } from '../../utils/getElement';
+export type QDropdownMenuProps = {
+    /**
+     * The DOM element used to activate the dropdown menu.
+     */
+    activator?: Selector;
+    /**
+     * The appearance of the dropdown menu.
+     * 'regular' uses body text color for background and body background color for text.
+     * 'inverted' matches body color scheme.
+     */
+    appearance?: Appearance;
+    /**
+     * Whether to disable teleport.
+     */
+    inline?: boolean;
+    /**
+     * The delay in milliseconds before showing the dropdown menu.
+     */
+    delay?: number;
+    /**
+     * The placement of the dropdown menu.
+     */
+    placement?: Placement;
+    /**
+     * The name of the transition to apply.
+     */
+    transition?: string;
+    /**
+     * Custom set of classes to apply to the component.
+     */
+    class?: string | unknown[];
+    /**
+     * The list of available items for selection.
+     */
+    items: QDropdownMenuItemProps[];
+    /**
+     * The item groups used for organizing the available items.
+     */
+    groups?: QDropdownMenuGroupProps[];
+    /**
+     * Property on each item that contains its value.
+     */
+    itemValue?: string;
+    /**
+     * Property on each item that contains its title.
+     */
+    itemLabel?: string;
+    /**
+     * Custom icon configurations.
+     */
+    icons?: typeof DEFAULT_ICONS;
+};
+export type QDropdownMenuContentProps = QDropdownMenuProps & {
+    /**
+     * The method to trigger the dropdown menu.
+     */
+    trigger?: Trigger;
+    /**
+     * Offset the dropdown menu in the given amount of pixels.
+     */
+    offset?: number;
+    /**
+     * Offset the dropdown menu in the given amount of pixels (opposite to the main axis).
+     */
+    crossOffset?: number;
+    /**
+     * Depth for recursive nesting
+     */
+    depth?: number;
+};
+export type QDropdownMenuItemProps = Omit<QListItemProps, 'value' | 'label'> & {
+    /**
+     * The list of available items for selection.
+     */
+    items?: QDropdownMenuItemProps[];
+    /**
+     * The item groups used for organizing the available items.
+     */
+    groups?: QDropdownMenuGroupProps[];
+    [key: string]: any;
+};
+export type QDropdownMenuGroupProps = QListItemGroupProps & {
+    /**
+     * Whether the entire item group is disabled.
+     */
+    disabled?: boolean;
+};
+export declare const DEFAULT_ICONS: {
+    expand: {
+        icon: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QDropdownMenu/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAElD,MAAM,MAAM,kBAAkB,GAAG;IAChC;;OAEG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAA;IAEpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,CAAA;IAEvB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;IAE1B;;OAEG;IACH,KAAK,EAAE,sBAAsB,EAAE,CAAA;IAE/B;;OAEG;IACH,MAAM,CAAC,EAAE,uBAAuB,EAAE,CAAA;IAElC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,kBAAkB,GAAG;IAC5D;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG;IAC9E;;OAEG;IACH,KAAK,CAAC,EAAE,sBAAsB,EAAE,CAAA;IAEhC;;OAEG;IACH,MAAM,CAAC,EAAE,uBAAuB,EAAE,CAAA;IAIlC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,mBAAmB,GAAG;IAC3D;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAGD,eAAO,MAAM,aAAa;;;;CAIM,CAAA"}