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

package/dist/components/systems/table-sticky/UluTableStickyRows.vue.js

@@ -0,0 +1,63 @@
+import { createElementBlock as i, openBlock as s, Fragment as c, renderList as u, normalizeStyle as r, normalizeClass as d, createBlock as A, resolveDynamicComponent as f, withCtx as y, renderSlot as h, createTextVNode as _, toDisplayString as k } from "vue";
+import C from "../../../_virtual/_plugin-vue_export-helper.js";
+const g = {
+  name: "UluTableStickyRows",
+  props: {
+    rows: Array,
+    rowColumns: Array,
+    columnWidth: String,
+    optionalAttr: Function,
+    resolveClasses: Function,
+    getCellHeaders: Function,
+    value: Function,
+    isActual: Boolean,
+    classes: Object,
+    foot: {
+      type: Boolean,
+      default: !1
+    }
+  }
+}, v = ["id"], H = ["innerHTML"];
+function m(n, S, t, b, B, F) {
+  return s(!0), i(c, null, u(t.rows, (l, a) => (s(), i("tr", {
+    key: `br-${a}`,
+    id: t.optionalAttr(t.isActual && l.id),
+    class: d(t.resolveClasses(t.classes.row, { row: l.data, rowIndex: a, isActual: t.isActual, foot: t.foot })),
+    style: r({
+      height: l.height
+    })
+  }, [
+    (s(!0), i(c, null, u(t.rowColumns, (e, o) => (s(), A(f(e.rowHeader ? "th" : "td"), {
+      id: t.optionalAttr(t.isActual && e.rowHeader && e.getRowHeaderId(a)),
+      scope: t.optionalAttr(t.isActual && e.rowHeader && "row"),
+      key: `bc-${o}`,
+      headers: t.optionalAttr(t.isActual && t.getCellHeaders(e, a)),
+      class: d(t.resolveClasses(e.class, { column: e, index: o, isActual: t.isActual, row: l, rowIndex: a, foot: t.foot })),
+      style: r({
+        width: t.columnWidth
+      })
+    }, {
+      default: y(() => [
+        n.$slots[e.slot] ? h(n.$slots, e.slot, {
+          key: 0,
+          row: l.data,
+          column: e,
+          rowIndex: a,
+          index: o,
+          foot: t.foot,
+          isActual: t.isActual
+        }) : e.html ? (s(), i("div", {
+          key: 1,
+          innerHTML: t.value({ row: l, column: e, rowIndex: a, isActual: t.isActual, foot: t.foot })
+        }, null, 8, H)) : (s(), i(c, { key: 2 }, [
+          _(k(t.value({ row: l, column: e, rowIndex: a, isActual: t.isActual, foot: t.foot })), 1)
+        ], 64))
+      ]),
+      _: 2
+    }, 1032, ["id", "scope", "headers", "class", "style"]))), 128))
+  ], 14, v))), 128);
+}
+const L = /* @__PURE__ */ C(g, [["render", m]]);
+export {
+  L as default
+};

package/dist/{types/components → components}/systems/table-sticky/UluTableStickyTable.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<{
     resolveClasses: FunctionConstructor;
     classes: {
         type: ObjectConstructor;
@@ -61,7 +61,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }): any;
     getCellHeaders(column: any, rowIndex: any): string;
     getHeaderHeaders(column: any): 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<{
     resolveClasses: FunctionConstructor;
     classes: {
         type: ObjectConstructor;
@@ -114,7 +114,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     getRowValue: Function;
     getColumnTitle: Function;
 }, {}, {
-    UluTableStickyRows: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    UluTableStickyRows: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
         rows: ArrayConstructor;
         rowColumns: ArrayConstructor;
         columnWidth: StringConstructor;
@@ -128,7 +128,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: BooleanConstructor;
             default: boolean;
         };
-    }>, {}, {}, {}, {}, 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<{
         rows: ArrayConstructor;
         rowColumns: ArrayConstructor;
         columnWidth: StringConstructor;
@@ -145,7 +145,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }>> & Readonly<{}>, {
         isActual: boolean;
         foot: boolean;
-    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluTableStickyTable.vue.d.ts.map

package/dist/components/systems/table-sticky/UluTableStickyTable.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluTableStickyTable.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/table-sticky/UluTableStickyTable.vue"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;IAmQM;;OAEG;;;;;;;IAOH;;;;OAIG;;;;;;;;IAKH;;;;OAIG;;;;;;;;;;;;IA4BH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;IApDH;;OAEG;;;;;;;IAOH;;;;OAIG;;;;;;;;IAKH;;;;OAIG"}

