@ulu/frontend-vue 0.2.0-beta.2 → 0.2.0-beta.4

package/dist/components/layout/UluWhenBreakpoint.vue.d.ts

@@ -0,0 +1,24 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    max?: string | undefined;
+    min?: string | undefined;
+    only?: string | undefined;
+    $props: {
+        readonly max?: string | undefined;
+        readonly min?: string | undefined;
+        readonly only?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+//# sourceMappingURL=UluWhenBreakpoint.vue.d.ts.map

package/dist/components/layout/UluWhenBreakpoint.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluWhenBreakpoint.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/layout/UluWhenBreakpoint.vue"],"names":[],"mappings":"AAGA;wBA6OqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;2OAOG"}

package/dist/components/layout/UluWhenBreakpoint.vue.js

@@ -0,0 +1,59 @@
+import { ref as f, computed as d, watch as m, onBeforeUnmount as y, renderSlot as k, createCommentVNode as S } from "vue";
+import { useRequiredInject as g } from "../../composables/useRequiredInject.js";
+const B = {
+  __name: "UluWhenBreakpoint",
+  props: {
+    /**
+     * The maximum breakpoint to show the content at.
+     */
+    max: String,
+    /**
+     * The minimum breakpoint to show the content at.
+     */
+    min: String,
+    /**
+     * Only show the content at this breakpoint.
+     */
+    only: String
+  },
+  setup(p) {
+    const o = p, r = g("uluBreakpointManager"), l = f({}), c = f([]), u = f(!1), h = d(() => !u.value || ["max", "min", "only"].filter((e) => o[e]).length === 0 ? !1 : Object.values(l.value).every((e) => e)), v = (a) => {
+      const e = (t) => {
+        const n = o[t];
+        if (n) {
+          l.value[t] = !1;
+          const s = {
+            on: () => {
+              l.value[t] = !0;
+            },
+            off: () => {
+              l.value[t] = !1;
+            }
+          };
+          a.at(n)[t](s), c.value.push({ name: n, direction: t, handler: s });
+        }
+      };
+      e("max"), e("min"), e("only"), u.value = !0;
+    }, i = () => {
+      r.value && c.value.forEach(({ name: a, direction: e, handler: t }) => {
+        const n = r.value.at(a);
+        if (n)
+          try {
+            n.remove(t, e);
+          } catch (s) {
+            console.error(s);
+          }
+      }), c.value = [], l.value = {}, u.value = !1;
+    };
+    return m(r, (a) => {
+      a && !u.value && v(a);
+    }, { immediate: !0 }), m([() => o.max, () => o.min, () => o.only], () => {
+      r.value && u.value && (i(), v(r.value));
+    }), y(() => {
+      i();
+    }), (a, e) => h.value ? k(a.$slots, "default", { key: 0 }) : S("", !0);
+  }
+};
+export {
+  B as default
+};

package/dist/{types/components → components}/navigation/UluBreadcrumb.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /**
      * Array of breadcrumb items.
      * Each item is an object: { title: String, to: [String, Object], current: Boolean }
@@ -26,7 +26,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             separator: string;
         };
     };
-}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /**
      * Array of breadcrumb items.
      * Each item is an object: { title: String, to: [String, Object], current: Boolean }
@@ -58,14 +58,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     classes: Record<string, any>;
     items: unknown[];
 }, {}, {
-    UluIcon: import("vue").DefineComponent<{}, {
-        $props: Partial<{
-            readonly spaced: boolean;
-            readonly icon?: string | boolean | Record<string, any> | unknown[] | undefined;
-        }>;
+    UluIcon: import('vue').DefineComponent<{}, {
         spaced: boolean;
         icon?: string | boolean | Record<string, any> | unknown[] | undefined;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        $props: {
+            readonly spaced?: boolean | undefined;
+            readonly icon?: string | boolean | Record<string, any> | unknown[] | undefined;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluBreadcrumb.vue.d.ts.map

package/dist/components/navigation/UluBreadcrumb.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluBreadcrumb.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluBreadcrumb.vue"],"names":[],"mappings":"AAmCA;;IA0FM;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;;OAGG;;;;;;;;;;;;;IAfH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;;OAGG"}

package/dist/components/navigation/UluBreadcrumb.vue.js

@@ -0,0 +1,86 @@
+import b from "../elements/UluIcon.vue.js";
+import { resolveComponent as o, createElementBlock as s, createCommentVNode as u, openBlock as a, normalizeClass as t, createElementVNode as f, Fragment as k, renderList as p, createBlock as y, renderSlot as c, withCtx as g, createTextVNode as i, toDisplayString as m, createVNode as B } from "vue";
+import h from "../../_virtual/_plugin-vue_export-helper.js";
+const I = {
+  name: "UluBreadcrumb",
+  components: {
+    UluIcon: b
+  },
+  props: {
+    /**
+     * Array of breadcrumb items.
+     * Each item is an object: { title: String, to: [String, Object], current: Boolean }
+     */
+    items: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * Icon to use as a separator.
+     */
+    separatorIcon: String,
+    /**
+     * Classes object to be applied to elements.
+     * Keys: nav, list, item, link, icon
+     */
+    classes: {
+      type: Object,
+      default: () => ({
+        nav: "breadcrumb",
+        list: "breadcrumb__list",
+        item: "breadcrumb__item",
+        link: "breadcrumb__link",
+        current: "breadcrumb__current",
+        separator: "breadcrumb__separator"
+      })
+    }
+  }
+};
+function U(l, v, e, C, N, S) {
+  const d = o("router-link"), _ = o("UluIcon");
+  return e.items.length ? (a(), s("nav", {
+    key: 0,
+    class: t(e.classes.nav),
+    "aria-label": "Breadcrumb"
+  }, [
+    f("ol", {
+      class: t(e.classes.list)
+    }, [
+      (a(!0), s(k, null, p(e.items, (r, n) => (a(), s("li", {
+        key: n,
+        class: t(e.classes.item)
+      }, [
+        r.current ? (a(), s("span", {
+          key: 1,
+          class: t(r.current)
+        }, [
+          c(l.$slots, "default", { item: r }, () => [
+            i(m(r.title), 1)
+          ])
+        ], 2)) : (a(), y(d, {
+          key: 0,
+          to: r.to,
+          class: t(e.classes.link),
+          "aria-current": r.current ? "page" : null
+        }, {
+          default: g(() => [
+            c(l.$slots, "default", { item: r }, () => [
+              i(m(r.title), 1)
+            ])
+          ]),
+          _: 2
+        }, 1032, ["to", "class", "aria-current"])),
+        n < e.items.length - 1 ? c(l.$slots, "separator", { key: 2 }, () => [
+          B(_, {
+            class: t(e.classes.separator),
+            icon: e.separatorIcon || "type:pathSeparator"
+          }, null, 8, ["class", "icon"])
+        ]) : u("", !0)
+      ], 2))), 128))
+    ], 2)
+  ], 2)) : u("", !0);
+}
+const w = /* @__PURE__ */ h(I, [["render", U]]);
+export {
+  w as default
+};

