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

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

@@ -0,0 +1,46 @@
+import { createElementBlock as n, openBlock as r, createElementVNode as a, createVNode as l, renderSlot as i, createTextVNode as o, toDisplayString as c } from "vue";
+import s from "./UluIcon.vue.js";
+const f = ["href", "target"], m = { class: "external-link__text" }, _ = {
+  __name: "UluExternalLink",
+  props: {
+    /**
+     * Text for link or use slot
+     */
+    text: String,
+    /**
+     * Link href
+     */
+    href: String,
+    /**
+     * Link target
+     */
+    target: {
+      type: String,
+      default: "_blank"
+    },
+    /**
+     * Override default icon
+     */
+    icon: String
+  },
+  setup(e) {
+    return (t, x) => (r(), n("a", {
+      class: "external-link",
+      href: e.href,
+      target: e.target
+    }, [
+      a("span", m, [
+        i(t.$slots, "default", {}, () => [
+          o(c(e.text), 1)
+        ])
+      ]),
+      l(s, {
+        class: "external-link__icon margin-left-small-x display-inline",
+        icon: e.icon || "type:externalLink"
+      }, null, 8, ["icon"])
+    ], 8, f));
+  }
+};
+export {
+  _ as default
+};

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

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    spaced: boolean;
+    icon?: string | boolean | Record<string, any> | unknown[] | undefined;
+    $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>;
+export default _default;
+//# sourceMappingURL=UluIcon.vue.d.ts.map

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

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

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

@@ -0,0 +1,55 @@
+import { inject as S, ref as _, computed as e, watchEffect as h, defineAsyncComponent as A, markRaw as v, createBlock as p, createElementBlock as B, createCommentVNode as F, openBlock as i, resolveDynamicComponent as f, mergeProps as g, normalizeClass as D } from "vue";
+import { useIcon as R } from "../../composables/useIcon.js";
+const x = {
+  __name: "UluIcon",
+  props: {
+    /**
+     * Icon definition can be string (fa classes), or array or object (any prop format FaIcon accepts)
+     * - This will override the 'type' prop if both are provided
+     */
+    icon: [String, Array, Object, Boolean],
+    /**
+     * Whether the icon should use flow inline
+     */
+    spaced: Boolean
+  },
+  setup(y) {
+    const s = S("uluCore"), l = _(null), { getIconProps: C, getClassesFromDefinition: d } = R();
+    let a;
+    const m = y, c = e(() => s.getSetting("fontAwesomeStatic")), r = e(() => s.getSetting("iconComponent")), I = e(() => s.getSetting("iconPropResolver")), n = e(() => {
+      const { icon: o } = m;
+      if (typeof o == "string" && o.startsWith("type:"))
+        try {
+          const t = o.substring(5);
+          return s.getIcon(t);
+        } catch (t) {
+          return console.warn(t), null;
+        }
+      return o;
+    }), w = e(() => !r.value || !n.value ? null : I.value(n.value)), k = e(() => C(n.value)), P = e(() => d(n.value)), u = e(() => ({
+      "flow-inline": m.spaced
+    }));
+    return h(async () => {
+      if (!c.value && n.value) {
+        if (l.value === null)
+          if (a)
+            l.value = v(a.FontAwesomeIcon);
+          else {
+            const o = A(async () => {
+              const t = await import("@fortawesome/vue-fontawesome");
+              return a = t, t.FontAwesomeIcon;
+            });
+            l.value = v(o);
+          }
+      } else
+        l.value = null;
+    }), (o, t) => r.value ? (i(), p(f(r.value), g({ key: 0 }, w.value, { class: u.value }), null, 16, ["class"])) : !c.value && l.value && n.value ? (i(), p(f(l.value), g({ key: 1 }, k.value, { class: u.value }), null, 16, ["class"])) : c.value && n.value ? (i(), B("span", {
+      key: 2,
+      class: D([P.value, u.value]),
+      "aria-hidden": "true"
+    }, null, 2)) : F("", !0);
+  }
+};
+export {
+  x as default
+};