package/dist/components/systems/table-sticky/UluTableStickyTable.vue.js

@@ -0,0 +1,226 @@
+import F from "./UluTableStickyRows.vue.js";
+import { resolveComponent as W, createElementBlock as i, openBlock as r, normalizeClass as f, createCommentVNode as C, createElementVNode as _, toDisplayString as k, Fragment as h, renderList as g, normalizeStyle as b, createBlock as B, resolveDynamicComponent as V, withCtx as v, renderSlot as A, createTextVNode as w, createVNode as T, createSlots as m, normalizeProps as R, guardReactiveProps as S } from "vue";
+import L from "../../../_virtual/_plugin-vue_export-helper.js";
+const U = {
+  name: "UluTableStickyTable",
+  components: {
+    UluTableStickyRows: F
+  },
+  props: {
+    resolveClasses: Function,
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    caption: String,
+    idPrefix: String,
+    headerRows: {
+      type: Array,
+      required: !0
+    },
+    rows: Array,
+    footerRows: Array,
+    rowColumns: Array,
+    /**
+     * Is the actual table not a clone for sticky headers
+     */
+    isActual: {
+      type: Boolean
+    },
+    columnWidth: {
+      type: String
+    },
+    /**
+     * Optional user overridden value getter (for rows)
+     * @param {Object} row The current row
+     * @param {Object} column The current column in the row
+     */
+    getRowValue: {
+      type: Function,
+      default: ({ row: s, column: a }) => s[a.key]
+    },
+    /**
+     * Optional user overridden value getter (for rows)
+     * @param {Object} row The current row
+     * @param {Object} column The current column in the row
+     */
+    getColumnTitle: {
+      type: Function,
+      default: ({ column: s }) => s.title
+    }
+  },
+  data() {
+    return {
+      headerRefs: {}
+    };
+  },
+  methods: {
+    handleSortFocus(s, a) {
+      this.isActual && (s.sortFocused = a);
+    },
+    addHeaderRef(s, a) {
+      const { headerRefs: e, isActual: n } = this;
+      if (!n || !a) return;
+      const { id: u } = s, l = e[u];
+      l && this.$emit("actual-header-removed", l), this.$emit("actual-header-added", a), e[u] = a;
+    },
+    /**
+     * False is no longer not printed
+     */
+    optionalAttr(s) {
+      return s || null;
+    },
+    value({ row: s, column: a, rowIndex: e }) {
+      const n = a.value;
+      return n ? n({ row: s.data, column: a, rowIndex: e }) : this.getRowValue({ row: s.data, column: a, rowIndex: e });
+    },
+    getCellHeaders(s, a) {
+      const e = s.headers.join(" "), n = s.getRowHeaders(a), u = n.length ? " " : "";
+      return `${e}${u}${n}`;
+    },
+    getHeaderHeaders(s) {
+      const a = s.headers.filter((e) => e !== s.id);
+      if (a.length)
+        return a.join(" ");
+    }
+  }
+}, M = ["aria-hidden"], N = {
+  key: 0,
+  class: "table-sticky__caption"
+}, j = ["id"], z = ["id", "rowspan", "colspan", "data-child-columns", "aria-sort", "scope", "headers"], P = ["innerHTML"], D = {
+  class: "table-sticky__sort-icon",
+  "aria-hidden": "true"
+}, E = { class: "table-sticky__sort-icon-inner" }, q = ["innerHTML"], O = { key: 1 }, G = { key: 2 };
+function J(s, a, e, n, u, l) {
+  const H = W("UluTableStickyRows");
+  return r(), i("table", {
+    class: f(e.resolveClasses(e.classes.table, { isActual: e.isActual })),
+    "aria-hidden": e.isActual ? "false" : "true"
+  }, [
+    e.caption ? (r(), i("caption", N, k(e.caption), 1)) : C("", !0),
+    _("thead", null, [
+      (r(!0), i(h, null, g(e.headerRows, (c, o) => (r(), i("tr", {
+        key: `hr-${o}`,
+        id: l.optionalAttr(e.isActual && c.id),
+        class: f(e.resolveClasses(e.classes.rowHeader, { row: c, rowIndex: o, isActual: e.isActual })),
+        style: b({
+          height: c.height
+        })
+      }, [
+        (r(!0), i(h, null, g(c.columns, (t, d) => (r(), i("th", {
+          key: `hc-${d}`,
+          id: l.optionalAttr(e.isActual && t.id),
+          rowspan: t.rowspan,
+          colspan: t.colspan,
+          "data-child-columns": t.columns && t.columns.length,
+          class: f([
+            {
+              "sort-active": t.sortApplied,
+              "sort-ascending": t.sortApplied && t.sortAscending,
+              "sort-descending": t.sortApplied && !t.sortAscending
+            },
+            e.resolveClasses(t.classHeader, { column: t, index: d, isActual: e.isActual })
+          ]),
+          style: b({
+            width: t.width
+          }),
+          "aria-sort": t.sort ? t.sortAscending ? "ascending" : "descending" : null,
+          scope: l.optionalAttr(e.isActual && (t.colspan > 1 ? "colgroup" : "col")),
+          headers: l.optionalAttr(e.isActual && l.getHeaderHeaders(t, o)),
+          ref_for: !0,
+          ref: (y) => l.addHeaderRef(t, y)
+        }, [
+          t.sortable ? (r(), B(V(e.isActual ? "button" : "div"), {
+            key: 0,
+            class: f(["table-sticky__sort-button", {
+              "table-sticky__sort-button--focused": t.sortFocused
+            }]),
+            onClick: (y) => s.$emit("column-sorted", t),
+            onFocus: (y) => l.handleSortFocus(t, !0),
+            onBlur: (y) => l.handleSortFocus(t, !1),
+            "aria-pressed": t.sortApplied ? "true" : "false"
+          }, {
+            default: v(() => [
+              s.$slots[t.slotHeader] ? A(s.$slots, t.slotHeader, {
+                key: 0,
+                isActual: e.isActual,
+                column: t,
+                index: d
+              }) : t.htmlTitle ? (r(), i("div", {
+                key: 1,
+                innerHTML: e.getColumnTitle({ column: t, index: d, isActual: e.isActual })
+              }, null, 8, P)) : (r(), i(h, { key: 2 }, [
+                w(k(e.getColumnTitle({ column: t, index: d, isActual: e.isActual })), 1)
+              ], 64)),
+              _("span", D, [
+                _("span", E, [
+                  A(s.$slots, "sortIcon", {}, () => [
+                    a[0] || (a[0] = w("▼", -1))
+                  ])
+                ])
+              ])
+            ]),
+            _: 2
+          }, 1064, ["class", "onClick", "onFocus", "onBlur", "aria-pressed"])) : (r(), i(h, { key: 1 }, [
+            s.$slots[t.slotHeader] ? A(s.$slots, t.slotHeader, {
+              key: 0,
+              isActual: e.isActual,
+              column: t,
+              index: d
+            }) : t.htmlTitle ? (r(), i("div", {
+              key: 1,
+              innerHTML: e.getColumnTitle({ column: t, index: d, isActual: e.isActual })
+            }, null, 8, q)) : (r(), i(h, { key: 2 }, [
+              w(k(e.getColumnTitle({ column: t, index: d, isActual: e.isActual })), 1)
+            ], 64))
+          ], 64))
+        ], 14, z))), 128))
+      ], 14, j))), 128))
+    ]),
+    e.rows ? (r(), i("tbody", O, [
+      T(H, {
+        rows: e.rows,
+        rowColumns: e.rowColumns,
+        optionalAttr: l.optionalAttr,
+        resolveClasses: e.resolveClasses,
+        getCellHeaders: l.getCellHeaders,
+        isActual: e.isActual,
+        columnWidth: e.columnWidth,
+        classes: e.classes,
+        value: l.value
+      }, m({ _: 2 }, [
+        g(s.$slots, (c, o) => ({
+          name: o,
+          fn: v((t) => [
+            A(s.$slots, o, R(S(t)))
+          ])
+        }))
+      ]), 1032, ["rows", "rowColumns", "optionalAttr", "resolveClasses", "getCellHeaders", "isActual", "columnWidth", "classes", "value"])
+    ])) : C("", !0),
+    e.footerRows ? (r(), i("tfoot", G, [
+      T(H, {
+        rows: e.footerRows,
+        rowColumns: e.rowColumns,
+        optionalAttr: l.optionalAttr,
+        resolveClasses: e.resolveClasses,
+        getCellHeaders: l.getCellHeaders,
+        isActual: e.isActual,
+        columnWidth: e.columnWidth,
+        classes: e.classes,
+        value: l.value,
+        foot: ""
+      }, m({ _: 2 }, [
+        g(s.$slots, (c, o) => ({
+          name: o,
+          fn: v((t) => [
+            A(s.$slots, o, R(S(t)))
+          ])
+        }))
+      ]), 1032, ["rows", "rowColumns", "optionalAttr", "resolveClasses", "getCellHeaders", "isActual", "columnWidth", "classes", "value"])
+    ])) : C("", !0)
+  ], 10, M);
+}
+const Y = /* @__PURE__ */ L(U, [["render", J]]);
+export {
+  Y as default
+};

