@ulu/frontend-vue 0.5.1 → 0.5.3

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

@@ -1 +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"}
+{"version":3,"file":"UluAccordion.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordion.vue"],"names":[],"mappings":"AA+BA;wBA8VqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;;;;;;;;;sPASG"}

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

@@ -1,8 +1,9 @@
-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 = {
+import { computed as c, inject as x, onMounted as V, createBlock as s, openBlock as d, unref as O, withCtx as i, renderSlot as l, resolveDynamicComponent as T, createTextVNode as B, toDisplayString as C, createElementVNode as M, normalizeClass as S, createVNode as $ } from "vue";
+import A from "../elements/UluIcon.vue.js";
+import b from "./UluCollapsible.vue.js";
+import { useModifiers as h } from "../../composables/useModifiers.js";
+import { newId as j } from "../../utils/dom.js";
+const G = {
   __name: "UluAccordion",
   props: {
     /**
@@ -57,49 +58,57 @@ const E = {
     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;
+  setup(t, { emit: u }) {
+    const r = t, m = u, { resolvedModifiers: g } = h({ props: r, baseClass: "accordion" }), p = c(() => {
+      const e = { ...r.classes };
+      return e.container = [e.container, g.value], e;
+    }), o = x("uluAccordionGroup", null), a = j("ulu-accordion");
+    V(() => {
+      o && r.startOpen && o.toggle(a, !0);
     });
-    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))
+    const f = c(() => o ? o.activeAccordionId.value === a : r.modelValue);
+    function y(e) {
+      o && o.toggle(a, e), m("update:modelValue", e);
+    }
+    return (e, E) => (d(), s(b, {
+      id: O(a),
+      "model-value": f.value,
+      "start-open": t.startOpen,
+      "trigger-text": t.triggerText,
+      classes: p.value,
+      animate: t.animate,
+      "onUpdate:modelValue": y
     }, {
-      trigger: n(({ isOpen: a }) => [
-        o(t.$slots, "trigger", { isOpen: a }, () => [
-          (s(), l(g(e.triggerTextElement), null, {
-            default: n(() => [
-              f(p(e.triggerText), 1)
+      trigger: i(({ isOpen: n }) => [
+        l(e.$slots, "trigger", { isOpen: n }, () => [
+          (d(), s(T(t.triggerTextElement), null, {
+            default: i(() => [
+              B(C(t.triggerText), 1)
             ]),
             _: 1
           }))
         ]),
-        o(t.$slots, "icon", { isOpen: a }, () => [
-          y("span", {
-            class: x(["accordion__icon", e.classes.icon])
+        l(e.$slots, "icon", { isOpen: n }, () => [
+          M("span", {
+            class: S(["accordion__icon", t.classes.icon])
           }, [
-            V(v, {
-              icon: a ? "type:collapse" : "type:expand",
+            $(A, {
+              icon: n ? "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
+      default: i(({ isOpen: n, toggle: v }) => [
+        l(e.$slots, "default", {
+          isOpen: n,
+          toggle: v
         })
       ]),
       _: 3
-    }, 8, ["model-value", "start-open", "trigger-text", "classes", "animate"]));
+    }, 8, ["id", "model-value", "start-open", "trigger-text", "classes", "animate"]));
   }
 };
 export {
-  E as default
+  G as default
 };

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

@@ -14,28 +14,29 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
         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, {}, any>;
+}, {}, {}, {}, 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;
+            item: unknown;
             index: number;
             isOpen: boolean | undefined;
         }): any;
         icon?(_: {
-            item: never;
+            item: unknown;
             index: number;
             isOpen: boolean | undefined;
         }): any;
         item?(_: {
-            item: never;
+            item: unknown;
             index: number;
             isOpen: true;
             toggle: typeof toggle;
         }): any;
+        default?(_: {}): any;
     };
     refs: {};
-    rootEl: any;
+    rootEl: HTMLDivElement;
 };
 //# sourceMappingURL=UluAccordionGroup.vue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"UluAccordionGroup.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordionGroup.vue"],"names":[],"mappings":"AAgCA;wBAkRqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;2OAOG"}
+{"version":3,"file":"UluAccordionGroup.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordionGroup.vue"],"names":[],"mappings":"AA+BA;wBAgQqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;sPAQG"}

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

@@ -1,9 +1,6 @@
-import { ref as f, watch as p, createElementBlock as g, createCommentVNode as y, openBlock as s, Fragment as O, renderList as h, createBlock as k, createSlots as v, withCtx as l, renderSlot as m, createTextVNode as $, toDisplayString as S } from "vue";
-import B from "./UluAccordion.vue.js";
-const E = {
-  key: 0,
-  class: "accordion-group"
-}, x = {
+import { ref as m, provide as f, createElementBlock as c, openBlock as l, renderSlot as s, Fragment as p, renderList as y, createBlock as k, createSlots as $, withCtx as a, createTextVNode as v, toDisplayString as A } from "vue";
+import O from "./UluAccordion.vue.js";
+const S = { class: "accordion-group" }, B = {
   __name: "UluAccordionGroup",
   props: {
     /**
@@ -36,48 +33,42 @@ const E = {
       default: !0
     }
   },
-  setup(a) {
-    const u = a, o = f([]);
-    p(() => u.items, (e) => {
-      o.value = e.map((i) => ({
-        ...i,
-        isOpen: i.isOpen || !1
-      }));
-    }, { immediate: !0, deep: !0 });
-    function c(e, i) {
-      i ? o.value.forEach((t, r) => {
-        t.isOpen = r === e;
-      }) : o.value[e].isOpen = !1;
+  setup(r) {
+    const i = m(null);
+    function u(e, g) {
+      g ? i.value = e : i.value === e && (i.value = null);
     }
-    return (e, i) => a.items?.length ? (s(), g("div", E, [
-      (s(!0), g(O, null, h(o.value, (t, r) => (s(), k(B, {
-        key: r,
-        "model-value": t.isOpen,
-        "onUpdate:modelValue": (n) => c(r, n),
+    return f("uluAccordionGroup", {
+      activeAccordionId: i,
+      toggle: u
+    }), (e, g) => (l(), c("div", S, [
+      r.items?.length ? (l(!0), c(p, { key: 0 }, y(r.items, (t, o) => (l(), k(O, {
+        key: o,
+        "start-open": t.isOpen,
         "trigger-text": t.title,
         classes: t.classes,
-        "trigger-text-element": a.triggerTextElement,
-        modifiers: a.modifiers,
-        animate: a.animate
-      }, v({
-        default: l(({ isOpen: n, toggle: d }) => [
-          m(e.$slots, "item", {
+        "trigger-text-element": r.triggerTextElement,
+        modifiers: r.modifiers,
+        animate: r.animate
+      }, $({
+        default: a(({ isOpen: n, toggle: d }) => [
+          s(e.$slots, "item", {
             item: t,
-            index: r,
+            index: o,
             isOpen: n,
             toggle: d
           }, () => [
-            $(S(t.content), 1)
+            v(A(t.content), 1)
           ])
         ]),
         _: 2
       }, [
         e.$slots.trigger ? {
           name: "trigger",
-          fn: l(({ isOpen: n }) => [
-            m(e.$slots, "trigger", {
+          fn: a(({ isOpen: n }) => [
+            s(e.$slots, "trigger", {
               item: t,
-              index: r,
+              index: o,
               isOpen: n
             })
           ]),
@@ -85,19 +76,19 @@ const E = {
         } : void 0,
         e.$slots.icon ? {
           name: "icon",
-          fn: l(({ isOpen: n }) => [
-            m(e.$slots, "icon", {
+          fn: a(({ isOpen: n }) => [
+            s(e.$slots, "icon", {
               item: t,
-              index: r,
+              index: o,
               isOpen: n
             })
           ]),
           key: "1"
         } : void 0
-      ]), 1032, ["model-value", "onUpdate:modelValue", "trigger-text", "classes", "trigger-text-element", "modifiers", "animate"]))), 128))
-    ])) : y("", !0);
+      ]), 1032, ["start-open", "trigger-text", "classes", "trigger-text-element", "modifiers", "animate"]))), 128)) : s(e.$slots, "default", { key: 1 })
+    ]));
   }
 };
 export {
-  x as default
+  B as default
 };

package/dist/components/elements/UluDefinitionList.vue.d.ts

@@ -40,6 +40,7 @@ type __VLS_TemplateResult = {
             index: number;
             descriptionIndex: number;
         }): any;
+        default?(_: {}): any;
     };
     refs: {};
     rootEl: any;

package/dist/components/elements/UluDefinitionList.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluDefinitionList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluDefinitionList.vue"],"names":[],"mappings":"AAmCA;wBAyQqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;;;;;;;;;;;;;2OAOG"}
+{"version":3,"file":"UluDefinitionList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluDefinitionList.vue"],"names":[],"mappings":"AAsCA;wBAuRqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;;;;;;;;;;;;;2OAOG"}

package/dist/components/elements/UluDefinitionList.vue.js

@@ -1,6 +1,6 @@
-import { computed as b, createElementBlock as r, createCommentVNode as g, openBlock as a, normalizeClass as n, unref as k, Fragment as d, renderList as m, createElementVNode as L, renderSlot as p, createTextVNode as u, toDisplayString as f } from "vue";
-import { useModifiers as C } from "../../composables/useModifiers.js";
-const N = {
+import { provide as b, computed as m, createElementBlock as i, createCommentVNode as g, openBlock as a, normalizeClass as r, unref as L, renderSlot as o, Fragment as u, renderList as f, createElementVNode as C, createTextVNode as p, toDisplayString as y } from "vue";
+import { useModifiers as D } from "../../composables/useModifiers.js";
+const M = {
   __name: "UluDefinitionList",
   props: {
     /**
@@ -48,55 +48,57 @@ const N = {
      */
     compact: Boolean
   },
-  setup(t) {
-    const e = t, y = b(() => ({
-      inline: e.inline,
-      "inline-all": e.inlineAll,
-      table: e.table,
-      separated: e.separated,
-      "separated-first": e.separatedFirst,
-      "separated-last": e.separatedLast,
-      compact: e.compact
-    })), { resolvedModifiers: B } = C({
-      props: e,
-      internal: y,
+  setup(e) {
+    const t = e;
+    b("uluDefinitionListClasses", m(() => t.classes));
+    const B = m(() => ({
+      inline: t.inline,
+      "inline-all": t.inlineAll,
+      table: t.table,
+      separated: t.separated,
+      "separated-first": t.separatedFirst,
+      "separated-last": t.separatedLast,
+      compact: t.compact
+    })), { resolvedModifiers: k } = D({
+      props: t,
+      internal: B,
       baseClass: "definition-list"
     }), A = (s) => Array.isArray(s.description) ? s.description : [s.description];
-    return (s, D) => t.items?.length ? (a(), r("dl", {
+    return (s, $) => (e.items !== void 0 ? e.items.length : s.$slots.default) ? (a(), i("dl", {
       key: 0,
-      class: n(["definition-list", [k(B), t.classes.list]])
+      class: r(["definition-list", [L(k), e.classes.list]])
     }, [
-      (a(!0), r(d, null, m(t.items, (i, l) => (a(), r("div", {
+      e.items !== void 0 ? (a(!0), i(u, { key: 0 }, f(e.items, (n, l) => (a(), i("div", {
         key: l,
-        class: n(t.classes.item)
+        class: r(e.classes.item)
       }, [
-        L("dt", {
-          class: n(t.classes.term)
+        C("dt", {
+          class: r(e.classes.term)
         }, [
-          p(s.$slots, "term", {
-            item: i,
+          o(s.$slots, "term", {
+            item: n,
             index: l
           }, () => [
-            u(f(i.term), 1)
+            p(y(n.term), 1)
           ])
         ], 2),
-        (a(!0), r(d, null, m(A(i), (o, c) => (a(), r("dd", {
+        (a(!0), i(u, null, f(A(n), (d, c) => (a(), i("dd", {
           key: c,
-          class: n(t.classes.description)
+          class: r(e.classes.description)
         }, [
-          p(s.$slots, "description", {
-            item: i,
-            description: o,
+          o(s.$slots, "description", {
+            item: n,
+            description: d,
             index: l,
             descriptionIndex: c
           }, () => [
-            u(f(o), 1)
+            p(y(d), 1)
           ])
         ], 2))), 128))
-      ], 2))), 128))
+      ], 2))), 128)) : o(s.$slots, "default", { key: 1 })
     ], 2)) : g("", !0);
   }
 };
 export {
-  N as default
+  M as default
 };

package/dist/components/elements/UluDefinitionListItem.vue.d.ts

@@ -0,0 +1,28 @@
+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<{}, {
+    classes?: Record<string, any> | undefined;
+    description?: string | unknown[] | undefined;
+    term?: string | undefined;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly description?: string | unknown[] | undefined;
+        readonly term?: string | 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: {
+        term?(_: {}): any;
+        description?(_: {
+            description: unknown;
+            index: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluDefinitionListItem.vue.d.ts.map

package/dist/components/elements/UluDefinitionListItem.vue.d.ts.map

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

package/dist/components/elements/UluDefinitionListItem.vue.js

@@ -0,0 +1,46 @@
+import { inject as f, computed as o, createElementBlock as r, openBlock as i, normalizeClass as n, createElementVNode as y, renderSlot as d, createTextVNode as u, toDisplayString as m, Fragment as g, renderList as C } from "vue";
+const k = {
+  __name: "UluDefinitionListItem",
+  props: {
+    /**
+     * The term text (renders inside dt)
+     */
+    term: String,
+    /**
+     * The description text or array of strings (renders inside dd)
+     */
+    description: [String, Array],
+    /**
+     * Optional classes object to override/append to injected parent classes { item, term, description }
+     */
+    classes: Object
+  },
+  setup(e) {
+    const t = e, p = f("uluDefinitionListClasses", { value: {} }), s = o(() => p.value || {}), v = o(() => t.description ? Array.isArray(t.description) ? t.description : [t.description] : []);
+    return (c, S) => (i(), r("div", {
+      class: n([s.value.item, e.classes?.item])
+    }, [
+      y("dt", {
+        class: n([s.value.term, e.classes?.term])
+      }, [
+        d(c.$slots, "term", {}, () => [
+          u(m(e.term), 1)
+        ])
+      ], 2),
+      (i(!0), r(g, null, C(v.value, (l, a) => (i(), r("dd", {
+        key: a,
+        class: n([s.value.description, e.classes?.description])
+      }, [
+        d(c.$slots, "description", {
+          description: l,
+          index: a
+        }, () => [
+          u(m(l), 1)
+        ])
+      ], 2))), 128))
+    ], 2));
+  }
+};
+export {
+  k as default
+};

package/dist/components/elements/UluList.vue.d.ts

@@ -34,6 +34,7 @@ type __VLS_TemplateResult = {
             item: unknown;
             index: number;
         }): any;
+        default?(_: {}): any;
     };
     refs: {};
     rootEl: any;

package/dist/components/elements/UluList.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluList.vue"],"names":[],"mappings":"AAiCA;wBAmPqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;;;;;;;;;;;;;2OAOG"}
+{"version":3,"file":"UluList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluList.vue"],"names":[],"mappings":"AAoCA;wBAiQqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;;;;;;;;;;;;;2OAOG"}

package/dist/components/elements/UluList.vue.js

@@ -1,5 +1,5 @@
-import { computed as n, createBlock as m, createCommentVNode as u, openBlock as l, resolveDynamicComponent as y, normalizeStyle as B, normalizeClass as o, withCtx as f, createElementBlock as d, Fragment as v, renderList as S, renderSlot as g, createTextVNode as k, toDisplayString as C } from "vue";
-const h = {
+import { provide as m, computed as r, createBlock as y, createCommentVNode as f, openBlock as a, resolveDynamicComponent as v, normalizeStyle as B, normalizeClass as o, withCtx as S, createElementBlock as i, renderSlot as c, Fragment as k, renderList as g, createTextVNode as C, toDisplayString as O } from "vue";
+const L = {
   __name: "UluList",
   props: {
     /**
@@ -50,8 +50,10 @@ const h = {
     listStyleType: String
   },
   setup(e) {
-    const r = e, s = n(() => r.ordered || r.forceOrdered), c = n(() => s.value ? "ol" : "ul");
-    return (i, O) => e.items?.length ? (l(), m(y(c.value), {
+    const t = e;
+    m("uluListClasses", r(() => t.classes));
+    const n = r(() => t.ordered || t.forceOrdered), u = r(() => n.value ? "ol" : "ul");
+    return (l, T) => (e.items !== void 0 ? e.items.length : l.$slots.default) ? (a(), y(v(u.value), {
       key: 0,
       class: o([
         {
@@ -65,29 +67,29 @@ const h = {
       style: B({
         listStyleType: e.listStyleType
       }),
-      reversed: s.value ? e.reversed : null,
+      reversed: n.value ? e.reversed : null,
       start: e.start
     }, {
-      default: f(() => [
-        (l(!0), d(v, null, S(e.items, (t, a) => (l(), d("li", {
-          key: a,
+      default: S(() => [
+        e.items !== void 0 ? (a(!0), i(k, { key: 0 }, g(e.items, (s, d) => (a(), i("li", {
+          key: d,
           class: o([
             e.classes.item,
-            t?.classes?.item
+            s?.classes?.item
           ])
         }, [
-          g(i.$slots, "default", {
-            item: t,
-            index: a
+          c(l.$slots, "default", {
+            item: s,
+            index: d
           }, () => [
-            k(C(t), 1)
+            C(O(s), 1)
           ])
-        ], 2))), 128))
+        ], 2))), 128)) : c(l.$slots, "default", { key: 1 })
       ]),
       _: 3
-    }, 8, ["class", "style", "reversed", "start"])) : u("", !0);
+    }, 8, ["class", "style", "reversed", "start"])) : f("", !0);
   }
 };
 export {
-  h as default
+  L as default
 };

package/dist/components/elements/UluListItem.vue.d.ts

@@ -0,0 +1,20 @@
+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<{}, {
+    classes?: string | Record<string, any> | unknown[] | undefined;
+    $props: {
+        readonly classes?: string | Record<string, any> | unknown[] | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLLIElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+//# sourceMappingURL=UluListItem.vue.d.ts.map

package/dist/components/elements/UluListItem.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluListItem.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluListItem.vue"],"names":[],"mappings":"AAKA;wBAkFqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;qPAQG"}

package/dist/components/elements/UluListItem.vue.js

@@ -0,0 +1,21 @@
+import { inject as a, computed as c, createElementBlock as r, openBlock as n, normalizeClass as o, renderSlot as u } from "vue";
+const p = {
+  __name: "UluListItem",
+  props: {
+    /**
+     * Optional class binding to append to the injected parent classes
+     */
+    classes: [String, Array, Object]
+  },
+  setup(e) {
+    const s = a("uluListClasses", { value: {} }), t = c(() => s.value || {});
+    return (l, i) => (n(), r("li", {
+      class: o([t.value.item, e.classes])
+    }, [
+      u(l.$slots, "default")
+    ], 2));
+  }
+};
+export {
+  p as default
+};

package/dist/components/index.d.ts

@@ -18,10 +18,12 @@ export { default as UluCallout } from './elements/UluCallout.vue';
 export { default as UluCaptionedFigure } from './elements/UluCaptionedFigure.vue';
 export { default as UluCard } from './elements/UluCard.vue';
 export { default as UluDefinitionList } from './elements/UluDefinitionList.vue';
+export { default as UluDefinitionListItem } from './elements/UluDefinitionListItem.vue';
 export { default as UluExternalLink } from './elements/UluExternalLink.vue';
 export { default as UluIcon } from './elements/UluIcon.vue';
 export { default as UluImage } from './elements/UluImage.vue';
 export { default as UluList } from './elements/UluList.vue';
+export { default as UluListItem } from './elements/UluListItem.vue';
 export { default as UluMain } from './elements/UluMain.vue';
 export { default as UluOverflowScroller } from './elements/UluOverflowScroller.vue';
 export { default as UluRule } from './elements/UluRule.vue';