ablok-components 0.3.57 → 0.3.59

package/dist/assets/img/guide.png.js

@@ -0,0 +1,4 @@
+const A = "data:image/png;base64,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";
+export {
+  A as default
+};

package/dist/components/atoms/base-button/base-button.vue.js

@@ -0,0 +1,92 @@
+import { defineComponent as s, computed as r, openBlock as t, createElementBlock as o, normalizeClass as i, renderSlot as d, createVNode as u, createCommentVNode as n, createBlock as f, toDisplayString as y } from "vue";
+import m from "../loading-spinner/loading-spinner.vue.js";
+/* empty css                                      */
+import b from "../svg-icon/svg-icon.vue.js";
+/* empty css                        */
+const g = ["type", "disabled"], C = /* @__PURE__ */ s({
+  __name: "base-button",
+  props: {
+    type: {
+      type: null
+    },
+    caption: {
+      type: String
+    },
+    variant: {
+      type: String
+    },
+    color: {
+      type: String,
+      default: "primary"
+    },
+    size: {
+      type: String
+    },
+    icon: {
+      type: String
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    pending: {
+      type: Boolean,
+      default: !1
+    },
+    success: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: Boolean,
+      default: !1
+    },
+    outlined: {
+      type: Boolean,
+      default: !1
+    },
+    rounded: {
+      type: Boolean,
+      default: !1
+    },
+    circle: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(e) {
+    const l = e, c = r(() => l.caption && !l.circle);
+    return (a, p) => (t(), o("button", {
+      type: e.type,
+      disabled: e.disabled,
+      class: i(["btn", {
+        disabled: e.disabled,
+        pending: e.pending,
+        rounded: e.rounded,
+        "rounded-circle": e.circle,
+        [`btn-${e.color}`]: !e.outlined,
+        [`btn-outline-${e.color}`]: e.outlined,
+        "btn-lg": e.size === "large",
+        "btn-sm": e.size === "small"
+      }])
+    }, [
+      e.pending ? d(a.$slots, "pending-icon", { key: 0 }, () => [
+        u(m)
+      ]) : n("", !0),
+      d(a.$slots, "default", {}, () => [
+        e.icon ? (t(), f(b, {
+          key: 0,
+          symbol: e.icon,
+          class: "base-button__caption"
+        }, null, 8, ["symbol"])) : n("", !0),
+        c.value ? (t(), o("span", {
+          key: 1,
+          class: i(["base-button__caption", { "icon-padding": e.icon }])
+        }, y(e.caption), 3)) : n("", !0)
+      ])
+    ], 10, g));
+  }
+});
+export {
+  C as default
+};

package/dist/components/atoms/base-button/base-button.vue3.js

@@ -0,0 +1,5 @@
+import o from "./base-button.vue.js";
+/* empty css                 */
+export {
+  o as default
+};

package/dist/components/atoms/base-headline/base-headline.vue.js

@@ -0,0 +1,30 @@
+import { defineComponent as s, computed as l, openBlock as o, createBlock as c, resolveDynamicComponent as i, normalizeClass as r, withCtx as d, renderSlot as m, createElementVNode as u } from "vue";
+const h = ["innerHTML"], x = /* @__PURE__ */ s({
+  __name: "base-headline",
+  props: {
+    tag: {},
+    size: {},
+    variant: {},
+    text: {},
+    className: {}
+  },
+  setup(e) {
+    const t = e, a = l(() => t.tag || "p");
+    return (n, f) => (o(), c(i(a.value), {
+      class: r(["headline", `${e.size} headline--${e.size}${e.className || ""}`])
+    }, {
+      default: d(() => [
+        m(n.$slots, "default", {}, () => [
+          u("span", {
+            class: "headline__text",
+            innerHTML: e.text
+          }, null, 8, h)
+        ])
+      ]),
+      _: 3
+    }, 8, ["class"]));
+  }
+});
+export {
+  x as default
+};

package/dist/components/atoms/base-headline/base-headline.vue2.js

@@ -0,0 +1,4 @@
+import f from "./base-headline.vue.js";
+export {
+  f as default
+};

package/dist/components/atoms/base-image/base-image.vue.js

@@ -0,0 +1,75 @@
+import { defineComponent as u, useTemplateRef as c, ref as f, onBeforeMount as g, openBlock as i, createElementBlock as p, normalizeClass as l, createBlock as y, createCommentVNode as r, createElementVNode as v } from "vue";
+import B from "../loading-spinner/loading-spinner.vue.js";
+/* empty css                                      */
+const k = ["src", "alt"], h = /* @__PURE__ */ u({
+  __name: "base-image",
+  props: {
+    src: {
+      type: String,
+      default: 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg"/>',
+      required: !0
+    },
+    alt: {
+      type: String,
+      default: ""
+    },
+    spinner: {
+      type: Boolean,
+      default: !1
+    },
+    zoom: {
+      type: Boolean,
+      default: !1
+    },
+    animate: {
+      type: Boolean,
+      default: !0
+    },
+    ready: {
+      type: Boolean,
+      default: !1
+    },
+    pending: {
+      type: Boolean,
+      default: !1
+    },
+    emitPending: {
+      type: Boolean,
+      default: !0
+    }
+  },
+  emits: ["update:ready", "update:pending"],
+  setup(e, { emit: d }) {
+    const n = e, a = d, o = c("image"), t = f(!1);
+    function m() {
+      t.value = !0, o.value?.addEventListener("transitionend", s, { once: !0 });
+    }
+    function s() {
+      a("update:ready", !0), n.emitPending && a("update:pending", !1);
+    }
+    return g(() => {
+      n.emitPending && a("update:pending", !0);
+    }), (w, x) => e.src ? (i(), p("div", {
+      key: 0,
+      class: l(["base-image", {
+        "base-image--zoom": e.zoom
+      }])
+    }, [
+      e.spinner && !t.value ? (i(), y(B, { key: 0 })) : r("", !0),
+      v("img", {
+        ref_key: "image",
+        ref: o,
+        class: l(["", {
+          "opacity-0": e.animate && !t.value,
+          "opacity-1": !e.animate || t.value
+        }]),
+        src: e.src,
+        alt: e.alt,
+        onLoad: m
+      }, null, 42, k)
+    ], 2)) : r("", !0);
+  }
+});
+export {
+  h as default
+};

package/dist/components/atoms/base-image/base-image.vue3.js

@@ -0,0 +1,5 @@
+import o from "./base-image.vue.js";
+/* empty css                */
+export {
+  o as default
+};

package/dist/components/atoms/base-input/base-input.vue.js

@@ -0,0 +1,181 @@
+import { defineComponent as k, useTemplateRef as N, ref as p, computed as d, watch as B, onMounted as w, openBlock as s, createElementBlock as m, normalizeClass as v, createElementVNode as y, renderSlot as f, withDirectives as $, mergeProps as L, vModelDynamic as q, createCommentVNode as b, createVNode as z, Transition as E, withCtx as M, toDisplayString as C } from "vue";
+import { sanitizeInput as D, uniqueId as g } from "../../../utilities/helpers.js";
+import { sanitizeHtml as H } from "../../../composables/useSanitize.js";
+const T = { class: "input-group input__input-group" }, I = ["type", "id", "name", "placeholder", "pattern", "disabled", "readonly", "required", "maxlength", "true-value", "false-value", "aria-label", "role", "autocomplete"], O = ["for", "innerHTML"], A = {
+  key: 0,
+  class: "input__error alert alert-danger mt-3"
+}, j = /* @__PURE__ */ k({
+  __name: "base-input",
+  props: {
+    modelValue: {
+      type: [String, Number, Boolean, Date],
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "text"
+    },
+    name: {
+      type: String,
+      default: () => g()
+    },
+    id: {
+      type: String,
+      default: () => g()
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    variant: {
+      type: String,
+      default: ""
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    readOnly: {
+      type: Boolean,
+      default: !1
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    min: {
+      type: Number
+    },
+    max: {
+      type: Number
+    },
+    maxlength: {
+      type: Number
+    },
+    pattern: {
+      type: String,
+      default: null
+    },
+    trueValue: {
+      type: null,
+      default: !0
+    },
+    falseValue: {
+      type: null,
+      default: !1
+    },
+    role: {
+      type: String,
+      default: "presentation"
+    },
+    autocomplete: {
+      type: String,
+      default: "off"
+    },
+    validate: {
+      type: Boolean,
+      default: !1
+    },
+    valid: {
+      type: Boolean,
+      default: !0
+    },
+    sanitize: {
+      type: Boolean,
+      default: !0
+    }
+  },
+  emits: ["update:modelValue", "update:valid"],
+  setup(e, { emit: h }) {
+    const l = e, c = h, n = N("input"), i = p(l.valid), u = p(), x = d(
+      () => H(`${l.label}${l.required ? " *" : ""}`)
+    ), o = d({
+      get() {
+        return l.modelValue;
+      },
+      set(t) {
+        t = l.type === "number" ? l.max && Number(t) > l.max ? l.max : l.min !== void 0 && Number(t) < l.min ? l.min : Number(t) : t, l.sanitize && typeof t == "string" && !["checkbox", "radio", "number", "date", "datetime-local", "time", "month", "week", "email", "tel", "url"].includes(l.type) && (t = D(t)), c("update:modelValue", t);
+      }
+    }), S = d(() => {
+      if (l.type === "number") {
+        const { min: t, max: a } = l;
+        return {
+          ...t !== void 0 ? { min: t } : {},
+          ...a !== void 0 ? { max: a } : {}
+        };
+      }
+      return {};
+    });
+    function r() {
+      l.validate && n.value && (i.value = n.value.checkValidity(), i.value ? u.value = void 0 : u.value = n.value.validationMessage, c("update:valid", i.value));
+    }
+    return B(() => l.modelValue, () => {
+      i.value === !1 && r();
+    }), w(() => {
+      let t = (a) => {
+        o.value = typeof a.detail == "string" || typeof a.detail == "number" ? `${a.detail}` : "";
+      };
+      n.value?.addEventListener("focusin", (a) => {
+        window.addEventListener("update-focussed-input", t);
+      }), n.value?.addEventListener("focusout", (a) => {
+        window.removeEventListener("update-focussed-input", t);
+      }), r();
+    }), (t, a) => (s(), m("div", {
+      class: v(["input", `input--${e.type}${i.value ? "" : " input--invalid"}`])
+    }, [
+      y("div", T, [
+        f(t.$slots, "input-prepend", { slotScope: "props" }),
+        $(y("input", L({
+          ref_key: "input",
+          ref: n,
+          "onUpdate:modelValue": a[0] || (a[0] = (V) => o.value = V),
+          type: e.type === "color" ? "text" : e.type,
+          id: e.id,
+          name: e.name,
+          placeholder: e.placeholder,
+          pattern: e.pattern,
+          disabled: e.disabled,
+          readonly: e.readOnly,
+          required: e.required,
+          maxlength: e.maxlength
+        }, S.value, {
+          "true-value": e.trueValue,
+          "false-value": e.falseValue,
+          class: ["form-control", {
+            "form-check-input": e.type === "checkbox"
+          }],
+          "aria-label": e.label,
+          role: e.role,
+          autocomplete: e.autocomplete,
+          onChange: r
+        }), null, 16, I), [
+          [q, o.value]
+        ]),
+        f(t.$slots, "input-append", { slotScope: "props" })
+      ]),
+      f(t.$slots, "label", {}, () => [
+        e.label ? (s(), m("label", {
+          key: 0,
+          for: e.id,
+          class: v(["input__label", {
+            "form-check-label": e.type === "checkbox"
+          }]),
+          innerHTML: x.value
+        }, null, 10, O)) : b("", !0)
+      ]),
+      z(E, { name: "fade" }, {
+        default: M(() => [
+          !i.value && u.value ? (s(), m("div", A, C(u.value), 1)) : b("", !0)
+        ]),
+        _: 1
+      })
+    ], 2));
+  }
+});
+export {
+  j as default
+};

package/dist/components/atoms/base-input/base-input.vue3.js

@@ -0,0 +1,5 @@
+import o from "./base-input.vue.js";
+/* empty css                */
+export {
+  o as default
+};

package/dist/components/atoms/base-paragraph/base-paragraph.vue.js

@@ -0,0 +1,21 @@
+import { defineComponent as t, openBlock as n, createElementBlock as s, normalizeClass as r } from "vue";
+import { useSanitize as o } from "../../../composables/useSanitize.js";
+const c = ["innerHTML"], u = /* @__PURE__ */ t({
+  __name: "base-paragraph",
+  props: {
+    size: {},
+    variant: {},
+    text: {},
+    className: {}
+  },
+  setup(e) {
+    const a = e;
+    return o(() => a.text || ""), (i, l) => (n(), s("p", {
+      class: r(["base-paragraph", `${e.size || ""} ${e.className || ""}`]),
+      innerHTML: e.text
+    }, null, 10, c));
+  }
+});
+export {
+  u as default
+};

package/dist/components/atoms/base-paragraph/base-paragraph.vue2.js

@@ -0,0 +1,4 @@
+import f from "./base-paragraph.vue.js";
+export {
+  f as default
+};

package/dist/components/atoms/canvas-confetti/canvas-confetti.vue.js

@@ -0,0 +1,113 @@
+import { defineComponent as f, ref as p, computed as m, onMounted as d, openBlock as y, createElementBlock as w } from "vue";
+import { getConfetti as g } from "../../../composables/useConfetti.js";
+const s = {
+  default: {
+    items: [
+      {
+        particleCount: 80,
+        spread: 120,
+        origin: { y: 0.625, x: 0.5 }
+      },
+      {
+        timeout: 400,
+        particleCount: 80,
+        spread: 120,
+        origin: { y: 0.625, x: 0.625 }
+      },
+      {
+        timeout: 800,
+        particleCount: 80,
+        spread: 120,
+        origin: { y: 0.625, x: 0.375 }
+      }
+    ]
+  },
+  randomDirection: {
+    items: [
+      {
+        angle: r(55, 125),
+        spread: r(50, 70),
+        particleCount: r(50, 100),
+        origin: { y: 0.6 }
+      }
+    ]
+  },
+  pride: {
+    items: [
+      {
+        timeout: 20,
+        particleCount: 2,
+        spread: 32,
+        origin: { x: 0 },
+        colors: ["#ff0000"]
+      },
+      {
+        timeout: 20,
+        particleCount: 2,
+        spread: 32,
+        origin: { x: 1 },
+        colors: ["#ff0000"]
+      }
+    ]
+  }
+};
+function r(i, t) {
+  return Math.random() * (t - i) + i;
+}
+const _ = /* @__PURE__ */ f({
+  __name: "canvas-confetti",
+  props: {
+    preset: {
+      type: String,
+      default: "default"
+    },
+    items: {
+      default: () => [{}]
+    },
+    colors: {
+      type: Array,
+      default: () => []
+    },
+    loop: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(i) {
+    const t = i, o = p(null), c = m(() => ({
+      ...s[t.preset],
+      items: s[t.preset].items.map((e, n) => ({
+        ...e,
+        ...t.items[n],
+        ...t.colors.length ? { colors: t.colors } : {}
+      }))
+    }));
+    async function u(e) {
+      return new Promise((n) => {
+        (typeof window < "u" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : (l) => setTimeout(l, 16))(() => o.value?.confetti?.(JSON.parse(JSON.stringify(e)))), setTimeout(() => n(), 0);
+      });
+    }
+    async function a() {
+      await Promise.all(c.value.items.map(
+        (e) => new Promise((n) => setTimeout(() => {
+          n(u(e));
+        }, e.timeout || 0))
+      )), t.loop && a();
+    }
+    return d(async () => {
+      if (typeof window < "u" && o.value) {
+        const e = await g();
+        if (!e)
+          return;
+        o.value.confetti = o.value?.confetti || e.create(o.value, { resize: !0 }), a();
+      }
+    }), (e, n) => (y(), w("canvas", {
+      class: "canvas-confetti",
+      ref_key: "canvas",
+      ref: o
+    }, null, 512));
+  }
+});
+export {
+  _ as default
+};

package/dist/components/atoms/canvas-confetti/canvas-confetti.vue3.js

@@ -0,0 +1,5 @@
+import o from "./canvas-confetti.vue.js";
+/* empty css                     */
+export {
+  o as default
+};

package/dist/components/atoms/check-group/check-group.vue.js

@@ -0,0 +1,86 @@
+import { defineComponent as v, ref as h, computed as i, openBlock as u, createElementBlock as r, Fragment as k, renderList as b, withDirectives as g, createElementVNode as s, vModelCheckbox as V } from "vue";
+import { uniqueId as c } from "../../../utilities/helpers.js";
+const q = { class: "check-group" }, B = ["id", "name", "value", "disabled", "read-only", "required"], x = ["for", "innerHTML"], M = /* @__PURE__ */ v({
+  __name: "check-group",
+  props: {
+    modelValue: {
+      type: null,
+      default: () => []
+    },
+    options: {
+      type: Array,
+      required: !0
+    },
+    name: {
+      type: String,
+      default: () => c()
+    },
+    id: {
+      type: String,
+      default: () => c()
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    readOnly: {
+      type: Boolean,
+      default: !1
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(l, { emit: m }) {
+    const t = l, f = m;
+    h([]);
+    const n = i({
+      get() {
+        return t.modelValue;
+      },
+      set(e) {
+        f("update:modelValue", e);
+      }
+    }), y = i(() => t.options && t.options.map((e) => (e = typeof e == "string" ? {
+      text: e,
+      value: e
+    } : e, {
+      ...e,
+      active: t.modelValue && t.modelValue.includes(e.value)
+    })));
+    return (e, o) => (u(), r("div", q, [
+      (u(!0), r(k, null, b(y.value, (a, d) => (u(), r("div", {
+        key: d,
+        class: "form-check"
+      }, [
+        g(s("input", {
+          type: "checkbox",
+          "onUpdate:modelValue": o[0] || (o[0] = (p) => n.value = p),
+          id: `${l.id}-${d}`,
+          name: l.name,
+          class: "form-check-input",
+          value: a.value || a,
+          disabled: l.disabled,
+          "read-only": l.readOnly,
+          required: l.required
+        }, null, 8, B), [
+          [V, n.value]
+        ]),
+        s("label", {
+          class: "form-check-label",
+          for: `${l.id}-${d}`,
+          innerHTML: a.text
+        }, null, 8, x)
+      ]))), 128))
+    ]));
+  }
+});
+export {
+  M as default
+};

package/dist/components/atoms/check-group/check-group.vue3.js

@@ -0,0 +1,5 @@
+import o from "./check-group.vue.js";
+/* empty css                 */
+export {
+  o as default
+};