package/dist/components/elements/UluList.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<{}, {
+    classes: Record<string, any>;
+    compact: boolean;
+    ordered: boolean;
+    unordered: boolean;
+    lines: boolean;
+    forceOrdered: boolean;
+    reversed: boolean;
+    start?: string | undefined;
+    items?: unknown[] | undefined;
+    listStyleType?: string | undefined;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly compact?: boolean | undefined;
+        readonly ordered?: boolean | undefined;
+        readonly unordered?: boolean | undefined;
+        readonly lines?: boolean | undefined;
+        readonly forceOrdered?: boolean | undefined;
+        readonly reversed?: boolean | undefined;
+        readonly start?: string | undefined;
+        readonly items?: unknown[] | undefined;
+        readonly listStyleType?: 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?(_: {
+            item: unknown;
+            index: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+//# sourceMappingURL=UluList.vue.d.ts.map

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

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

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

@@ -0,0 +1,88 @@
+import { computed as o, createBlock as u, openBlock as t, resolveDynamicComponent as m, normalizeStyle as y, normalizeClass as n, withCtx as B, createElementBlock as d, Fragment as f, renderList as v, renderSlot as S, createTextVNode as g, toDisplayString as k } from "vue";
+const x = {
+  __name: "UluList",
+  props: {
+    /**
+     * Array of list items, output as is or use slot to template the item
+     */
+    items: Array,
+    /**
+     * Classes object (keys are list and listItem to be applied to <ul> and <li>)
+     * - Any valid class binding for each
+     */
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Use list-ordered class, and sets element to <ol>
+     */
+    ordered: Boolean,
+    /**
+     * Use list-unordered class
+     */
+    unordered: Boolean,
+    /**
+     * Use list-lines class
+     */
+    lines: Boolean,
+    /**
+     * Use list-compact class
+     */
+    compact: Boolean,
+    /**
+     * If setting up custom ordered list this will ensure the correct element type
+     * - Note: 'ordered' prop sets the ordered list class, this does not
+     */
+    forceOrdered: Boolean,
+    /**
+     * Define the start value for <ol>
+     */
+    start: String,
+    /**
+     * Reverse ordered list
+     */
+    reversed: Boolean,
+    /**
+     * Define list style type (ie. disc, decimal, etc)
+     */
+    listStyleType: String
+  },
+  setup(e) {
+    const l = e, r = o(() => l.ordered || l.forceOrdered), c = o(() => r.value ? "ol" : "ul");
+    return (i, O) => (t(), u(m(c.value), {
+      class: n([
+        {
+          "list-ordered": e.ordered,
+          "list-unordered": e.unordered,
+          "list-lines": e.lines,
+          "list-compact": e.compact
+        },
+        e.classes.list
+      ]),
+      style: y({
+        listStyleType: e.listStyleType
+      }),
+      reversed: r.value ? e.reversed : null,
+      start: e.start
+    }, {
+      default: B(() => [
+        (t(!0), d(f, null, v(e.items, (s, a) => (t(), d("li", {
+          key: a,
+          class: n(e.classes.listItem)
+        }, [
+          S(i.$slots, "default", {
+            item: s,
+            index: a
+          }, () => [
+            g(k(s), 1)
+          ])
+        ], 2))), 128))
+      ]),
+      _: 3
+    }, 8, ["class", "style", "reversed", "start"]));
+  }
+};
+export {
+  x as default
+};

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

@@ -0,0 +1,18 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=UluMain.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UluMain.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluMain.vue"],"names":[],"mappings":"AAQA,iBAAS,cAAc;WAuBT,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AAOD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,uRAMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAEpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

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

@@ -0,0 +1,12 @@
+import { createElementBlock as t, openBlock as n, renderSlot as o } from "vue";
+import r from "../../_virtual/_plugin-vue_export-helper.js";
+const c = {}, s = { id: "main-content" };
+function a(e, i) {
+  return n(), t("main", s, [
+    o(e.$slots, "default")
+  ]);
+}
+const l = /* @__PURE__ */ r(c, [["render", a]]);
+export {
+  l as default
+};

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

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

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

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

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

@@ -0,0 +1,53 @@
+import { computed as i, createElementBlock as o, openBlock as n, normalizeClass as a, unref as s } from "vue";
+import { useModifiers as c } from "../../composables/useModifiers.js";
+const d = {
+  __name: "UluRule",
+  props: {
+    /**
+     * Whether to use the actual <hr> vs superficial <div></div> for rule element
+     */
+    semantic: Boolean,
+    /**
+     * Use short modifier
+     */
+    short: Boolean,
+    /**
+     * Optional margin (keyword from your rule margins config in frontend)
+     */
+    margin: String,
+    /**
+     * Add light modifier (if set, usually exists, this is for convenience, use modifiers prop if you have custom naming)
+     */
+    light: Boolean,
+    /**
+     * Add large modifier (if set, usually exists, this is for convenience, use modifiers prop if you have custom naming)
+     */
+    large: Boolean,
+    /**
+     * Modifiers (to add any modifier classes based on base class [ie. 'tertiary'])
+     */
+    modifiers: [String, Array]
+  },
+  setup(r) {
+    const e = r, t = i(() => ({
+      short: e.short,
+      light: e.light,
+      large: e.large,
+      [`margin-${e.margin}`]: e.margin
+    })), { resolvedModifiers: l } = c({
+      props: e,
+      baseClass: "rule",
+      internal: t
+    });
+    return (m, u) => r.semantic ? (n(), o("hr", {
+      key: 0,
+      class: a(["rule", s(l)])
+    }, null, 2)) : (n(), o("div", {
+      key: 1,
+      class: a(["rule", s(l)])
+    }, null, 2));
+  }
+};
+export {
+  d as default
+};

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

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    type?: string | undefined;
+    $props: {
+        readonly type?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=UluSpokeSpinner.vue.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+import { createElementBlock as n, openBlock as r, normalizeClass as p, createElementVNode as t, Fragment as o, renderList as i } from "vue";
+const a = { class: "spoke-spinner__spinner" }, _ = {
+  __name: "UluSpokeSpinner",
+  props: {
+    /**
+     * Type modifier for spinner (ie match scss style name)
+     */
+    type: String
+  },
+  setup(e) {
+    return (c, l) => (r(), n("div", {
+      class: p(["spoke-spinner", { [`spoke-spinner--${e.type}`]: e.type }])
+    }, [
+      t("div", a, [
+        (r(), n(o, null, i(12, (s) => t("div", { key: s })), 64))
+      ])
+    ], 2));
+  }
+};
+export {
+  _ as default
+};

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

@@ -0,0 +1,30 @@
+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<{}, {
+    counter: boolean;
+    type?: string | 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;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLSpanElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+//# sourceMappingURL=UluTag.vue.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+import { createElementBlock as o, openBlock as t, normalizeClass as i, unref as c, createBlock as s, createCommentVNode as l, renderSlot as m, createElementVNode as u, toDisplayString as g } from "vue";
+import f from "./UluIcon.vue.js";
+import { useModifiers as d } from "../../composables/useModifiers.js";
+const B = {
+  __name: "UluTag",
+  props: {
+    /**
+     * Type (corresponds with styles setup for tag in scss module)
+     */
+    type: [String],
+    /**
+     * Size (corresponds with sizes setup for tag in scss module)
+     */
+    size: String,
+    /**
+     * Use counter style (for numbers, etc)
+     */
+    counter: Boolean,
+    /**
+     * Text for tag, or use slot
+     */
+    text: [String, Number],
+    /**
+     * Icon prop, if used will set the icon for the button, will use UluIcon (which uses font-awesome icons conditionally)
+     * - If using custom icons use slot instead
+     */
+    icon: [String, Array],
+    /**
+     * Modifiers for tag class
+     */
+    modifiers: [String, Array]
+  },
+  setup(e) {
+    const n = e, { resolvedModifiers: r } = d({ props: n, baseClass: "tag" });
+    return (a, y) => (t(), o("span", {
+      class: i(["tag", [
+        {
+          "tag--counter": e.counter,
+          [`tag--${e.size}`]: e.size,
+          [`tag--${e.type}`]: e.type
+        },
+        c(r)
+      ]])
+    }, [
+      e.icon ? (t(), s(f, {
+        key: 0,
+        icon: e.icon,
+        spaced: ""
+      }, null, 8, ["icon"])) : l("", !0),
+      m(a.$slots, "default", {}, () => [
+        u("span", null, g(e.text), 1)
+      ])
+    ], 2));
+  }
+};
+export {
+  B as default
+};

package/dist/components/forms/UluFileDisplay.vue.d.ts

@@ -0,0 +1,27 @@
+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<{}, {
+    icon: string;
+    file: Record<string, any>;
+    noFileSize: boolean;
+    $props: {
+        readonly icon?: string | undefined;
+        readonly file?: Record<string, any> | undefined;
+        readonly noFileSize?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLAnchorElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            fileName: any;
+            fileSize: string;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLAnchorElement;
+};
+//# sourceMappingURL=UluFileDisplay.vue.d.ts.map

package/dist/components/forms/UluFileDisplay.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluFileDisplay.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/forms/UluFileDisplay.vue"],"names":[],"mappings":"AAWA;wBA8LqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;yPAQG"}

package/dist/components/forms/UluFileDisplay.vue.js

@@ -0,0 +1,59 @@
+import { computed as c, createElementBlock as m, openBlock as r, renderSlot as u, createVNode as d, createElementVNode as p, createTextVNode as y, createBlock as b, createCommentVNode as x, toDisplayString as S } from "vue";
+import w from "../elements/UluIcon.vue.js";
+import $ from "../elements/UluTag.vue.js";
+const h = ["href", "download"], z = { class: "margin-left-small-x" }, k = {
+  __name: "UluFileDisplay",
+  props: {
+    /**
+     * The File object to be displayed.
+     */
+    file: {
+      required: !0,
+      type: Object
+    },
+    /**
+     * The icon to display next to the file name.
+     */
+    icon: {
+      type: String,
+      default: "type:file"
+    },
+    /**
+     * If true, the file size will not be displayed.
+     */
+    noFileSize: Boolean
+  },
+  setup(e) {
+    const n = e, s = c(() => typeof window > "u" ? "" : window.URL.createObjectURL(n.file)), i = c(() => {
+      const { size: t } = n.file, l = t / 1e6, a = t / 1e3, o = (f) => parseFloat(f.toFixed(2));
+      return l > 1 ? `${o(l)}Mb` : a > 1 ? `${o(a)}Kb` : `${o(t)}B`;
+    });
+    return (t, l) => (r(), m("a", {
+      class: "layout-flex-baseline",
+      href: s.value,
+      download: e.file.name
+    }, [
+      u(t.$slots, "default", {
+        fileName: e.file.name,
+        fileSize: i.value
+      }, () => [
+        d(w, {
+          class: "ui-icon",
+          icon: e.icon
+        }, null, 8, ["icon"]),
+        p("span", z, [
+          y(S(e.file.name) + " ", 1),
+          e.noFileSize ? x("", !0) : (r(), b($, {
+            key: 0,
+            text: i.value,
+            small: "",
+            outline: ""
+          }, null, 8, ["text"]))
+        ])
+      ])
+    ], 8, h));
+  }
+};
+export {
+  k as default
+};

package/dist/components/forms/UluForm.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<{}, {
+    element: string;
+    fullWidth: boolean;
+    fullWidthSelect: boolean;
+    hideLabels: boolean;
+    actionsRight: boolean;
+    $props: {
+        readonly element?: string | undefined;
+        readonly fullWidth?: boolean | undefined;
+        readonly fullWidthSelect?: boolean | undefined;
+        readonly hideLabels?: boolean | undefined;
+        readonly actionsRight?: boolean | 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=UluForm.vue.d.ts.map

package/dist/components/forms/UluForm.vue.d.ts.map

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

package/dist/components/forms/UluForm.vue.js

@@ -0,0 +1,47 @@
+import { createBlock as l, openBlock as o, resolveDynamicComponent as a, normalizeClass as i, withCtx as m, renderSlot as n } from "vue";
+const r = {
+  __name: "UluForm",
+  props: {
+    /**
+     * The HTML element to use for the form.
+     */
+    element: {
+      type: String,
+      default: "form"
+    },
+    /**
+     * If true, applies the full-width styles to text inputs.
+     */
+    fullWidth: Boolean,
+    /**
+     * If true, applies the full-width styles to select inputs.
+     */
+    fullWidthSelect: Boolean,
+    /**
+     * If true, hides all labels in the form.
+     */
+    hideLabels: Boolean,
+    /**
+     * If true, right-aligns the form actions.
+     */
+    actionsRight: Boolean
+  },
+  setup(e) {
+    return (t, h) => (o(), l(a(e.element), {
+      class: i(["form-theme", [{
+        "form-theme--full-width": e.fullWidth,
+        "form-theme--full-width-select": e.fullWidthSelect,
+        "form-theme--hide-labels": e.hideLabels,
+        "form-theme--actions-right": e.actionsRight
+      }]])
+    }, {
+      default: m(() => [
+        n(t.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["class"]));
+  }
+};
+export {
+  r as default
+};