package/dist/{types/components → components}/utils/UluConditionalText.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<{
     /**
      * Text to print in element
      */
@@ -10,7 +10,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
         default: string;
     };
-}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /**
      * Text to print in element
      */
@@ -24,6 +24,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>> & Readonly<{}>, {
     element: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluConditionalText.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UluConditionalText.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluConditionalText.vue"],"names":[],"mappings":"AAMA;;IAmCM;;OAEG;;IAEH;;OAEG;;;;;;IANH;;OAEG;;IAEH;;OAEG"}

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

@@ -0,0 +1,30 @@
+import { createBlock as t, createCommentVNode as n, openBlock as o, resolveDynamicComponent as r, withCtx as a, createTextVNode as c, toDisplayString as i } from "vue";
+import l from "../../_virtual/_plugin-vue_export-helper.js";
+const m = {
+  name: "UluConditionalText",
+  props: {
+    /**
+     * Text to print in element
+     */
+    text: [String, Number, Array, Object],
+    /**
+     * Element type to render (ie. h1, h2, p, etc)
+     */
+    element: {
+      type: String,
+      default: "p"
+    }
+  }
+};
+function u(d, x, e, f, p, s) {
+  return e.text != null ? (o(), t(r(e.element), { key: 0 }, {
+    default: a(() => [
+      c(i(e.text), 1)
+    ]),
+    _: 1
+  })) : n("", !0);
+}
+const C = /* @__PURE__ */ l(m, [["render", u]]);
+export {
+  C as default
+};

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

@@ -0,0 +1,23 @@
+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<{}, {
+    is: string | Function | Record<string, any>;
+    unwrapped: boolean;
+    $props: {
+        readonly is?: string | Function | Record<string, any> | undefined;
+        readonly unwrapped?: 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;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+//# sourceMappingURL=UluConditionalWrapper.vue.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+import { createBlock as n, renderSlot as a, openBlock as o, resolveDynamicComponent as l, withCtx as r } from "vue";
+const s = {
+  __name: "UluConditionalWrapper",
+  props: {
+    /**
+     * The underlying component or HTML tag to render.
+     * Can be a string like 'div' or an imported component object.
+     */
+    is: {
+      type: [String, Object, Function],
+      // Can be a string or a component definition
+      default: "div"
+      // A sensible default for a wrapper
+    },
+    /**
+     * If true, the wrapper will not be rendered and the content
+     * will be output directly.
+     */
+    unwrapped: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(e) {
+    return (t, p) => e.unwrapped ? a(t.$slots, "default", { key: 1 }) : (o(), n(l(e.is), { key: 0 }, {
+      default: r(() => [
+        a(t.$slots, "default")
+      ]),
+      _: 3
+    }));
+  }
+};
+export {
+  s as default
+};

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

@@ -0,0 +1,3 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLSpanElement>;
+export default _default;
+//# sourceMappingURL=UluEmpty.vue.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+import { createElementBlock as e, openBlock as t } from "vue";
+import o from "../../_virtual/_plugin-vue_export-helper.js";
+const n = {}, c = { style: { display: "none" } };
+function r(s, _) {
+  return t(), e("span", c);
+}
+const f = /* @__PURE__ */ o(n, [["render", r]]);
+export {
+  f as default
+};

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

@@ -0,0 +1,3 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluEmptyView.vue.d.ts.map

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

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

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

@@ -0,0 +1,11 @@
+import { resolveComponent as o, createBlock as r, openBlock as t } from "vue";
+import c from "../../_virtual/_plugin-vue_export-helper.js";
+const n = {};
+function _(m, p) {
+  const e = o("router-view");
+  return t(), r(e);
+}
+const i = /* @__PURE__ */ c(n, [["render", _]]);
+export {
+  i as default
+};

package/dist/{types/components → components}/utils/UluPlaceholderImage.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<{
     imageId: StringConstructor;
     /**
      * Width of the image
@@ -28,7 +28,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         width: any;
         height: 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<{
     imageId: StringConstructor;
     /**
      * Width of the image
@@ -53,9 +53,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
      */
     random: BooleanConstructor;
 }>> & Readonly<{}>, {
-    height: string | number;
-    width: string | number;
     random: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    width: string | number;
+    height: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluPlaceholderImage.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UluPlaceholderImage.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/utils/UluPlaceholderImage.vue"],"names":[],"mappings":"AAGA;;;IA2DM;;OAEG;;;;;IAKH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;;;;;;IApBH;;OAEG;;;;;IAKH;;OAEG;;;;;IAKH;;OAEG;;IAEH;;OAEG"}

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

@@ -0,0 +1,54 @@
+import { randomInt as i } from "@ulu/utils/random.js";
+import { createElementBlock as s, openBlock as c } from "vue";
+import a from "../../_virtual/_plugin-vue_export-helper.js";
+const d = {
+  name: "UluPlaceholderImage",
+  props: {
+    imageId: String,
+    /**
+     * Width of the image
+     */
+    width: {
+      type: [String, Number],
+      default: "300"
+    },
+    /**
+     * Height of the image
+     */
+    height: {
+      type: [String, Number],
+      default: "400"
+    },
+    /**
+     * Alt text for placeholder image
+     */
+    alt: String,
+    /**
+     * Random size
+     */
+    random: Boolean
+  },
+  computed: {
+    src() {
+      const { imageId: t } = this, { width: r, height: e } = this.size;
+      return `https://picsum.photos/${t ? `id/${t}/` : ""}${r}/${e}`;
+    },
+    size() {
+      const { random: t, width: r, height: e } = this;
+      return t ? {
+        width: i(500, 1e3),
+        height: i(500, 1e3)
+      } : { width: r, height: e };
+    }
+  }
+}, h = ["src", "alt"];
+function m(t, r, e, o, l, n) {
+  return c(), s("img", {
+    src: n.src,
+    alt: e.alt
+  }, null, 8, h);
+}
+const f = /* @__PURE__ */ a(d, [["render", m]]);
+export {
+  f as default
+};

package/dist/{types/components → components}/utils/UluPlaceholderText.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<{
     amount: {
         type: NumberConstructor;
         default: number;
@@ -7,7 +7,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
         default: string;
     };
-}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     amount: {
         type: NumberConstructor;
         default: number;
@@ -19,6 +19,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>> & Readonly<{}>, {
     element: string;
     amount: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluPlaceholderText.vue.d.ts.map

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

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

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

@@ -0,0 +1,27 @@
+import { createElementBlock as u, openBlock as i, Fragment as s, renderList as a, createBlock as r, resolveDynamicComponent as c, withCtx as l, createTextVNode as o } from "vue";
+import m from "../../_virtual/_plugin-vue_export-helper.js";
+const d = {
+  name: "PlaceholderText",
+  props: {
+    amount: {
+      type: Number,
+      default: 1
+    },
+    element: {
+      type: String,
+      default: "p"
+    }
+  }
+};
+function p(f, e, t, v, g, x) {
+  return i(!0), u(s, null, a(parseInt(t.amount), (n) => (i(), r(c(t.element), { key: n }, {
+    default: l(() => [...e[0] || (e[0] = [
+      o(" Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed semper erat tincidunt tellus vestibulum dictum. Fusce vel augue commodo, egestas diam sed, accumsan leo. Maecenas congue nec nisl et ullamcorper. Maecenas tincidunt, tortor et viverra eleifend, enim leo vestibulum ipsum, quis placerat mi nisi nec ex. Vivamus a justo volutpat, scelerisque elit eget, lacinia ex. Phasellus dapibus sollicitudin tortor, vitae suscipit nunc condimentum ut. Cras suscipit feugiat nibh nec consectetur. Phasellus vitae quam blandit, cursus metus ut, placerat mi. Sed tempor lacus non est interdum imperdiet nec quis metus. Praesent vel eleifend diam. Donec tincidunt eget purus sed posuere. ", -1)
+    ])]),
+    _: 2
+  }, 1024))), 128);
+}
+const h = /* @__PURE__ */ m(d, [["render", p]]);
+export {
+  h as default
+};