@avakhula/ui 0.1.22 → 0.1.23

package/dist/components/Form/Radio/Radio.js

@@ -0,0 +1,91 @@
+import s from "../../../helpers/generateUID.js";
+import { createElementBlock as o, openBlock as c, normalizeClass as n, createElementVNode as t, createCommentVNode as h, toDisplayString as m, pushScopeId as b, popScopeId as f } from "vue";
+import { _ } from "../../../chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+const k = {
+  name: "IbRadio",
+  props: {
+    modelValue: "",
+    label: String,
+    error: {
+      type: Boolean,
+      default: !1
+    },
+    name: {
+      type: String
+    },
+    id: {
+      type: String,
+      default() {
+        return s();
+      }
+    },
+    value: {
+      type: [String, Number],
+      required: !0
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  data() {
+    return {
+      uid: s()
+    };
+  },
+  mounted() {
+    this.checked = this.isChecked;
+  },
+  methods: {
+    checkHandler() {
+      this.$emit("update:modelValue", this.value);
+    }
+  },
+  computed: {
+    classes() {
+      return {
+        "ib-radio": !0,
+        "has-error": this.error,
+        "radio-filled": this.isChecked,
+        "radio-disabled": this.disabled
+      };
+    },
+    isChecked() {
+      return this.modelValue === this.value;
+    }
+  }
+}, p = (d) => (b("data-v-48bfd634"), d = d(), f(), d), g = ["for", "aria-checked"], y = ["name", "id", "value", "checked", "disabled"], v = /* @__PURE__ */ p(() => /* @__PURE__ */ t("span", { class: "ib-radio-input" }, null, -1)), C = {
+  key: 0,
+  class: "ib-radio-label"
+};
+function S(d, l, e, I, V, a) {
+  var i, r;
+  return c(), o("label", {
+    role: "radio",
+    class: n(a.classes),
+    for: e.id,
+    "aria-checked": a.isChecked
+  }, [
+    t("input", {
+      type: "radio",
+      name: e.name,
+      id: e.id,
+      value: e.value,
+      checked: a.isChecked,
+      disabled: e.disabled,
+      ref: "radio",
+      onChange: l[0] || (l[0] = (...u) => a.checkHandler && a.checkHandler(...u))
+    }, null, 40, y),
+    t("span", {
+      class: n(["ib-radio-body", { "without-text": !((i = e.label) != null && i.length) }])
+    }, [
+      v,
+      (r = e.label) != null && r.length ? (c(), o("span", C, m(e.label), 1)) : h("", !0)
+    ], 2)
+  ], 10, g);
+}
+const N = /* @__PURE__ */ _(k, [["render", S], ["__scopeId", "data-v-48bfd634"]]);
+export {
+  N as default
+};

package/dist/components/Form/TextEditor/TextEditor.js

@@ -0,0 +1,422 @@
+import { Q as w, a as F } from "../../../chunks/vue-quill.esm-bundler-FvTqp_xR.js";
+import H from "../../IconButton/IconButton.js";
+import V from "../../Alert/Alert.js";
+import D from "../CharactersCount.js";
+import R from "./Toolbar.js";
+import { stripHtml as U } from "../../../helpers/stripHtml.js";
+import { g as I } from "../../../chunks/_commonjsHelpers-DaMA6jEr.js";
+import { setupTextEditor as z } from "./setupTextEditor.js";
+import { resolveComponent as E, createElementBlock as W, openBlock as S, normalizeClass as k, createBlock as C, createCommentVNode as T, withDirectives as G, createElementVNode as M, withCtx as B, createTextVNode as j, toDisplayString as A, createVNode as q, vShow as J } from "vue";
+import { _ as K } from "../../../chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+var L = { exports: {} }, X = L.exports, N;
+function Y() {
+  return N || (N = 1, (function(n, g) {
+    (function(c, l) {
+      n.exports = l();
+    })(typeof self < "u" ? self : X, function() {
+      return (
+        /******/
+        (function(a) {
+          var c = {};
+          function l(t) {
+            if (c[t])
+              return c[t].exports;
+            var i = c[t] = {
+              /******/
+              i: t,
+              /******/
+              l: !1,
+              /******/
+              exports: {}
+              /******/
+            };
+            return a[t].call(i.exports, i, i.exports, l), i.l = !0, i.exports;
+          }
+          return l.m = a, l.c = c, l.d = function(t, i, b) {
+            l.o(t, i) || Object.defineProperty(t, i, {
+              /******/
+              configurable: !1,
+              /******/
+              enumerable: !0,
+              /******/
+              get: b
+              /******/
+            });
+          }, l.n = function(t) {
+            var i = t && t.__esModule ? (
+              /******/
+              function() {
+                return t.default;
+              }
+            ) : (
+              /******/
+              function() {
+                return t;
+              }
+            );
+            return l.d(i, "a", i), i;
+          }, l.o = function(t, i) {
+            return Object.prototype.hasOwnProperty.call(t, i);
+          }, l.p = "", l(l.s = 0);
+        })([
+          /* 0 */
+          /***/
+          (function(a, c, l) {
+            function t(f, y) {
+              if (!(f instanceof y))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            Object.defineProperty(c, "__esModule", { value: !0 });
+            var i = l(1);
+            function b(f, y) {
+              var _ = f.import("parchment"), o = i.default(f);
+              o.className = y && y.className || "ql-placeholder-content", f.register(o);
+              var e = function h(p, r) {
+                var d = this;
+                t(this, h), this.quill = p, this.onTextChange = function(u, s, m) {
+                  if (m === f.sources.USER) {
+                    var v = d.quill.getContents(), x = v.diff(s), O = x.ops.filter(function(P) {
+                      return P.insert && P.insert.placeholder && P.insert.placeholder.required;
+                    }).length;
+                    O && d.quill.updateContents(x, f.sources.SILENT);
+                  }
+                }, this.onClick = function(u) {
+                  var s = _.find(u.target.parentNode);
+                  if (s instanceof o) {
+                    var m = d.quill.getIndex(s);
+                    d.quill.setSelection(m, s.length(), f.sources.USER);
+                  }
+                }, this.toolbarHandler = function(u) {
+                  var s = d.quill.getSelection(), m = d.placeholders.filter(function(v) {
+                    return v.id === u;
+                  })[0];
+                  if (!m) throw new Error("Missing placeholder for " + u);
+                  d.quill.deleteText(s.index, s.length), d.quill.insertEmbed(s.index, "placeholder", m, f.sources.USER), d.quill.setSelection(s.index + 1, 0);
+                }, this.placeholders = r.placeholders, o.delimiters = r.delimiters || ["{", "}"], this.quill.getModule("toolbar").addHandler("placeholder", this.toolbarHandler), this.quill.root.addEventListener("click", this.onClick), this.quill.on("text-change", this.onTextChange);
+              };
+              return e;
+            }
+            c.default = b;
+          }),
+          /* 1 */
+          /***/
+          (function(a, c, l) {
+            var t = /* @__PURE__ */ (function() {
+              function o(e, h) {
+                for (var p = 0; p < h.length; p++) {
+                  var r = h[p];
+                  r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+                }
+              }
+              return function(e, h, p) {
+                return h && o(e.prototype, h), p && o(e, p), e;
+              };
+            })(), i = function o(e, h, p) {
+              e === null && (e = Function.prototype);
+              var r = Object.getOwnPropertyDescriptor(e, h);
+              if (r === void 0) {
+                var d = Object.getPrototypeOf(e);
+                return d === null ? void 0 : o(d, h, p);
+              } else {
+                if ("value" in r)
+                  return r.value;
+                var u = r.get;
+                return u === void 0 ? void 0 : u.call(p);
+              }
+            };
+            function b(o, e) {
+              if (!(o instanceof e))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function f(o, e) {
+              if (!o)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return e && (typeof e == "object" || typeof e == "function") ? e : o;
+            }
+            function y(o, e) {
+              if (typeof e != "function" && e !== null)
+                throw new TypeError("Super expression must either be null or a function, not " + typeof e);
+              o.prototype = Object.create(e && e.prototype, { constructor: { value: o, enumerable: !1, writable: !0, configurable: !0 } }), e && (Object.setPrototypeOf ? Object.setPrototypeOf(o, e) : o.__proto__ = e);
+            }
+            Object.defineProperty(c, "__esModule", { value: !0 });
+            function _(o) {
+              var e = o.import("blots/embed"), h = (function(p) {
+                y(r, p);
+                function r() {
+                  return b(this, r), f(this, (r.__proto__ || Object.getPrototypeOf(r)).apply(this, arguments));
+                }
+                return t(r, [{
+                  key: "length",
+                  value: function() {
+                    return 1;
+                  }
+                }, {
+                  key: "deleteAt",
+                  value: function(u, s) {
+                    this.domNode.dataset.required || i(r.prototype.__proto__ || Object.getPrototypeOf(r.prototype), "deleteAt", this).call(this, u, s);
+                  }
+                }], [{
+                  key: "create",
+                  value: function(u) {
+                    var s = i(r.__proto__ || Object.getPrototypeOf(r), "create", this).call(this, u);
+                    u.required && s.setAttribute("data-required", "true"), s.setAttribute("data-id", u.id), s.setAttribute("data-label", u.label), s.setAttribute("spellcheck", "false");
+                    var m = r.delimiters, v = typeof m == "string" ? "" + m + u.label + m : "" + m[0] + u.label + (m[1] || m[0]), x = document.createTextNode(v);
+                    if (o.version < "1.3") {
+                      var O = document.createElement("span");
+                      O.setAttribute("contenteditable", "false"), O.appendChild(x), s.appendChild(O);
+                    } else
+                      s.appendChild(x);
+                    return s;
+                  }
+                }, {
+                  key: "value",
+                  value: function(u) {
+                    return u.dataset;
+                  }
+                }]), r;
+              })(e);
+              return h.blotName = "placeholder", h.tagName = "span", h;
+            }
+            c.default = _;
+          })
+          /******/
+        ])
+      );
+    });
+  })(L)), L.exports;
+}
+var Z = Y();
+const Q = /* @__PURE__ */ I(Z);
+w.register("modules/placeholder", Q(w, {
+  className: "ql-placeholder-content"
+}));
+w.debug("error");
+z();
+const $ = {
+  name: "IbTextEditor",
+  props: {
+    name: {
+      type: String,
+      required: !0
+    },
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    placeholders: {
+      type: Array,
+      default: () => []
+    },
+    modelValue: {
+      type: String
+    },
+    content: {
+      type: String,
+      default: ""
+    },
+    readOnly: {
+      type: Boolean,
+      default: !1
+    },
+    enable: {
+      type: Boolean,
+      default: !0
+    },
+    modules: {
+      type: [Object, Array],
+      default: () => {
+      }
+    },
+    options: {
+      type: Object,
+      default: () => {
+      }
+    },
+    characterLimit: {
+      type: [String, Number],
+      default: null
+    },
+    error: {
+      type: Boolean,
+      default: !1
+    },
+    disable: {
+      type: Boolean,
+      default: !1
+    },
+    errorMessage: {
+      type: String,
+      default: ""
+    },
+    characterLimitErrorMessage: {
+      type: String,
+      default: ""
+    },
+    hiddenElements: {
+      type: Array,
+      default: () => ["font-size", "image"]
+    }
+  },
+  emits: ["onOverLimitHandler", "update:modelValue", "change", "blur"],
+  mounted() {
+    const n = this.$refs.wrapper.querySelector("input[data-link]");
+    n.dataset.link = "Enter Link", this.updateCharacterLength();
+  },
+  data() {
+    return {
+      data: this.modelValue ? this.modelValue : this.content,
+      characterLength: 0,
+      isFocus: !1
+    };
+  },
+  watch: {
+    content(n) {
+      this.data = n;
+    },
+    data(n) {
+      const g = this.cleanPlaceholderSpans(n);
+      this.$emit("update:modelValue", g);
+    },
+    characterOverLimit(n) {
+      this.$emit("onOverLimitHandler", n);
+    }
+  },
+  methods: {
+    onChange() {
+      let n = this.cleanPlaceholderSpans(this.data);
+      this.data = this.patchListStylePosition(n), this.updateCharacterLength(), this.$emit("change", this.data);
+    },
+    onBlur(n) {
+      this.$emit("blur", this.cleanPlaceholderSpans(this.data), n), this.isFocus = !1;
+    },
+    onFocus() {
+      this.isFocus = !0;
+    },
+    updateCharacterLength() {
+      this.characterLength = U(this.data).length;
+    },
+    cleanPlaceholderSpans(n) {
+      if (!n) return n;
+      let g;
+      do
+        g = n, n = n.replace(/<span contenteditable="false">([\s\S]*?)<\/span>/g, (a, c) => c.replace(/[\u200B-\u200F\uFEFF]/g, ""));
+      while (g !== n);
+      return n;
+    },
+    patchListStylePosition(n) {
+      const g = document.createElement("div");
+      return g.innerHTML = n, g.querySelectorAll('ul[style*="text-align"], ol[style*="text-align"], li[style*="text-align"]').forEach((a) => {
+        const c = a.getAttribute("style") ?? "";
+        if (!/list-style-position\s*:\s*inside/i.test(c)) {
+          const l = (c.trim().endsWith(";") || c.trim() === "" ? c : c + ";") + " list-style-position: inside;";
+          a.setAttribute("style", l);
+        }
+      }), g.innerHTML;
+    }
+  },
+  computed: {
+    config() {
+      const n = {
+        placeholder: this.data.length ? "" : this.placeholder,
+        readOnly: this.readOnly ? this.readOnly : this.disable,
+        enable: this.enable,
+        modules: {
+          toolbar: {
+            container: "#toolbar",
+            handlers: { image: this.imageButtonClickHandler }
+          },
+          placeholder: {
+            delimiters: ["{{", "}}"],
+            placeholders: this.placeholders
+          }
+        }
+      };
+      return Object.assign(n, this.options);
+    },
+    characterOverLimit() {
+      return !!this.characterLimit && this.characterLength > this.characterLimit;
+    },
+    uid() {
+      return Math.random().toString(36).substr(2, 9);
+    }
+  },
+  components: {
+    QuillEditor: F,
+    IbIconButton: H,
+    IbAlert: V,
+    IbCharacterCount: D,
+    Toolbar: R
+  }
+}, ee = ["name", "disabled", "value"], te = {
+  class: "ib-text-editor",
+  ref: "wrapper"
+};
+function re(n, g, a, c, l, t) {
+  const i = E("ib-character-count"), b = E("ib-alert"), f = E("QuillEditor"), y = E("Toolbar");
+  return S(), W("div", {
+    class: k(["textarea-wrapper", {
+      error: t.characterOverLimit || a.error || a.errorMessage.length,
+      focus: l.isFocus,
+      disable: a.disable
+    }])
+  }, [
+    a.characterLimit ? (S(), C(i, {
+      key: 0,
+      "character-limit": a.characterLimit,
+      "character-length": l.characterLength
+    }, null, 8, ["character-limit", "character-length"])) : T("", !0),
+    a.errorMessage.length ? (S(), C(b, {
+      key: 1,
+      class: "error-message"
+    }, {
+      default: B(() => [
+        j(A(a.errorMessage), 1)
+      ]),
+      _: 1
+    })) : T("", !0),
+    G(q(b, { class: "error-message" }, {
+      default: B(() => [
+        j(A(a.characterLimitErrorMessage), 1)
+      ]),
+      _: 1
+    }, 512), [
+      [J, a.characterLimitErrorMessage.length && t.characterOverLimit]
+    ]),
+    M("input", {
+      name: a.name,
+      type: "hidden",
+      disabled: a.disable,
+      value: l.data
+    }, null, 8, ee),
+    M("div", {
+      class: k(["ib-text-editor-wrapper", { disable: a.disable }])
+    }, [
+      M("div", te, [
+        q(f, {
+          "aria-label": "text-editor",
+          onTextChange: t.onChange,
+          onBlur: t.onBlur,
+          onFocus: t.onFocus,
+          ref: "quill",
+          content: l.data,
+          "onUpdate:content": g[0] || (g[0] = (_) => l.data = _),
+          contentType: "html",
+          options: t.config,
+          modules: a.modules
+        }, null, 8, ["onTextChange", "onBlur", "onFocus", "content", "options", "modules"])
+      ], 512),
+      q(y, {
+        id: "toolbar",
+        class: "toolbar",
+        ref: "toolbar",
+        placeholders: a.placeholders,
+        uid: t.uid,
+        "hidden-elements": a.hiddenElements
+      }, null, 8, ["placeholders", "uid", "hidden-elements"])
+    ], 2)
+  ], 2);
+}
+const fe = /* @__PURE__ */ K($, [["render", re], ["__scopeId", "data-v-6f456437"]]);
+export {
+  fe as default
+};