package/dist/{types/components → components}/navigation/UluMenu.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /**
      * Items Array of Objects for each link
      * [{
@@ -30,7 +30,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     noChildren: BooleanConstructor;
 }>, {}, {}, {}, {
     handleItemClick(event: any, item: any): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "item-click"[], "item-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "item-click"[], "item-click", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /**
      * Items Array of Objects for each link
      * [{
@@ -67,31 +67,31 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     iconOnly: boolean;
     noChildren: boolean;
 }, {}, {
-    UluIcon: import("vue").DefineComponent<{}, {
-        $props: Partial<{
-            readonly spaced: boolean;
-            readonly icon?: string | boolean | Record<string, any> | unknown[] | undefined;
-        }>;
+    UluIcon: import('vue').DefineComponent<{}, {
         spaced: boolean;
         icon?: string | boolean | Record<string, any> | unknown[] | undefined;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        $props: {
+            readonly spaced?: boolean | undefined;
+            readonly icon?: string | boolean | Record<string, any> | unknown[] | undefined;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
     UluTag: {
-        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
-            $props: Partial<{
-                readonly counter: boolean;
-                readonly size?: string | undefined;
-                readonly type?: string | undefined;
-                readonly text?: string | number | undefined;
-                readonly icon?: string | unknown[] | undefined;
-                readonly modifiers?: string | unknown[] | undefined;
-            }>;
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
             counter: boolean;
-            size?: string | undefined;
             type?: string | undefined;
-            text?: string | number | undefined;
+            size?: string | undefined;
             icon?: string | unknown[] | undefined;
             modifiers?: string | unknown[] | undefined;
-        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            text?: string | number | undefined;
+            $props: {
+                readonly counter?: boolean | undefined;
+                readonly type?: string | undefined;
+                readonly size?: string | undefined;
+                readonly icon?: string | unknown[] | undefined;
+                readonly modifiers?: string | unknown[] | undefined;
+                readonly text?: string | number | undefined;
+            };
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLSpanElement, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
@@ -99,44 +99,44 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             M: {};
             Defaults: {};
         }, Readonly<{}> & Readonly<{}>, {
-            $props: Partial<{
-                readonly counter: boolean;
-                readonly size?: string | undefined;
-                readonly type?: string | undefined;
-                readonly text?: string | number | undefined;
-                readonly icon?: string | unknown[] | undefined;
-                readonly modifiers?: string | unknown[] | undefined;
-            }>;
             counter: boolean;
-            size?: string | undefined;
             type?: string | undefined;
-            text?: string | number | undefined;
+            size?: string | undefined;
             icon?: string | unknown[] | undefined;
             modifiers?: string | unknown[] | undefined;
+            text?: string | number | undefined;
+            $props: {
+                readonly counter?: boolean | undefined;
+                readonly type?: string | undefined;
+                readonly size?: string | undefined;
+                readonly icon?: string | unknown[] | undefined;
+                readonly modifiers?: string | unknown[] | undefined;
+                readonly text?: string | number | undefined;
+            };
         }, {}, {}, {}, {}>;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
-        $props: Partial<{
-            readonly counter: boolean;
-            readonly size?: string | undefined;
-            readonly type?: string | undefined;
-            readonly text?: string | number | undefined;
-            readonly icon?: string | unknown[] | undefined;
-            readonly modifiers?: string | unknown[] | undefined;
-        }>;
+    } & import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
         counter: boolean;
-        size?: string | undefined;
         type?: string | undefined;
-        text?: string | number | undefined;
+        size?: string | undefined;
         icon?: string | unknown[] | undefined;
         modifiers?: string | unknown[] | undefined;
-    }, {}, {}, {}, 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 () => {
+        text?: string | number | undefined;
+        $props: {
+            readonly counter?: boolean | undefined;
+            readonly type?: string | undefined;
+            readonly size?: string | undefined;
+            readonly icon?: string | unknown[] | undefined;
+            readonly modifiers?: string | unknown[] | undefined;
+            readonly text?: string | number | undefined;
+        };
+    }, {}, {}, {}, 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?: (props: {}) => any;
+            default?(_: {}): any;
         };
     });
-}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluMenu.vue.d.ts.map

package/dist/components/navigation/UluMenu.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluMenu.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluMenu.vue"],"names":[],"mappings":"AAmDA;;IAoIM;;;;;;;;;;;OAWG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IA3BH;;;;;;;;;;;OAWG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG"}

package/dist/components/navigation/UluMenu.vue.js

@@ -0,0 +1,119 @@
+import C from "../elements/UluIcon.vue.js";
+import g from "../elements/UluTag.vue.js";
+import { resolveComponent as r, resolveDirective as U, createElementBlock as i, createCommentVNode as t, openBlock as n, normalizeClass as a, Fragment as v, renderList as x, withDirectives as B, createBlock as o, resolveDynamicComponent as I, mergeProps as f, withCtx as O, renderSlot as A, createElementVNode as T, toDisplayString as b } from "vue";
+import D from "../../_virtual/_plugin-vue_export-helper.js";
+const M = {
+  name: "UluMenu",
+  components: {
+    UluIcon: C,
+    UluTag: g
+  },
+  emits: [
+    /**
+     * Fired anytime a item is clicked
+     */
+    "item-click"
+  ],
+  props: {
+    /**
+     * Items Array of Objects for each link
+     * [{
+     *   title: String (title of link)
+     *   icon: Icon definition passed to UluIcon
+     *   tag: Tag appearing after link text (count/etc), pass props you want bound to tag
+     *   tooltip: Add tooltip to menu item (pass options for tooltip), unless iconOnly than the title is presented in the tooltip
+     *   href: Will result in <a>
+     *   click: Will be called on click and result in <button>
+     *   to: Will result in <a> and use vue-router router-link component
+     * }]
+     */
+    items: Array,
+    /**
+     * Classes object to add class bindings to the different elements
+     * - { list, item, link, linkActive, linkExactActive, linkIcon, linkText }
+     */
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Use icon only version of menu
+     */
+    iconOnly: Boolean,
+    /**
+     * Do not print menu items children recursively
+     */
+    noChildren: Boolean
+  },
+  methods: {
+    handleItemClick(s, c) {
+      c.click && c.click(s), this.$emit("item-click", { item: c, event: s });
+    }
+  }
+};
+function S(s, c, e, E, w, k) {
+  const _ = r("UluIcon"), d = r("UluTag"), h = r("UluMenu", !0), y = U("ulu-tooltip");
+  return e.items?.length ? (n(), i("ul", {
+    key: 0,
+    class: a(e.classes.list)
+  }, [
+    (n(!0), i(v, null, x(e.items, (l, u) => (n(), i("li", {
+      key: u,
+      class: a([
+        e.classes.item,
+        l?.classes?.item,
+        l.separatorBefore ? e.classes.itemSeparatorBefore : "",
+        l.separatorAfter ? e.classes.itemSeparatorAfter : ""
+      ])
+    }, [
+      B((n(), o(I(l.to || l.path ? "router-link" : l.click ? "button" : "a"), f({ ref_for: !0 }, {
+        ...l.to || l.path ? {
+          to: l.to || l.path,
+          activeClass: e.classes.linkActive || null,
+          exactActiveClass: e.classes.linkExactActive || null
+        } : {},
+        ...l.href ? { href: l.href || "#" } : {}
+      }, {
+        onClick: (m) => {
+          k.handleItemClick(m, l);
+        },
+        class: [e.classes.link, l?.classes?.link],
+        "aria-label": e.iconOnly ? l.title : null,
+        id: l.id
+      }), {
+        default: O(() => [
+          A(s.$slots, "default", {
+            item: l,
+            index: u
+          }, () => [
+            l.icon ? (n(), o(_, {
+              key: 0,
+              icon: l.icon,
+              class: a([e.classes.linkIcon, l?.classes?.linkIcon])
+            }, null, 8, ["icon", "class"])) : t("", !0),
+            T("span", {
+              class: a([e.classes.linkText, l?.classes?.linkText])
+            }, b(l.title), 3),
+            l.tag ? (n(), o(d, f({
+              key: 1,
+              ref_for: !0
+            }, l.tag), null, 16)) : t("", !0)
+          ])
+        ]),
+        _: 2
+      }, 1040, ["onClick", "class", "aria-label", "id"])), [
+        [y, e.iconOnly ? l.title : l.tooltip || null]
+      ]),
+      !e.noChildren && l?.children?.length ? (n(), o(h, {
+        key: 0,
+        iconOnly: e.iconOnly,
+        classes: e.classes,
+        items: l.children
+      }, null, 8, ["iconOnly", "classes", "items"])) : t("", !0)
+    ], 2))), 128))
+  ], 2)) : t("", !0);
+}
+const F = /* @__PURE__ */ D(M, [["render", S]]);
+export {
+  F as default
+};

