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

package/dist/{types/components → components}/utils/UluRouteAnnouncer.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<{
     /**
      * Allow user to bypass this functionality
      * - Function should return true if the page should be announced
@@ -27,7 +27,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>, {}, {}, {
     title(): any;
-}, {}, 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<{
     /**
      * Allow user to bypass this functionality
      * - Function should return true if the page should be announced
@@ -58,6 +58,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     validator: Function;
     exclude: unknown[];
     getTitle: Function;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluRouteAnnouncer.vue.d.ts.map

package/dist/components/utils/UluRouteAnnouncer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluRouteAnnouncer.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluRouteAnnouncer.vue"],"names":[],"mappings":"AAqBA;;IAuFM;;;;;OAKG;;;;;IAKH;;;;OAIG;;;;;IAKH;;OAEG;;;;;;;;IArBH;;;;;OAKG;;;;;IAKH;;;;OAIG;;;;;IAKH;;OAEG"}

package/dist/components/utils/UluRouteAnnouncer.vue.js

@@ -0,0 +1,59 @@
+import { createElementBlock as s, createCommentVNode as l, openBlock as u, toDisplayString as c } from "vue";
+import a from "../../_virtual/_plugin-vue_export-helper.js";
+const d = {
+  name: "RouteAnnouncer",
+  props: {
+    /**
+     * Allow user to bypass this functionality
+     * - Function should return true if the page should be announced
+     * - Function is passed  (to, from, $route) => {}
+     *   - to/from are path strings
+     */
+    validator: {
+      type: Function,
+      default: () => !0
+    },
+    /**
+     * Array of paths to exclude
+     * - Can be exact path "/about" 
+     * - Or can be path with wildcard "/about/*" (match all paths under about)
+     */
+    exclude: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * Function to retrieve routes title
+     */
+    getTitle: {
+      type: Function,
+      default: (t) => t.meta?.title
+    }
+  },
+  watch: {
+    "$route.path"(t, r) {
+      if (this.$route.hash)
+        return;
+      const n = this.validator(t, r, this.$route), i = this.exclude.some((e) => e.endsWith("*") ? t.startsWith(e.slice(0, e.length - 1)) : t === e);
+      n && !i && this.$refs.el.focus();
+    }
+  },
+  computed: {
+    title() {
+      const t = this.getTitle(this.$route);
+      return t || console.warn("RouteAnnouncer: No page title!"), t;
+    }
+  }
+};
+function f(t, r, n, i, e, o) {
+  return o.title ? (u(), s("p", {
+    key: 0,
+    tabindex: "-1",
+    class: "hidden-visually",
+    ref: "el"
+  }, c(o.title), 513)) : l("", !0);
+}
+const m = /* @__PURE__ */ a(d, [["render", f]]);
+export {
+  m as default
+};

package/dist/components/utils/UluSanityRichText.vue.d.ts

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

package/dist/components/utils/UluSanityRichText.vue.d.ts.map

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

package/dist/components/utils/UluSanityRichText.vue.js

@@ -0,0 +1,45 @@
+import { createBlock as n, createCommentVNode as o, openBlock as r, withCtx as c, createVNode as l, unref as m, h as p } from "vue";
+import { PortableText as i } from "@portabletext/vue";
+import s from "./UluConditionalWrapper.vue.js";
+const g = {
+  __name: "UluSanityRichText",
+  props: {
+    /**
+     * The array of Portable Text blocks to render.
+     */
+    content: Array,
+    /**
+     * If true, the output will not be wrapped in a div with the 'wysiwyg' class.
+     */
+    noWrapper: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(e) {
+    const a = {
+      types: {
+        image: ({ value: t }) => p("img", {
+          src: `${t.imageUrl}?max-w=1100&fit=crop`,
+          alt: t.imageAlt
+        })
+      }
+    };
+    return (t, u) => e.content?.length ? (r(), n(s, {
+      key: 0,
+      class: "wysiwyg",
+      unwrapped: e.noWrapper
+    }, {
+      default: c(() => [
+        l(m(i), {
+          value: e.content,
+          components: a
+        }, null, 8, ["value"])
+      ]),
+      _: 1
+    }, 8, ["unwrapped"])) : o("", !0);
+  }
+};
+export {
+  g as default
+};

package/dist/components/visualizations/UluAnimateNumber.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * The target number to animate to.
+     */
+    value: NumberConstructor;
+}>, {}, {
+    currentValue: number | undefined;
+    tweenValue: number | undefined;
+}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * The target number to animate to.
+     */
+    value: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluAnimateNumber.vue.d.ts.map

