ablok-components 0.3.57 → 0.3.59

package/dist/components/atoms/custom-html/custom-html.vue.js

@@ -0,0 +1,26 @@
+import { defineComponent as o, ref as c, onMounted as s, openBlock as l, createElementBlock as r, renderSlot as m, createElementVNode as u, createCommentVNode as a } from "vue";
+const d = {
+  key: 0,
+  class: "custom-html"
+}, i = ["innerHTML"], p = /* @__PURE__ */ o({
+  __name: "custom-html",
+  props: {
+    content: {}
+  },
+  setup(t) {
+    const e = c(!1);
+    return s(() => {
+      window !== void 0 && (e.value = !0);
+    }), (n, _) => e.value ? (l(), r("div", d, [
+      m(n.$slots, "default", {}, () => [
+        u("div", {
+          class: "custom-html__content",
+          innerHTML: t.content
+        }, null, 8, i)
+      ])
+    ])) : a("", !0);
+  }
+});
+export {
+  p as default
+};

package/dist/components/atoms/custom-html/custom-html.vue2.js

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

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

@@ -0,0 +1,84 @@
+import { defineComponent as r, computed as c, openBlock as s, createElementBlock as m, withDirectives as f, createElementVNode as d, vModelCheckbox as p, unref as y } from "vue";
+import { sanitizeHtml as b } from "../../../composables/useSanitize.js";
+const h = { class: "form-check input input--checkbox" }, k = ["value", "id", "name", "required", "disabled", "true-value", "false-value"], v = ["for", "innerHTML"], g = /* @__PURE__ */ r({
+  __name: "input-checkbox",
+  props: {
+    id: {
+      type: String
+    },
+    name: {
+      type: String
+    },
+    label: {
+      type: String
+    },
+    error: {
+      type: String
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    readOnly: {
+      type: Boolean,
+      default: !1
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    modelValue: {
+      type: [Boolean, Array]
+    },
+    value: {
+      type: [String, Object]
+    },
+    checked: {
+      type: Boolean
+    },
+    trueValue: {
+      type: null,
+      default: !0
+    },
+    falseValue: {
+      type: null,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue", "update:checked"],
+  setup(e, { emit: i }) {
+    const t = e, a = i, u = c({
+      get() {
+        return t.modelValue || t.checked;
+      },
+      set(l) {
+        a("update:checked", l), a("update:modelValue", l);
+      }
+    });
+    return (l, n) => (s(), m("div", h, [
+      f(d("input", {
+        ref: "input",
+        "onUpdate:modelValue": n[0] || (n[0] = (o) => u.value = o),
+        value: e.value,
+        id: e.id,
+        name: e.name,
+        type: "checkbox",
+        required: e.required,
+        disabled: e.disabled,
+        class: "form-check-input",
+        "true-value": e.trueValue,
+        "false-value": e.falseValue
+      }, null, 8, k), [
+        [p, u.value]
+      ]),
+      d("label", {
+        class: "input__label form-check-label",
+        for: e.id,
+        innerHTML: y(b)(e.label || "")
+      }, null, 8, v)
+    ]));
+  }
+});
+export {
+  g as default
+};

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

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

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

@@ -0,0 +1,99 @@
+import { defineComponent as c, computed as f, openBlock as i, createElementBlock as d, normalizeClass as y, createElementVNode as r, renderSlot as a, withDirectives as g, vModelText as S, unref as b, createCommentVNode as V } from "vue";
+import { uniqueId as u } from "../../../utilities/helpers.js";
+import { sanitizeHtml as h } from "../../../composables/useSanitize.js";
+const v = { class: "input-group input__input-group" }, D = ["id", "name", "placeholder", "pattern", "disabled", "read-only", "required", "aria-label"], $ = ["for", "innerHTML"], O = /* @__PURE__ */ c({
+  __name: "input-datetime",
+  props: {
+    modelValue: {
+      type: [String, Number, Boolean, Date],
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "text"
+    },
+    name: {
+      type: String,
+      default: () => u()
+    },
+    id: {
+      type: String,
+      default: () => u()
+    },
+    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
+    },
+    pattern: {
+      type: String,
+      default: null
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: s }) {
+    const n = e, m = s, o = f({
+      get() {
+        const t = n.modelValue && /* @__PURE__ */ new Date(`${n.modelValue}Z`), l = t && new Date(t.getTime() + (/* @__PURE__ */ new Date()).getTimezoneOffset() * -60 * 1e3).toISOString();
+        return l && l.replace("Z", "");
+      },
+      set(t) {
+        const l = t && new Date(t);
+        t = l && l.toISOString(), m("update:modelValue", t && t.replace("Z", ""));
+      }
+    });
+    return (t, l) => (i(), d("div", {
+      class: y(["input", `input--${e.type}`])
+    }, [
+      r("div", v, [
+        a(t.$slots, "input-prepend", { slotScope: "props" }),
+        g(r("input", {
+          "onUpdate:modelValue": l[0] || (l[0] = (p) => o.value = p),
+          type: "datetime-local",
+          id: e.id,
+          name: e.name,
+          placeholder: e.placeholder,
+          pattern: e.pattern,
+          disabled: e.disabled,
+          "read-only": e.readOnly,
+          required: e.required,
+          class: "form-control",
+          "aria-label": e.label
+        }, null, 8, D), [
+          [S, o.value]
+        ]),
+        a(t.$slots, "input-append", { slotScope: "props" })
+      ]),
+      a(t.$slots, "label", {}, () => [
+        e.label ? (i(), d("label", {
+          key: 0,
+          for: e.id,
+          class: "input__label",
+          innerHTML: b(h)(`${e.label}${e.required ? " *" : ""}`)
+        }, null, 8, $)) : V("", !0)
+      ])
+    ], 2));
+  }
+});
+export {
+  O as default
+};

package/dist/components/atoms/input-datetime/input-datetime.vue2.js

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

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

@@ -0,0 +1,130 @@
+import { defineComponent as b, ref as y, reactive as h, computed as g, watch as s, openBlock as S, createElementBlock as z, normalizeClass as $, createElementVNode as l, renderSlot as d, toDisplayString as v, unref as B } from "vue";
+import { uniqueId as r } from "../../../utilities/helpers.js";
+import { sanitizeHtml as F } from "../../../composables/useSanitize.js";
+const V = ["id", "name", "multiple", "accept", "disabled"], C = { class: "input__input-group input-group" }, k = ["value", "id", "name", "disabled"], q = ["for", "disabled"], w = { class: "btn btn-outline-contrast" }, x = ["for"], E = ["innerHTML"], L = /* @__PURE__ */ b({
+  __name: "input-file",
+  props: {
+    modelValue: {
+      type: Array,
+      default: []
+    },
+    name: {
+      type: String,
+      default: () => r()
+    },
+    id: {
+      type: String,
+      default: () => r()
+    },
+    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
+    },
+    pattern: {
+      type: String,
+      default: null
+    },
+    multiple: {
+      type: Boolean,
+      default: !1
+    },
+    accept: {
+      type: String
+    },
+    maxFileSize: {
+      type: Number,
+      default: 0
+    },
+    dropzone: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: m }) {
+    const i = e, f = m;
+    function p(t) {
+      const n = t.target && t.target.files;
+      n && (a.splice(0, a.length), Array.from(n).forEach((o) => {
+        if (i.maxFileSize && o.size > i.maxFileSize) {
+          console.warn(`File ${o.name} exceeds the ${i.maxFileSize} bytes size limit and will not be added.`);
+          return;
+        }
+        a.push(o);
+      }));
+    }
+    const u = y(), a = h([]), c = g(() => a && a.map((t) => t.name));
+    return s(() => i.modelValue, (t, n) => {
+      t.length === 0 && (u.value.value = null);
+    }, { deep: !0 }), s(() => a, (t, n) => {
+      f("update:modelValue", t);
+    }, { deep: !0 }), (t, n) => (S(), z("div", {
+      class: $(["input input-file", "input-file--primary"])
+    }, [
+      l("input", {
+        ref_key: "input",
+        ref: u,
+        type: "file",
+        id: e.id,
+        name: e.name,
+        class: "d-none",
+        onChange: p,
+        multiple: e.multiple,
+        accept: e.accept,
+        disabled: e.disabled
+      }, null, 40, V),
+      l("div", C, [
+        d(t.$slots, "input-prepend"),
+        l("input", {
+          type: "text",
+          value: c.value,
+          id: e.id,
+          name: e.name,
+          class: "form-control",
+          disabled: e.disabled
+        }, null, 8, k),
+        d(t.$slots, "input-append", {}, () => [
+          l("label", {
+            for: e.id,
+            disabled: e.disabled
+          }, [
+            d(t.$slots, "button", {}, () => [
+              l("span", w, v(t.$t("common.selectFile")), 1)
+            ])
+          ], 8, q)
+        ])
+      ]),
+      l("label", { for: e.id }, [
+        d(t.$slots, "label", {}, () => [
+          l("span", {
+            class: "input__label",
+            innerHTML: B(F)(`${e.label}${e.required ? " *" : ""}`)
+          }, null, 8, E)
+        ])
+      ], 8, x)
+    ]));
+  }
+});
+export {
+  L as default
+};

package/dist/components/atoms/input-file/input-file.vue2.js

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

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

@@ -0,0 +1,149 @@
+import { defineComponent as k, ref as m, computed as I, watch as h, openBlock as r, createElementBlock as p, normalizeClass as w, createElementVNode as q, createBlock as D, Fragment as P, renderList as T, withDirectives as x, vModelText as E } from "vue";
+import { uniqueId as y } from "../../../utilities/helpers.js";
+import K from "../input-password/input-password.vue.js";
+const N = { class: "input-group input__input-group" }, O = ["onUpdate:modelValue", "disabled", "readonly", "onPaste", "onInput", "onKeydown"], j = /* @__PURE__ */ k({
+  __name: "input-passcode",
+  props: {
+    modelValue: {
+      type: [String, Number, Boolean, Date],
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "text"
+    },
+    name: {
+      type: String,
+      default: () => y()
+    },
+    id: {
+      type: String,
+      default: () => y()
+    },
+    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
+    },
+    maxlength: {
+      type: Number
+    },
+    pattern: {
+      type: String,
+      default: null
+    },
+    role: {
+      type: String,
+      default: "presentation"
+    },
+    autocomplete: {
+      type: String,
+      default: "off"
+    },
+    passcodeMatch: {
+      type: String,
+      default: ""
+    },
+    confirm: {
+      type: Boolean,
+      default: !1
+    },
+    splitInput: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(o, { emit: g }) {
+    const d = m([]), u = m([]), n = o, c = g, i = I({
+      get() {
+        return n.modelValue;
+      },
+      set(a) {
+        n.passcodeMatch === a || !n.passcodeMatch ? c("update:modelValue", a) : c("update:modelValue", "");
+      }
+    });
+    h(() => n.modelValue, (a) => {
+      const e = a?.toString() || "";
+      for (u.value = e.split("").slice(0, n.passcodeMatch?.length || 6); u.value.length < (n.passcodeMatch?.length || 6); )
+        u.value.push("");
+    }, { immediate: !0 }), h(() => u.value, (a) => {
+      const e = a.join("");
+      n.passcodeMatch === e || !n.passcodeMatch ? c("update:modelValue", e) : c("update:modelValue", "");
+    }, { deep: !0 });
+    const v = (a, e) => {
+      a.preventDefault();
+      const s = a.clipboardData?.getData("text") || "";
+      console.log("Paste detected:", s);
+      const t = s.split(""), l = n.passcodeMatch?.length || 6;
+      t.forEach((S, B) => {
+        const f = e + B;
+        f < l && (u.value[f] = S);
+      });
+      const M = Math.min(e + t.length, l - 1);
+      setTimeout(() => d.value[M]?.focus(), 0);
+    }, b = (a, e) => {
+      n.passcodeMatch?.length, a.key === "Backspace" && !u.value[e] && e > 0 && d.value[e - 1]?.focus();
+    }, V = (a, e) => {
+      let t = a.target.value;
+      t.length > 1 && (t = t.slice(-1)), u.value[e] = t;
+      const l = n.passcodeMatch?.length || 6;
+      t && e < l - 1 && setTimeout(() => d.value[e + 1]?.focus(), 0);
+    };
+    return (a, e) => (r(), p("div", {
+      class: w(["input", "input-passcode"])
+    }, [
+      q("div", N, [
+        o.splitInput ? (r(!0), p(P, { key: 1 }, T(o.passcodeMatch, (s, t) => x((r(), p("input", {
+          key: t,
+          "onUpdate:modelValue": (l) => u.value[t] = l,
+          type: "text",
+          ref_for: !0,
+          ref: (l) => d.value[t] = l,
+          maxlength: 1,
+          disabled: o.disabled,
+          readonly: o.readOnly,
+          onPaste: (l) => v(l, t),
+          onInput: (l) => V(l, t),
+          onKeydown: (l) => b(l, t),
+          size: "1",
+          class: "form-control text-center"
+        }, null, 40, O)), [
+          [E, u.value[t]]
+        ])), 128)) : (r(), D(K, {
+          key: 0,
+          modelValue: i.value,
+          "onUpdate:modelValue": e[0] || (e[0] = (s) => i.value = s),
+          type: o.type,
+          placeholder: o.placeholder,
+          disabled: o.disabled,
+          readonly: o.readOnly,
+          required: o.required,
+          label: o.label
+        }, null, 8, ["modelValue", "type", "placeholder", "disabled", "readonly", "required", "label"]))
+      ])
+    ]));
+  }
+});
+export {
+  j as default
+};

package/dist/components/atoms/input-passcode/input-passcode.vue2.js

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

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

@@ -0,0 +1,118 @@
+import { defineComponent as m, computed as f, openBlock as n, createElementBlock as c, normalizeClass as y, createElementVNode as g, createVNode as S, withCtx as p, renderSlot as u, createBlock as V, createCommentVNode as b } from "vue";
+import { uniqueId as i } from "../../../utilities/helpers.js";
+import w from "../base-input/base-input.vue.js";
+/* empty css                            */
+import B from "../svg-icon/svg-icon.vue.js";
+/* empty css                        */
+const h = { class: "input-group input__input-group" }, x = /* @__PURE__ */ m({
+  __name: "input-password",
+  props: {
+    modelValue: {
+      type: [String, Number, Boolean, Date],
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "text"
+    },
+    name: {
+      type: String,
+      default: () => i()
+    },
+    id: {
+      type: String,
+      default: () => i()
+    },
+    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
+    },
+    maxlength: {
+      type: Number
+    },
+    pattern: {
+      type: String,
+      default: null
+    },
+    role: {
+      type: String,
+      default: "presentation"
+    },
+    autocomplete: {
+      type: String,
+      default: "off"
+    },
+    password: {
+      type: String,
+      default: ""
+    },
+    confirm: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: s }) {
+    const l = e, o = s, d = f({
+      get() {
+        return l.modelValue;
+      },
+      set(t) {
+        l.password === t || !l.password ? o("update:modelValue", t) : o("update:modelValue", "");
+      }
+    });
+    return (t, r) => (n(), c("div", {
+      class: y(["input", "input-password"])
+    }, [
+      g("div", h, [
+        S(w, {
+          modelValue: d.value,
+          "onUpdate:modelValue": r[0] || (r[0] = (a) => d.value = a),
+          type: "password",
+          placeholder: e.placeholder,
+          disabled: e.disabled,
+          readonly: e.readOnly,
+          required: e.required,
+          label: e.label
+        }, {
+          "input-prepend": p((a) => [
+            u(t.$slots, "input-prepend", { slotScope: "props" })
+          ]),
+          "input-append": p((a) => [
+            u(t.$slots, "input-append", { slotScope: "props" }, () => [
+              e.confirm && e.modelValue === e.password ? (n(), V(B, {
+                key: 0,
+                symbol: "check",
+                class: "ms-2"
+              })) : b("", !0)
+            ])
+          ]),
+          _: 3
+        }, 8, ["modelValue", "placeholder", "disabled", "readonly", "required", "label"])
+      ])
+    ]));
+  }
+});
+export {
+  x as default
+};

package/dist/components/atoms/input-password/input-password.vue2.js

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