package/dist/components/navigation/UluMenuStack.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    noChildren: boolean;
+    containerElement: string;
+    hanging: boolean;
+    compact: boolean;
+    modifiers?: string | unknown[] | undefined;
+    items?: unknown[] | undefined;
+    $props: {
+        readonly noChildren?: boolean | undefined;
+        readonly containerElement?: string | undefined;
+        readonly hanging?: boolean | undefined;
+        readonly compact?: boolean | undefined;
+        readonly modifiers?: string | unknown[] | undefined;
+        readonly items?: unknown[] | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluMenuStack.vue.d.ts.map

package/dist/components/navigation/UluMenuStack.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluMenuStack.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluMenuStack.vue"],"names":[],"mappings":"AAqBA;"}

package/dist/components/navigation/UluMenuStack.vue.js

@@ -0,0 +1,68 @@
+import { computed as i, createBlock as o, openBlock as r, resolveDynamicComponent as s, normalizeClass as c, unref as m, withCtx as l, createVNode as u } from "vue";
+import k from "./UluMenu.vue.js";
+import { useModifiers as f } from "../../composables/useModifiers.js";
+const C = {
+  __name: "UluMenuStack",
+  props: {
+    /**
+     * Menu item (see UluMenu)
+     */
+    items: Array,
+    /**
+    * The HTML element to use as the container (e.g., 'nav', 'div', 'aside').
+     */
+    containerElement: {
+      type: String,
+      default: "nav"
+    },
+    /**
+     * Hanging style menu
+     */
+    hanging: Boolean,
+    /**
+     * Compact style menu
+     */
+    compact: Boolean,
+    /**
+     * Don't include children of menu
+     */
+    noChildren: Boolean,
+    /**
+     * Class modifiers (ie. 'transparent', 'secondary', etc)
+     */
+    modifiers: [String, Array]
+  },
+  setup(e) {
+    const n = e, t = i(() => ({
+      hanging: n.hanging,
+      compact: n.compact
+    })), { resolvedModifiers: a } = f({
+      props: n,
+      internal: t,
+      baseClass: "menu-stack"
+    });
+    return (_, d) => (r(), o(s(e.containerElement), {
+      class: c(["menu-stack", m(a)])
+    }, {
+      default: l(() => [
+        u(k, {
+          items: e.items,
+          classes: {
+            list: "menu-stack__list",
+            item: "menu-stack__item",
+            link: "menu-stack__link",
+            linkText: "menu-stack__link-text",
+            linkIcon: "menu-stack__link-icon",
+            itemSeparatorBefore: "menu-stack__item--separator-before",
+            itemSeparatorAfter: "menu-stack__item--separator-after"
+          },
+          noChildren: e.noChildren
+        }, null, 8, ["items", "noChildren"])
+      ]),
+      _: 1
+    }, 8, ["class"]));
+  }
+};
+export {
+  C as default
+};