package/dist/components/visualizations/UluAnimateNumber.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluAnimateNumber.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/visualizations/UluAnimateNumber.vue"],"names":[],"mappings":"AAGA;;IAiDM;;OAEG;;;;;;IAFH;;OAEG"}

package/dist/components/visualizations/UluAnimateNumber.vue.js

@@ -0,0 +1,39 @@
+import r from "gsap";
+import { createElementBlock as a, openBlock as u, renderSlot as n, createTextVNode as l, toDisplayString as o } from "vue";
+import s from "../../_virtual/_plugin-vue_export-helper.js";
+const c = {
+  name: "AnimateNumber",
+  props: {
+    /**
+     * The target number to animate to.
+     */
+    value: Number
+  },
+  watch: {
+    value() {
+      r.to(this, {
+        tweenValue: this.value,
+        onUpdate: () => {
+          this.currentValue = Math.ceil(this.tweenValue);
+        }
+      });
+    }
+  },
+  data() {
+    return {
+      currentValue: this.value,
+      tweenValue: this.value
+    };
+  }
+};
+function i(t, p, m, f, e, h) {
+  return u(), a("span", null, [
+    n(t.$slots, "default", { currentValue: e.currentValue }, () => [
+      l(o(e.currentValue), 1)
+    ])
+  ]);
+}
+const v = /* @__PURE__ */ s(c, [["render", i]]);
+export {
+  v as default
+};

package/dist/components/visualizations/UluProgressBar.vue.d.ts

