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

package/dist/_virtual/_plugin-vue_export-helper.js

@@ -0,0 +1,9 @@
+const s = (t, e) => {
+  const o = t.__vccOpts || t;
+  for (const [r, c] of e)
+    o[r] = c;
+  return o;
+};
+export {
+  s as default
+};

package/dist/components/collapsible/UluAccordion.vue.d.ts

@@ -0,0 +1,42 @@
+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<{}, {
+    $emit: (event: "update:modelValue", ...args: any[]) => void;
+    startOpen: boolean;
+    classes: Record<string, any>;
+    animate: boolean | Record<string, any>;
+    triggerTextElement: string;
+    triggerText?: string | undefined;
+    modelValue?: boolean | undefined;
+    modifiers?: string | unknown[] | undefined;
+    $props: {
+        readonly startOpen?: boolean | undefined;
+        readonly classes?: Record<string, any> | undefined;
+        readonly animate?: boolean | Record<string, any> | undefined;
+        readonly triggerTextElement?: string | undefined;
+        readonly triggerText?: string | undefined;
+        readonly modelValue?: boolean | undefined;
+        readonly modifiers?: string | unknown[] | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            isOpen: boolean | undefined;
+        }): any;
+        icon?(_: {
+            isOpen: boolean | undefined;
+        }): any;
+        default?(_: {
+            isOpen: true;
+            toggle: typeof toggle;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluAccordion.vue.d.ts.map

package/dist/components/collapsible/UluAccordion.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluAccordion.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordion.vue"],"names":[],"mappings":"AA8BA;wBA0SqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;;;;;;;;;sPASG"}

package/dist/components/collapsible/UluAccordion.vue.js

@@ -0,0 +1,105 @@
+import { computed as u, createBlock as l, openBlock as s, withCtx as n, renderSlot as o, resolveDynamicComponent as g, createTextVNode as f, toDisplayString as p, createElementVNode as y, normalizeClass as x, createVNode as V } from "vue";
+import v from "../elements/UluIcon.vue.js";
+import O from "./UluCollapsible.vue.js";
+import { useModifiers as T } from "../../composables/useModifiers.js";
+const E = {
+  __name: "UluAccordion",
+  props: {
+    /**
+     * v-model for controlling open state  (optional)
+     */
+    modelValue: {
+      type: Boolean,
+      default: void 0
+    },
+    /**
+     * Whether the accordion is open by default
+     */
+    startOpen: Boolean,
+    /**
+     * Enable or configure animations.
+     * - `false` (default) to disable all animations.
+     * - `true` to enable animations with default settings.
+     * - An object to provide custom options to auto-animate (e.g., { duration: 100, easing: 'linear' }).
+     */
+    animate: {
+      type: [Boolean, Object],
+      default: !0
+    },
+    /**
+     * Text to use for accordion, alternatively use #trigger slot
+     */
+    triggerText: String,
+    /**
+     * If using summary text sets the inner element the text is wrapped in, usually a headline or strong
+     */
+    triggerTextElement: {
+      type: String,
+      default: "strong"
+    },
+    /**
+     * Classes for elements. See UluCollapsible for all available class keys (trigger, content, etc).
+     * The 'icon' key is also available for the icon span.
+     * - Any valid class binding value per element
+     */
+    classes: {
+      type: Object,
+      default: () => ({
+        container: "accordion",
+        trigger: "accordion__summary",
+        content: "accordion__content",
+        containerOpen: "is-active"
+      })
+    },
+    /**
+     * Class modifiers (ie. 'transparent', 'secondary', etc)
+     */
+    modifiers: [String, Array]
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: $ }) {
+    const r = e, { resolvedModifiers: c } = T({ props: r, baseClass: "accordion" }), d = u(() => {
+      const t = { ...r.classes };
+      return t.container = [t.container, c.value], t;
+    });
+    return (t, i) => (s(), l(O, {
+      "model-value": e.modelValue,
+      "start-open": e.startOpen,
+      "trigger-text": e.triggerText,
+      classes: d.value,
+      animate: e.animate,
+      "onUpdate:modelValue": i[0] || (i[0] = (a) => t.$emit("update:modelValue", a))
+    }, {
+      trigger: n(({ isOpen: a }) => [
+        o(t.$slots, "trigger", { isOpen: a }, () => [
+          (s(), l(g(e.triggerTextElement), null, {
+            default: n(() => [
+              f(p(e.triggerText), 1)
+            ]),
+            _: 1
+          }))
+        ]),
+        o(t.$slots, "icon", { isOpen: a }, () => [
+          y("span", {
+            class: x(["accordion__icon", e.classes.icon])
+          }, [
+            V(v, {
+              icon: a ? "type:collapse" : "type:expand",
+              style: { display: "inline" }
+            }, null, 8, ["icon"])
+          ], 2)
+        ])
+      ]),
+      default: n(({ isOpen: a, toggle: m }) => [
+        o(t.$slots, "default", {
+          isOpen: a,
+          toggle: m
+        })
+      ]),
+      _: 3
+    }, 8, ["model-value", "start-open", "trigger-text", "classes", "animate"]));
+  }
+};
+export {
+  E as default
+};

package/dist/components/collapsible/UluAccordionGroup.vue.d.ts

@@ -0,0 +1,41 @@
+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<{}, {
+    animate: boolean | Record<string, any>;
+    triggerTextElement: string;
+    items: unknown[];
+    modifiers?: string | unknown[] | undefined;
+    $props: {
+        readonly animate?: boolean | Record<string, any> | undefined;
+        readonly triggerTextElement?: string | undefined;
+        readonly items?: unknown[] | undefined;
+        readonly modifiers?: string | unknown[] | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            item: never;
+            index: number;
+            isOpen: boolean | undefined;
+        }): any;
+        icon?(_: {
+            item: never;
+            index: number;
+            isOpen: boolean | undefined;
+        }): any;
+        item?(_: {
+            item: never;
+            index: number;
+            isOpen: true;
+            toggle: typeof toggle;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluAccordionGroup.vue.d.ts.map

package/dist/components/collapsible/UluAccordionGroup.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluAccordionGroup.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordionGroup.vue"],"names":[],"mappings":"AA6BA;wBA8QqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;sPAQG"}

package/dist/components/collapsible/UluAccordionGroup.vue.js

@@ -0,0 +1,100 @@
+import { ref as f, watch as p, createElementBlock as g, openBlock as o, Fragment as y, renderList as O, createBlock as v, createSlots as h, withCtx as l, renderSlot as m, createTextVNode as k, toDisplayString as $ } from "vue";
+import S from "./UluAccordion.vue.js";
+const B = { class: "accordion-group" }, x = {
+  __name: "UluAccordionGroup",
+  props: {
+    /**
+     * Array of items to render as accordions.
+     * Each item can have: title, content, isOpen, classes
+     */
+    items: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * If using summary text sets the inner element the text is wrapped in, usually a headline or strong
+     */
+    triggerTextElement: {
+      type: String,
+      default: "strong"
+    },
+    /**
+     * Class modifiers (ie. 'transparent', 'secondary', etc)
+     */
+    modifiers: [String, Array],
+    /**
+     * Enable or configure animations.
+     * - `false` (default) to disable all animations.
+     * - `true` to enable animations with default settings.
+     * - An object to provide custom options to auto-animate (e.g., { duration: 100, easing: 'linear' }).
+     */
+    animate: {
+      type: [Boolean, Object],
+      default: !0
+    }
+  },
+  setup(i) {
+    const u = i, s = f([]);
+    p(() => u.items, (e) => {
+      s.value = e.map((a) => ({
+        ...a,
+        isOpen: a.isOpen || !1
+      }));
+    }, { immediate: !0, deep: !0 });
+    function c(e, a) {
+      a ? s.value.forEach((t, r) => {
+        t.isOpen = r === e;
+      }) : s.value[e].isOpen = !1;
+    }
+    return (e, a) => (o(), g("div", B, [
+      (o(!0), g(y, null, O(s.value, (t, r) => (o(), v(S, {
+        key: r,
+        "model-value": t.isOpen,
+        "onUpdate:modelValue": (n) => c(r, n),
+        "trigger-text": t.title,
+        classes: t.classes,
+        "trigger-text-element": i.triggerTextElement,
+        modifiers: i.modifiers,
+        animate: i.animate
+      }, h({
+        default: l(({ isOpen: n, toggle: d }) => [
+          m(e.$slots, "item", {
+            item: t,
+            index: r,
+            isOpen: n,
+            toggle: d
+          }, () => [
+            k($(t.content), 1)
+          ])
+        ]),
+        _: 2
+      }, [
+        e.$slots.trigger ? {
+          name: "trigger",
+          fn: l(({ isOpen: n }) => [
+            m(e.$slots, "trigger", {
+              item: t,
+              index: r,
+              isOpen: n
+            })
+          ]),
+          key: "0"
+        } : void 0,
+        e.$slots.icon ? {
+          name: "icon",
+          fn: l(({ isOpen: n }) => [
+            m(e.$slots, "icon", {
+              item: t,
+              index: r,
+              isOpen: n
+            })
+          ]),
+          key: "1"
+        } : void 0
+      ]), 1032, ["model-value", "onUpdate:modelValue", "trigger-text", "classes", "trigger-text-element", "modifiers", "animate"]))), 128))
+    ]));
+  }
+};
+export {
+  x as default
+};

package/dist/components/collapsible/UluCollapsible.vue.d.ts

@@ -0,0 +1,45 @@
+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<{}, {
+    $emit: (event: "update:modelValue", ...args: any[]) => void;
+    startOpen: boolean;
+    classes: Record<string, any>;
+    closeOnEscape: boolean;
+    animate: boolean | Record<string, any>;
+    triggerText?: string | undefined;
+    modelValue?: boolean | undefined;
+    $props: {
+        readonly startOpen?: boolean | undefined;
+        readonly classes?: Record<string, any> | undefined;
+        readonly closeOnEscape?: boolean | undefined;
+        readonly animate?: boolean | Record<string, any> | undefined;
+        readonly triggerText?: string | undefined;
+        readonly modelValue?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    container: HTMLDivElement;
+}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            isOpen: boolean | undefined;
+        }): any;
+        default?(_: {
+            isOpen: true;
+            toggle: typeof toggle;
+        }): any;
+    };
+    refs: {
+        container: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+/**
+ * Function used to toggle the collapsible
+ */
+declare function toggle(): void;
+//# sourceMappingURL=UluCollapsible.vue.d.ts.map

package/dist/components/collapsible/UluCollapsible.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluCollapsible.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluCollapsible.vue"],"names":[],"mappings":"AA6BA;wBA0TqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;mBAUG;;;;;;;;;;;;;;;;;AAlGD;;GAEG;AACH,gCAEC"}

package/dist/components/collapsible/UluCollapsible.vue.js

@@ -0,0 +1,108 @@
+import { computed as n, onMounted as V, watch as x, ref as o, createElementBlock as p, openBlock as g, normalizeClass as s, withKeys as B, createElementVNode as k, createCommentVNode as E, renderSlot as f, createTextVNode as A, toDisplayString as I } from "vue";
+import { useAutoAnimate as j } from "@formkit/auto-animate/vue";
+import { newId as v } from "../../utils/dom.js";
+const w = ["id", "aria-controls", "aria-expanded"], N = ["id", "aria-hidden", "aria-labelledby"], z = {
+  __name: "UluCollapsible",
+  props: {
+    /**
+     * v-model for controlling open state
+     */
+    modelValue: {
+      type: Boolean,
+      default: void 0
+    },
+    /**
+     * Set text for trigger (instead of using slot)
+     */
+    triggerText: String,
+    /**
+     * Closes with escape key
+     */
+    closeOnEscape: Boolean,
+    /**
+     * When the component is shown it should start visible or hidden
+     */
+    startOpen: Boolean,
+    /**
+     * Enable or configure animations.
+     * - `true` to enable animations with default settings (default)
+     * - `false` (disable)
+     * - An object to provide custom options to auto-animate (e.g., { duration: 100, easing: 'linear' }).
+     */
+    animate: {
+      type: [Boolean, Object],
+      default: !0
+    },
+    /**
+     * Classes for elements ({ container, trigger, content })
+     * - Any valid class binding value per element
+     */
+    classes: {
+      type: Object,
+      default: () => ({
+        container: "ulu-collapsible",
+        trigger: "ulu-collapsible__trigger",
+        content: "ulu-collapsible__content",
+        containerOpen: "ulu-collapsible--open",
+        containerClosed: "ulu-collapsible--closed"
+      })
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(a, { emit: b }) {
+    const t = a, O = b, y = n(() => typeof t.animate == "object" ? t.animate : {}), [h, i] = j(y);
+    V(() => {
+      i(!!t.animate);
+    }), x(() => t.animate, (l) => {
+      i(!!l);
+    });
+    const c = n(() => t.modelValue !== void 0), r = o(t.startOpen), e = n({
+      get() {
+        return c.value ? t.modelValue : r.value;
+      },
+      set(l) {
+        c.value ? O("update:modelValue", l) : r.value = l;
+      }
+    }), u = o(v("ulu-collapsible-trigger")), d = o(v("ulu-collapsible-content"));
+    function m() {
+      e.value = !e.value;
+    }
+    function C() {
+      t.closeOnEscape && e.value && (e.value = !1);
+    }
+    return (l, S) => (g(), p("div", {
+      ref_key: "container",
+      ref: h,
+      onKeydown: B(C, ["esc"]),
+      class: s([a.classes.container, e.value ? a.classes.containerOpen : a.classes.containerClosed])
+    }, [
+      k("button", {
+        class: s(a.classes.trigger),
+        id: u.value,
+        "aria-controls": d.value,
+        "aria-expanded": e.value,
+        onClick: m
+      }, [
+        f(l.$slots, "trigger", { isOpen: e.value }, () => [
+          A(I(a.triggerText), 1)
+        ])
+      ], 10, w),
+      e.value ? (g(), p("div", {
+        key: 0,
+        class: s(a.classes.content),
+        tabindex: "-1",
+        id: d.value,
+        "aria-hidden": !e.value,
+        "aria-labelledby": u.value
+      }, [
+        f(l.$slots, "default", {
+          isOpen: e.value,
+          toggle: m
+        })
+      ], 10, N)) : E("", !0)
+    ], 34));
+  }
+};
+export {
+  z as default
+};

package/dist/components/collapsible/UluDropdown.vue.d.ts

@@ -0,0 +1,26 @@
+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<{}, {
+    popoverClasses: Record<string, any>;
+    triggerText?: string | undefined;
+    items?: unknown[] | undefined;
+    $props: {
+        readonly popoverClasses?: Record<string, any> | undefined;
+        readonly triggerText?: string | undefined;
+        readonly items?: unknown[] | 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: {
+        trigger?(_: {
+            isOpen: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+//# sourceMappingURL=UluDropdown.vue.d.ts.map

package/dist/components/collapsible/UluDropdown.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluDropdown.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluDropdown.vue"],"names":[],"mappings":"AAiBA;wBAqKqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;2OAQG"}

package/dist/components/collapsible/UluDropdown.vue.js

@@ -0,0 +1,47 @@
+import { createBlock as n, openBlock as a, withCtx as r, createVNode as o, renderSlot as i, createElementVNode as l, toDisplayString as m, normalizeStyle as c } from "vue";
+import p from "../../plugins/popovers/UluPopover.vue.js";
+import g from "../navigation/UluMenuStack.vue.js";
+import f from "../elements/UluIcon.vue.js";
+const S = {
+  __name: "UluDropdown",
+  props: {
+    /**
+     * Dropdown menu items (to be passed to UluMenu)
+     */
+    items: Array,
+    /**
+     * Optional text if not using slot
+     */
+    triggerText: String,
+    /**
+     * Pass classes object to UluPopover classes prop
+     */
+    popoverClasses: {
+      type: Object,
+      default: () => ({
+        trigger: "button"
+      })
+    }
+  },
+  setup(t) {
+    return (s, d) => (a(), n(p, { classes: t.popoverClasses }, {
+      trigger: r(({ isOpen: e }) => [
+        i(s.$slots, "trigger", { isOpen: e }, () => [
+          l("span", null, m(t.triggerText), 1),
+          o(f, {
+            class: "button__icon",
+            icon: "type:dropdownExpand",
+            style: c({ transform: e ? "rotate(180deg)" : "rotate(0deg)", transition: "transform 0.2s" })
+          }, null, 8, ["style"])
+        ])
+      ]),
+      default: r(() => [
+        o(g, { items: t.items }, null, 8, ["items"])
+      ]),
+      _: 3
+    }, 8, ["classes"]));
+  }
+};
+export {
+  S as default
+};

package/dist/{types/components → components}/collapsible/UluModal.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<{
     /**
      * Controls the visibility of the modal (for v-model).
      */
@@ -101,9 +101,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     modifiers: (StringConstructor | ArrayConstructor)[];
 }>, {
     resolvedModifiers: any;
-    hasHeader: import("vue").ComputedRef<string | import("vue").Slot<any> | undefined>;
-    resizerEnabled: import("vue").ComputedRef<boolean | undefined>;
-    resizerIconType: import("vue").ComputedRef<"type:resizeBoth" | "type:resizeHorizontal">;
+    hasHeader: import('vue').ComputedRef<string | import('vue').Slot<any> | undefined>;
+    resizerEnabled: import('vue').ComputedRef<boolean | undefined>;
+    resizerIconType: import('vue').ComputedRef<"type:resizeBoth" | "type:resizeHorizontal">;
 }, {
     containerWidth: null;
     titleId: string;
@@ -121,7 +121,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     handleToggle(event: any): void;
     setupResizer(): void;
     destroyResizer(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "open" | "update:modelValue")[], "close" | "open" | "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close" | "open" | "update:modelValue")[], "close" | "open" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /**
      * Controls the visibility of the modal (for v-model).
      */
@@ -227,7 +227,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     onOpen?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }>, {
-    position: string;
     classes: Record<string, any>;
     clickOutsideCloses: boolean;
     modelValue: boolean;
@@ -239,15 +238,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     teleport: string | boolean | Record<string, any>;
     preventScroll: boolean;
     preventScrollShift: boolean;
+    position: string;
 }, {}, {
-    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=UluModal.vue.d.ts.map

package/dist/components/collapsible/UluModal.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluModal.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluModal.vue"],"names":[],"mappings":"AA+DA;;IA2YM;;OAEG;;IAEH;;;;OAIG;;;;;IAKH;;OAEG;;;;;IAKH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;IAlGH;;OAEG;;IAEH;;;;OAIG;;;;;IAKH;;OAEG;;;;;IAKH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;;;;IAKH;;OAEG"}