@@ -0,0 +1,61 @@
+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>;
+    small: boolean;
+    labelHidden: boolean;
+    amount: number;
+    labelElement: string;
+    total: number;
+    deficit: number;
+    positive: boolean;
+    negative: boolean;
+    loader: boolean;
+    indeterminate: boolean;
+    noValues: boolean;
+    amountInHeader: boolean;
+    label?: string | undefined;
+    formatValue?: Function | undefined;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly small?: boolean | undefined;
+        readonly labelHidden?: boolean | undefined;
+        readonly amount?: number | undefined;
+        readonly labelElement?: string | undefined;
+        readonly total?: number | undefined;
+        readonly deficit?: number | undefined;
+        readonly positive?: boolean | undefined;
+        readonly negative?: boolean | undefined;
+        readonly loader?: boolean | undefined;
+        readonly indeterminate?: boolean | undefined;
+        readonly noValues?: boolean | undefined;
+        readonly amountInHeader?: boolean | undefined;
+        readonly label?: string | undefined;
+        readonly formatValue?: Function | 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: {
+        label?(_: {}): any;
+        valueAmount?(_: {
+            value: number;
+        }): any;
+        valueAmount?(_: {
+            value: number;
+        }): any;
+        icon?(_: {}): any;
+        valueDeficit?(_: {
+            value: number;
+        }): any;
+        valueTotal?(_: {
+            value: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluProgressBar.vue.d.ts.map

package/dist/components/visualizations/UluProgressBar.vue.d.ts.map

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

package/dist/components/visualizations/UluProgressBar.vue.js

@@ -0,0 +1,172 @@
+import { computed as m, createElementBlock as r, openBlock as s, normalizeClass as v, createCommentVNode as n, createElementVNode as o, createBlock as B, resolveDynamicComponent as h, withCtx as k, renderSlot as i, createTextVNode as u, toDisplayString as d, normalizeStyle as b } from "vue";
+const V = {
+  key: 0,
+  class: "progress-bar__header"
+}, $ = {
+  key: 1,
+  class: "progress-bar__value progress-bar__value--amount"
+}, C = {
+  key: 2,
+  class: "progress-bar__icon"
+}, H = { class: "progress-bar__track" }, N = {
+  key: 1,
+  class: "progress-bar__values"
+}, S = { class: "progress-bar__value progress-bar__value--amount" }, A = {
+  key: 0,
+  class: "progress-bar__value progress-bar__value--deficit"
+}, D = { class: "progress-bar__value progress-bar__value--total" }, w = {
+  __name: "UluProgressBar",
+  props: {
+    /**
+     * The label to display above the progress bar. (or use label slot)
+     */
+    label: String,
+    /**
+     * Hides the label visually, but keeps it for screen readers.
+     */
+    labelHidden: Boolean,
+    /**
+     * Optional classes object (currently only allowing { label } class)
+     */
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Element to use for label
+     */
+    labelElement: {
+      type: String,
+      default: "strong"
+    },
+    /**
+     * The current amount of progress.
+     */
+    amount: {
+      type: Number,
+      default: 0
+    },
+    /**
+     * The total amount that represents 100% progress.
+     */
+    total: {
+      type: Number,
+      default: 100
+    },
+    /**
+     * The amount of deficit to display on the bar.
+     */
+    deficit: {
+      type: Number,
+      default: 0
+    },
+    /**
+     * Renders a smaller version of the progress bar.
+     */
+    small: Boolean,
+    /**
+     * Applies the 'positive' style (e.g., green).
+     */
+    positive: Boolean,
+    /**
+     * Applies the 'negative' style (e.g., red).
+     */
+    negative: Boolean,
+    /**
+     * Applies styles for use as a thin loader.
+     */
+    loader: Boolean,
+    /**
+     * Applies an indeterminate animation for unknown progress.
+     */
+    indeterminate: Boolean,
+    /**
+     * Omit values from output (the numbers below the progress bar)
+     */
+    noValues: Boolean,
+    /**
+     * A function to format the numerical values (amount, deficit, total).
+     * Takes the value and type ('amount', 'deficit', 'total') as input and should return a string.
+     */
+    formatValue: {
+      type: Function,
+      default: (e, a) => e
+    },
+    /**
+     * Will put the amount only in header (there is a headerValue slot it you want to format)
+     */
+    amountInHeader: Boolean
+  },
+  setup(e) {
+    const a = e, c = (t, l) => `${l === 0 ? 0 : t / l * 100}%`, g = m(() => a.indeterminate ? null : c(a.amount, a.total)), f = m(() => c(a.deficit, a.total)), y = m(() => ({
+      "progress-bar": !0,
+      "progress-bar--small": a.small,
+      "progress-bar--positive": a.positive,
+      "progress-bar--negative": a.negative,
+      "progress-bar--loader": a.loader,
+      "progress-bar--indeterminate": a.indeterminate,
+      "type-small": a.small
+      // From original component, seems to control font size
+    }));
+    return (t, l) => (s(), r("div", {
+      class: v(y.value)
+    }, [
+      e.label || t.$slots.label || t.$slots.icon || e.amountInHeader ? (s(), r("div", V, [
+        e.label ? (s(), B(h(e.labelElement), {
+          key: 0,
+          class: v(["progress-bar__label", [e.classes.label, { "hidden-visually": e.labelHidden }]])
+        }, {
+          default: k(() => [
+            i(t.$slots, "label", {}, () => [
+              u(d(e.label), 1)
+            ])
+          ]),
+          _: 3
+        }, 8, ["class"])) : n("", !0),
+        e.amountInHeader ? (s(), r("div", $, [
+          l[0] || (l[0] = o("strong", { class: "hidden-visually" }, "Amount:", -1)),
+          i(t.$slots, "valueAmount", { value: e.amount }, () => [
+            u(d(e.formatValue(e.amount, "amount")), 1)
+          ])
+        ])) : n("", !0),
+        t.$slots.icon ? (s(), r("div", C, [
+          i(t.$slots, "icon")
+        ])) : n("", !0)
+      ])) : n("", !0),
+      o("div", H, [
+        o("div", {
+          class: "progress-bar__bar",
+          style: b({ width: g.value })
+        }, null, 4),
+        e.deficit > 0 ? (s(), r("div", {
+          key: 0,
+          class: "progress-bar__bar--deficit",
+          style: b({ width: f.value })
+        }, null, 4)) : n("", !0)
+      ]),
+      !e.noValues && !e.amountInHeader && !e.loader && !e.indeterminate ? (s(), r("div", N, [
+        o("div", S, [
+          l[1] || (l[1] = o("strong", { class: "hidden-visually" }, "Amount:", -1)),
+          i(t.$slots, "valueAmount", { value: e.amount }, () => [
+            u(d(e.formatValue(e.amount, "amount")), 1)
+          ])
+        ]),
+        e.deficit > 0 ? (s(), r("div", A, [
+          l[2] || (l[2] = o("strong", { class: "hidden-visually" }, "Deficit: ", -1)),
+          i(t.$slots, "valueDeficit", { value: e.deficit }, () => [
+            u("-" + d(e.formatValue(e.deficit, "deficit")), 1)
+          ])
+        ])) : n("", !0),
+        o("div", D, [
+          l[3] || (l[3] = o("strong", { class: "hidden-visually" }, "Total:", -1)),
+          i(t.$slots, "valueTotal", { value: e.total }, () => [
+            u(d(e.formatValue(e.total, "total")), 1)
+          ])
+        ])
+      ])) : n("", !0)
+    ], 2));
+  }
+};
+export {
+  w as default
+};

package/dist/components/visualizations/UluProgressCircle.vue.d.ts

@@ -0,0 +1,51 @@
+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<{}, {
+    small: boolean;
+    duration: number;
+    easing: string;
+    label: string;
+    formatValue: Function;
+    percentage: number;
+    noValue: boolean;
+    outside: boolean;
+    outsideBelow: boolean;
+    status: string;
+    pieStyle: boolean;
+    noMask: boolean;
+    $props: {
+        readonly small?: boolean | undefined;
+        readonly duration?: number | undefined;
+        readonly easing?: string | undefined;
+        readonly label?: string | undefined;
+        readonly formatValue?: Function | undefined;
+        readonly percentage?: number | undefined;
+        readonly noValue?: boolean | undefined;
+        readonly outside?: boolean | undefined;
+        readonly outsideBelow?: boolean | undefined;
+        readonly status?: string | undefined;
+        readonly pieStyle?: boolean | undefined;
+        readonly noMask?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    pie: SVGCircleElement;
+}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        value?(_: {
+            value: number;
+        }): any;
+        value?(_: {
+            value: number;
+        }): any;
+    };
+    refs: {
+        pie: SVGCircleElement;
+    };
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluProgressCircle.vue.d.ts.map

package/dist/components/visualizations/UluProgressCircle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluProgressCircle.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/visualizations/UluProgressCircle.vue"],"names":[],"mappings":"AAkCA;wBAqYqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBASG"}

package/dist/components/visualizations/UluProgressCircle.vue.js

@@ -0,0 +1,149 @@
+import { ref as h, watch as k, computed as i, onMounted as B, createElementBlock as o, openBlock as c, normalizeClass as V, createElementVNode as a, createCommentVNode as p, toDisplayString as u, normalizeStyle as w, renderSlot as y, createTextVNode as f } from "vue";
+const S = { class: "hidden-visually" }, _ = { class: "progress-circle__chart" }, x = {
+  class: "progress-circle__chart-svg",
+  viewBox: "0 0 32 32"
+}, $ = {
+  key: 0,
+  class: "progress-circle__chart-value"
+}, b = {
+  key: 0,
+  class: "progress-circle__value type-small-x"
+}, C = {
+  __name: "UluProgressCircle",
+  props: {
+    /**
+     * The label for accessibility (visually hidden).
+     */
+    label: {
+      type: String,
+      default: "Progress"
+    },
+    /**
+     * The progress percentage (0-100).
+     */
+    percentage: {
+      type: Number,
+      default: 0
+    },
+    /**
+     * A function to format the percentage value.
+     * Takes the number as input and should return a string.
+     */
+    formatValue: {
+      type: Function,
+      default: (s) => `${s}%`
+    },
+    /**
+     * Hides the percentage value display.
+     */
+    noValue: Boolean,
+    /**
+     * Renders a smaller version of the component.
+     */
+    small: Boolean,
+    /**
+     * Displays the percentage value outside (to the side) of the circle.
+     */
+    outside: Boolean,
+    /**
+     * Displays the percentage value below the circle.
+     */
+    outsideBelow: Boolean,
+    /**
+     * Sets the status color of the progress circle (e.g., 'low', 'incomplete', 'complete').
+     */
+    status: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Renders the component as a solid pie chart instead of a donut.
+     */
+    pieStyle: Boolean,
+    /**
+     * Removes the center mask, filling the entire circle.
+     */
+    noMask: Boolean,
+    /**
+     * The duration of the animation in milliseconds.
+     */
+    duration: {
+      type: Number,
+      default: 1e3
+      // Matches SCSS animation-duration
+    },
+    /**
+     * The easing function for the animation.
+     */
+    easing: {
+      type: String,
+      default: "ease-in"
+      // Matches SCSS animation-timing
+    }
+  },
+  setup(s) {
+    const e = s, l = h(null), d = (r) => r === 100 ? 101 : r, g = (r = 0) => {
+      if (!l.value || !l.value.animate) return;
+      const t = { strokeDasharray: [`${r} 100`, m.value] };
+      l.value.animate(t, { duration: e.duration, easing: e.easing, fill: "forwards" });
+    };
+    k(() => e.percentage, (r, t) => {
+      r !== t && g(d(t));
+    });
+    const m = i(() => `${d(e.percentage)} 100`), n = i(() => e.outside || e.outsideBelow || e.small), v = i(() => {
+      const r = {
+        "progress-circle": !0,
+        "progress-circle--small": e.small,
+        "progress-circle--pie": e.pieStyle,
+        "progress-circle--outside": n.value,
+        "progress-circle--outside-below": e.outsideBelow,
+        "progress-circle--no-mask": e.noMask
+      };
+      return e.status && (r[`progress-circle--${e.status}`] = !0), r;
+    });
+    return B(() => {
+      g();
+    }), (r, t) => (c(), o("div", {
+      class: V(v.value)
+    }, [
+      a("strong", S, u(s.label), 1),
+      a("div", _, [
+        (c(), o("svg", x, [
+          t[0] || (t[0] = a("circle", {
+            class: "progress-circle__chart-track",
+            r: "16",
+            cx: "16",
+            cy: "16"
+          }, null, -1)),
+          a("circle", {
+            class: "progress-circle__chart-pie",
+            ref_key: "pie",
+            ref: l,
+            r: "16",
+            cx: "16",
+            cy: "16",
+            style: w({ strokeDasharray: m.value })
+          }, null, 4),
+          t[1] || (t[1] = a("circle", {
+            class: "progress-circle__chart-mask",
+            cx: "16",
+            cy: "16"
+          }, null, -1))
+        ])),
+        !n.value && !s.noValue ? (c(), o("strong", $, [
+          y(r.$slots, "value", { value: s.percentage }, () => [
+            f(u(s.formatValue(s.percentage)), 1)
+          ])
+        ])) : p("", !0)
+      ]),
+      n.value && !s.noValue ? (c(), o("strong", b, [
+        y(r.$slots, "value", { value: s.percentage }, () => [
+          f(u(s.formatValue(s.percentage)), 1)
+        ])
+      ])) : p("", !0)
+    ], 2));
+  }
+};
+export {
+  C as default
+};

package/dist/composables/index.d.ts

@@ -0,0 +1,9 @@
+export { useIcon } from './useIcon.js';
+export { useModifiers } from './useModifiers.js';
+export { useWindowResize } from './useWindowResize.js';
+export { useRequiredInject } from './useRequiredInject.js';
+export { useBreakpointManager } from './useBreakpointManager.js';
+export { usePagination } from './usePagination.js';
+export { useDocumentTitle } from './useDocumentTitle.js';
+export { useUluFloating } from './useUluFloating.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/{types/components → composables}/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/components/index.js"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/composables/index.js"],"names":[],"mappings":""}

package/dist/{types/composables → composables}/useBreakpointManager.d.ts

@@ -21,8 +21,8 @@ export function useBreakpointManager(options: {
     onReady?: Function | undefined;
     plugin?: object | undefined;
 }): {
-    breakpointManager: import("vue").Ref<import("@ulu/frontend").BreakpointManager | null>;
-    breakpointActive: import("vue").Ref<string | null>;
-    breakpointDirection: import("vue").Ref<string | null>;
+    breakpointManager: import('vue').Ref<import('@ulu/frontend').BreakpointManager | null>;
+    breakpointActive: import('vue').Ref<string | null>;
+    breakpointDirection: import('vue').Ref<string | null>;
 };
 //# sourceMappingURL=useBreakpointManager.d.ts.map