@cling-se/widget 0.14.4 → 0.14.5

package/dist/mapFormMixin-ETYhBLl2.js

@@ -0,0 +1,72 @@
+import { b as r } from "./main-B9t0ybqW.js";
+const f = (a = [], { event: o = "input", type: c = void 0, useEmit: d = !0, setFnName: l } = {}) => ({
+  inheritAttrs: !1,
+  props: {
+    _document: {
+      type: Object,
+      default: () => ({})
+    },
+    _value: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  inject: {
+    viewSettings: {
+      default: () => ({
+        canEdit: !1,
+        isForm: !1,
+        setFormValue: null,
+        removeFormValue: null,
+        isPublicForm: !1
+      })
+    },
+    containerType: {
+      default: () => ({})
+    }
+  },
+  computed: {
+    canEdit() {
+      return r(this, "viewSettings.canEdit");
+    },
+    device() {
+      return r(this, "containerType.device", "");
+    },
+    isForm() {
+      return r(this, "viewSettings.isForm");
+    },
+    ...a.reduce((i, e) => {
+      const t = e, s = {
+        get() {
+          return this._value ? r(this._document, (this._value || {})[e]) : r(this.$attrs, e);
+        },
+        set(u) {
+          this.setField({ field: e, value: u, type: c });
+        }
+      };
+      return i[t] = s, i;
+    }, {})
+  },
+  methods: {
+    // Setter method exposed to host component, in case extra setter options are needed
+    // Providing either 'key' or 'field' optional, but one required
+    // key > field
+    // 'field' refers to name of computed field registered for the mixin
+    setField({ key: i, field: e, value: t, options: s, type: u }) {
+      const n = i || (this._value || {})[e];
+      if (!n)
+        return;
+      const m = l ? this[l] : this.viewSettings.setFormValue;
+      !d && typeof m == "function" ? m({ key: n, value: t, options: s }) : o ? (u === "number" && Number.isNaN(parseFloat(t)) && (t = null), this.$emit(o, { key: n, value: t, options: s })) : this.$emit({ key: n, value: t, options: s });
+    },
+    // Forward of document remove method
+    // Note: does not yet support emit option like the setter
+    removeField(i) {
+      var e, t;
+      (t = (e = this.viewSettings) == null ? void 0 : e.removeFormValue) == null || t.call(e, i);
+    }
+  }
+});
+export {
+  f as m
+};

package/dist/omit-DtTfKAed.js

@@ -0,0 +1,31 @@
+import { W as l, _ as o, X as i, Y as _, k as u, Z as f, $ as v, a0 as c, a1 as m, a2 as O, a3 as g } from "./main-B9t0ybqW.js";
+var C = l;
+function L(t) {
+  return C(t) ? void 0 : t;
+}
+var b = L, F = o;
+function A(t) {
+  var e = t == null ? 0 : t.length;
+  return e ? F(t, 1) : [];
+}
+var E = A, P = E, R = i, $ = _;
+function d(t) {
+  return $(R(t, void 0, P), t + "");
+}
+var y = d, S = f, D = O, G = v, M = g, N = c, T = b, h = y, j = m, p = 1, x = 2, I = 4, K = h(function(t, e) {
+  var a = {};
+  if (t == null)
+    return a;
+  var s = !1;
+  e = S(e, function(n) {
+    return n = M(n, t), s || (s = n.length > 1), n;
+  }), N(t, j(t), a), s && (a = D(a, p | x | I, T));
+  for (var r = e.length; r--; )
+    G(a, e[r]);
+  return a;
+}), U = K;
+const k = /* @__PURE__ */ u(U);
+export {
+  y as _,
+  k as o
+};

package/dist/publicSenderState-DD1lN9CR.js

@@ -0,0 +1,21 @@
+import { I as a, V as c } from "./main-B9t0ybqW.js";
+const e = JSON.parse(a.getItem("publicSender")), s = c.observable({
+  company: {
+    name: "",
+    LogotypePublicId: null,
+    ...e ? e.company : {}
+  },
+  user: {
+    email: "",
+    firstname: "",
+    lastname: "",
+    cellphone: "",
+    ...e ? e.user : {}
+  }
+}), r = ({ company: n, user: t }) => {
+  Object.assign(s.company, n), Object.assign(s.user, t), a.setItem("publicSender", JSON.stringify(s));
+};
+export {
+  r as a,
+  s
+};

package/dist/splitpanes-BHUVsCZF.js

@@ -0,0 +1,382 @@
+var _ = Object.defineProperty, M = Object.defineProperties, g = Object.getOwnPropertyDescriptors, u = Object.getOwnPropertySymbols, v = Object.prototype.hasOwnProperty, P = Object.prototype.propertyIsEnumerable, m = (e, t, i) => t in e ? _(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i, y = (e, t) => {
+  for (var i in t || (t = {}))
+    v.call(t, i) && m(e, i, t[i]);
+  if (u)
+    for (var i of u(t))
+      P.call(t, i) && m(e, i, t[i]);
+  return e;
+}, C = (e, t) => M(e, g(t)), w = (e, t) => {
+  var i = {};
+  for (var s in e)
+    v.call(e, s) && t.indexOf(s) < 0 && (i[s] = e[s]);
+  if (e != null && u)
+    for (var s of u(e))
+      t.indexOf(s) < 0 && P.call(e, s) && (i[s] = e[s]);
+  return i;
+};
+function S(e, t, i, s, n, a, r, h) {
+  var o = typeof e == "function" ? e.options : e;
+  t && (o.render = t, o.staticRenderFns = i, o._compiled = !0);
+  var l;
+  if (n && (l = n), l)
+    if (o.functional) {
+      o._injectStyles = l;
+      var c = o.render;
+      o.render = function(x, p) {
+        return l.call(p), c(x, p);
+      };
+    } else {
+      var d = o.beforeCreate;
+      o.beforeCreate = d ? [].concat(d, l) : [l];
+    }
+  return {
+    exports: e,
+    options: o
+  };
+}
+const b = {
+  name: "splitpanes",
+  props: {
+    horizontal: { type: Boolean },
+    pushOtherPanes: { type: Boolean, default: !0 },
+    dblClickSplitter: { type: Boolean, default: !0 },
+    rtl: { type: Boolean, default: !1 },
+    firstSplitter: { type: Boolean }
+  },
+  provide() {
+    return {
+      requestUpdate: this.requestUpdate,
+      onPaneAdd: this.onPaneAdd,
+      onPaneRemove: this.onPaneRemove,
+      onPaneClick: this.onPaneClick
+    };
+  },
+  data: () => ({
+    container: null,
+    ready: !1,
+    panes: [],
+    touch: {
+      mouseDown: !1,
+      dragging: !1,
+      activeSplitter: null
+    },
+    splitterTaps: {
+      splitter: null,
+      timeoutId: null
+    }
+  }),
+  computed: {
+    panesCount() {
+      return this.panes.length;
+    },
+    indexedPanes() {
+      return this.panes.reduce((e, t) => (e[t.id] = t) && e, {});
+    }
+  },
+  methods: {
+    updatePaneComponents() {
+      this.panes.forEach((e) => {
+        e.update && e.update({
+          [this.horizontal ? "height" : "width"]: `${this.indexedPanes[e.id].size}%`
+        });
+      });
+    },
+    bindEvents() {
+      document.addEventListener("mousemove", this.onMouseMove, { passive: !1 }), document.addEventListener("mouseup", this.onMouseUp), "ontouchstart" in window && (document.addEventListener("touchmove", this.onMouseMove, { passive: !1 }), document.addEventListener("touchend", this.onMouseUp));
+    },
+    unbindEvents() {
+      document.removeEventListener("mousemove", this.onMouseMove, { passive: !1 }), document.removeEventListener("mouseup", this.onMouseUp), "ontouchstart" in window && (document.removeEventListener("touchmove", this.onMouseMove, { passive: !1 }), document.removeEventListener("touchend", this.onMouseUp));
+    },
+    onMouseDown(e, t) {
+      this.bindEvents(), this.touch.mouseDown = !0, this.touch.activeSplitter = t;
+    },
+    onMouseMove(e) {
+      this.touch.mouseDown && (e.preventDefault(), this.touch.dragging = !0, this.calculatePanesSize(this.getCurrentMouseDrag(e)), this.$emit("resize", this.panes.map((t) => ({ min: t.min, max: t.max, size: t.size }))));
+    },
+    onMouseUp() {
+      this.touch.dragging && this.$emit("resized", this.panes.map((e) => ({ min: e.min, max: e.max, size: e.size }))), this.touch.mouseDown = !1, setTimeout(() => {
+        this.touch.dragging = !1, this.unbindEvents();
+      }, 100);
+    },
+    onSplitterClick(e, t) {
+      "ontouchstart" in window && (e.preventDefault(), this.dblClickSplitter && (this.splitterTaps.splitter === t ? (clearTimeout(this.splitterTaps.timeoutId), this.splitterTaps.timeoutId = null, this.onSplitterDblClick(e, t), this.splitterTaps.splitter = null) : (this.splitterTaps.splitter = t, this.splitterTaps.timeoutId = setTimeout(() => {
+        this.splitterTaps.splitter = null;
+      }, 500)))), this.touch.dragging || this.$emit("splitter-click", this.panes[t]);
+    },
+    onSplitterDblClick(e, t) {
+      let i = 0;
+      this.panes = this.panes.map((s, n) => (s.size = n === t ? s.max : s.min, n !== t && (i += s.min), s)), this.panes[t].size -= i, this.$emit("pane-maximize", this.panes[t]);
+    },
+    onPaneClick(e, t) {
+      this.$emit("pane-click", this.indexedPanes[t]);
+    },
+    getCurrentMouseDrag(e) {
+      const t = this.container.getBoundingClientRect(), { clientX: i, clientY: s } = "ontouchstart" in window && e.touches ? e.touches[0] : e;
+      return {
+        x: i - t.left,
+        y: s - t.top
+      };
+    },
+    getCurrentDragPercentage(e) {
+      e = e[this.horizontal ? "y" : "x"];
+      const t = this.container[this.horizontal ? "clientHeight" : "clientWidth"];
+      return this.rtl && !this.horizontal && (e = t - e), e * 100 / t;
+    },
+    calculatePanesSize(e) {
+      const t = this.touch.activeSplitter;
+      let i = {
+        prevPanesSize: this.sumPrevPanesSize(t),
+        nextPanesSize: this.sumNextPanesSize(t),
+        prevReachedMinPanes: 0,
+        nextReachedMinPanes: 0
+      };
+      const s = 0 + (this.pushOtherPanes ? 0 : i.prevPanesSize), n = 100 - (this.pushOtherPanes ? 0 : i.nextPanesSize), a = Math.max(Math.min(this.getCurrentDragPercentage(e), n), s);
+      let r = [t, t + 1], h = this.panes[r[0]] || null, o = this.panes[r[1]] || null;
+      const l = h.max < 100 && a >= h.max + i.prevPanesSize, c = o.max < 100 && a <= 100 - (o.max + this.sumNextPanesSize(t + 1));
+      if (l || c) {
+        l ? (h.size = h.max, o.size = Math.max(100 - h.max - i.prevPanesSize - i.nextPanesSize, 0)) : (h.size = Math.max(100 - o.max - i.prevPanesSize - this.sumNextPanesSize(t + 1), 0), o.size = o.max);
+        return;
+      }
+      if (this.pushOtherPanes) {
+        const d = this.doPushOtherPanes(i, a);
+        if (!d)
+          return;
+        ({ sums: i, panesToResize: r } = d), h = this.panes[r[0]] || null, o = this.panes[r[1]] || null;
+      }
+      h !== null && (h.size = Math.min(Math.max(a - i.prevPanesSize - i.prevReachedMinPanes, h.min), h.max)), o !== null && (o.size = Math.min(Math.max(100 - a - i.nextPanesSize - i.nextReachedMinPanes, o.min), o.max));
+    },
+    doPushOtherPanes(e, t) {
+      const i = this.touch.activeSplitter, s = [i, i + 1];
+      return t < e.prevPanesSize + this.panes[s[0]].min && (s[0] = this.findPrevExpandedPane(i).index, e.prevReachedMinPanes = 0, s[0] < i && this.panes.forEach((n, a) => {
+        a > s[0] && a <= i && (n.size = n.min, e.prevReachedMinPanes += n.min);
+      }), e.prevPanesSize = this.sumPrevPanesSize(s[0]), s[0] === void 0) ? (e.prevReachedMinPanes = 0, this.panes[0].size = this.panes[0].min, this.panes.forEach((n, a) => {
+        a > 0 && a <= i && (n.size = n.min, e.prevReachedMinPanes += n.min);
+      }), this.panes[s[1]].size = 100 - e.prevReachedMinPanes - this.panes[0].min - e.prevPanesSize - e.nextPanesSize, null) : t > 100 - e.nextPanesSize - this.panes[s[1]].min && (s[1] = this.findNextExpandedPane(i).index, e.nextReachedMinPanes = 0, s[1] > i + 1 && this.panes.forEach((n, a) => {
+        a > i && a < s[1] && (n.size = n.min, e.nextReachedMinPanes += n.min);
+      }), e.nextPanesSize = this.sumNextPanesSize(s[1] - 1), s[1] === void 0) ? (e.nextReachedMinPanes = 0, this.panes[this.panesCount - 1].size = this.panes[this.panesCount - 1].min, this.panes.forEach((n, a) => {
+        a < this.panesCount - 1 && a >= i + 1 && (n.size = n.min, e.nextReachedMinPanes += n.min);
+      }), this.panes[s[0]].size = 100 - e.prevPanesSize - e.nextReachedMinPanes - this.panes[this.panesCount - 1].min - e.nextPanesSize, null) : { sums: e, panesToResize: s };
+    },
+    sumPrevPanesSize(e) {
+      return this.panes.reduce((t, i, s) => t + (s < e ? i.size : 0), 0);
+    },
+    sumNextPanesSize(e) {
+      return this.panes.reduce((t, i, s) => t + (s > e + 1 ? i.size : 0), 0);
+    },
+    findPrevExpandedPane(e) {
+      return [...this.panes].reverse().find((i) => i.index < e && i.size > i.min) || {};
+    },
+    findNextExpandedPane(e) {
+      return this.panes.find((i) => i.index > e + 1 && i.size > i.min) || {};
+    },
+    checkSplitpanesNodes() {
+      Array.from(this.container.children).forEach((t) => {
+        const i = t.classList.contains("splitpanes__pane"), s = t.classList.contains("splitpanes__splitter");
+        if (!i && !s) {
+          t.parentNode.removeChild(t), console.warn("Splitpanes: Only <pane> elements are allowed at the root of <splitpanes>. One of your DOM nodes was removed.");
+          return;
+        }
+      });
+    },
+    addSplitter(e, t, i = !1) {
+      const s = e - 1, n = document.createElement("div");
+      n.classList.add("splitpanes__splitter"), i || (n.onmousedown = (a) => this.onMouseDown(a, s), typeof window < "u" && "ontouchstart" in window && (n.ontouchstart = (a) => this.onMouseDown(a, s)), n.onclick = (a) => this.onSplitterClick(a, s + 1)), this.dblClickSplitter && (n.ondblclick = (a) => this.onSplitterDblClick(a, s + 1)), t.parentNode.insertBefore(n, t);
+    },
+    removeSplitter(e) {
+      e.onmousedown = void 0, e.onclick = void 0, e.ondblclick = void 0, e.parentNode.removeChild(e);
+    },
+    redoSplitters() {
+      const e = Array.from(this.container.children);
+      e.forEach((i) => {
+        i.className.includes("splitpanes__splitter") && this.removeSplitter(i);
+      });
+      let t = 0;
+      e.forEach((i) => {
+        i.className.includes("splitpanes__pane") && (!t && this.firstSplitter ? this.addSplitter(t, i, !0) : t && this.addSplitter(t, i), t++);
+      });
+    },
+    requestUpdate(e) {
+      var t = e, { target: i } = t, s = w(t, ["target"]);
+      const n = this.indexedPanes[i._uid];
+      Object.entries(s).forEach(([a, r]) => n[a] = r);
+    },
+    onPaneAdd(e) {
+      let t = -1;
+      Array.from(e.$el.parentNode.children).some((n) => (n.className.includes("splitpanes__pane") && t++, n === e.$el));
+      const i = parseFloat(e.minSize), s = parseFloat(e.maxSize);
+      this.panes.splice(t, 0, {
+        id: e._uid,
+        index: t,
+        min: isNaN(i) ? 0 : i,
+        max: isNaN(s) ? 100 : s,
+        size: e.size === null ? null : parseFloat(e.size),
+        givenSize: e.size,
+        update: e.update
+      }), this.panes.forEach((n, a) => n.index = a), this.ready && this.$nextTick(() => {
+        this.redoSplitters(), this.resetPaneSizes({ addedPane: this.panes[t] }), this.$emit("pane-add", { index: t, panes: this.panes.map((n) => ({ min: n.min, max: n.max, size: n.size })) });
+      });
+    },
+    onPaneRemove(e) {
+      const t = this.panes.findIndex((s) => s.id === e._uid), i = this.panes.splice(t, 1)[0];
+      this.panes.forEach((s, n) => s.index = n), this.$nextTick(() => {
+        this.redoSplitters(), this.resetPaneSizes({ removedPane: C(y({}, i), { index: t }) }), this.$emit("pane-remove", { removed: i, panes: this.panes.map((s) => ({ min: s.min, max: s.max, size: s.size })) });
+      });
+    },
+    resetPaneSizes(e = {}) {
+      !e.addedPane && !e.removedPane ? this.initialPanesSizing() : this.panes.some((t) => t.givenSize !== null || t.min || t.max < 100) ? this.equalizeAfterAddOrRemove(e) : this.equalize(), this.ready && this.$emit("resized", this.panes.map((t) => ({ min: t.min, max: t.max, size: t.size })));
+    },
+    equalize() {
+      const e = 100 / this.panesCount;
+      let t = 0, i = [], s = [];
+      this.panes.forEach((n) => {
+        n.size = Math.max(Math.min(e, n.max), n.min), t -= n.size, n.size >= n.max && i.push(n.id), n.size <= n.min && s.push(n.id);
+      }), t > 0.1 && this.readjustSizes(t, i, s);
+    },
+    initialPanesSizing() {
+      100 / this.panesCount;
+      let e = 100, t = [], i = [], s = 0;
+      this.panes.forEach((a) => {
+        e -= a.size, a.size !== null && s++, a.size >= a.max && t.push(a.id), a.size <= a.min && i.push(a.id);
+      });
+      let n = 100;
+      e > 0.1 && (this.panes.forEach((a) => {
+        a.size === null && (a.size = Math.max(Math.min(e / (this.panesCount - s), a.max), a.min)), n -= a.size;
+      }), n > 0.1 && this.readjustSizes(e, t, i));
+    },
+    equalizeAfterAddOrRemove({ addedPane: e, removedPane: t } = {}) {
+      let i = 100 / this.panesCount, s = 0, n = [], a = [];
+      e && e.givenSize !== null && (i = (100 - e.givenSize) / (this.panesCount - 1)), this.panes.forEach((r) => {
+        s -= r.size, r.size >= r.max && n.push(r.id), r.size <= r.min && a.push(r.id);
+      }), !(Math.abs(s) < 0.1) && (this.panes.forEach((r) => {
+        e && e.givenSize !== null && e.id === r.id || (r.size = Math.max(Math.min(i, r.max), r.min)), s -= r.size, r.size >= r.max && n.push(r.id), r.size <= r.min && a.push(r.id);
+      }), s > 0.1 && this.readjustSizes(s, n, a));
+    },
+    readjustSizes(e, t, i) {
+      let s;
+      e > 0 ? s = e / (this.panesCount - t.length) : s = e / (this.panesCount - i.length), this.panes.forEach((n, a) => {
+        if (e > 0 && !t.includes(n.id)) {
+          const r = Math.max(Math.min(n.size + s, n.max), n.min), h = r - n.size;
+          e -= h, n.size = r;
+        } else if (!i.includes(n.id)) {
+          const r = Math.max(Math.min(n.size + s, n.max), n.min), h = r - n.size;
+          e -= h, n.size = r;
+        }
+        n.update({
+          [this.horizontal ? "height" : "width"]: `${this.indexedPanes[n.id].size}%`
+        });
+      }), Math.abs(e) > 0.1 && this.$nextTick(() => {
+        this.ready && console.warn("Splitpanes: Could not resize panes correctly due to their constraints.");
+      });
+    }
+  },
+  watch: {
+    panes: {
+      deep: !0,
+      immediate: !1,
+      handler() {
+        this.updatePaneComponents();
+      }
+    },
+    horizontal() {
+      this.updatePaneComponents();
+    },
+    firstSplitter() {
+      this.redoSplitters();
+    },
+    dblClickSplitter(e) {
+      [...this.container.querySelectorAll(".splitpanes__splitter")].forEach((i, s) => {
+        i.ondblclick = e ? (n) => this.onSplitterDblClick(n, s) : void 0;
+      });
+    }
+  },
+  beforeDestroy() {
+    this.ready = !1;
+  },
+  mounted() {
+    this.container = this.$refs.container, this.checkSplitpanesNodes(), this.redoSplitters(), this.resetPaneSizes(), this.$emit("ready"), this.ready = !0;
+  },
+  render(e) {
+    return e("div", {
+      ref: "container",
+      class: [
+        "splitpanes",
+        `splitpanes--${this.horizontal ? "horizontal" : "vertical"}`,
+        {
+          "splitpanes--dragging": this.touch.dragging
+        }
+      ]
+    }, this.$slots.default);
+  }
+};
+let E, R;
+const f = {};
+var k = /* @__PURE__ */ S(b, E, R, !1, N);
+function N(e) {
+  for (let t in f)
+    this[t] = f[t];
+}
+var j = /* @__PURE__ */ function() {
+  return k.exports;
+}(), O = function() {
+  var e = this, t = e.$createElement, i = e._self._c || t;
+  return i("div", { staticClass: "splitpanes__pane", style: e.style, on: { click: function(s) {
+    return e.onPaneClick(s, e._uid);
+  } } }, [e._t("default")], 2);
+}, D = [];
+const $ = {
+  name: "pane",
+  inject: ["requestUpdate", "onPaneAdd", "onPaneRemove", "onPaneClick"],
+  props: {
+    size: { type: [Number, String], default: null },
+    minSize: { type: [Number, String], default: 0 },
+    maxSize: { type: [Number, String], default: 100 }
+  },
+  data: () => ({
+    style: {}
+  }),
+  mounted() {
+    this.onPaneAdd(this);
+  },
+  beforeDestroy() {
+    this.onPaneRemove(this);
+  },
+  methods: {
+    update(e) {
+      this.style = e;
+    }
+  },
+  computed: {
+    sizeNumber() {
+      return this.size || this.size === 0 ? parseFloat(this.size) : null;
+    },
+    minSizeNumber() {
+      return parseFloat(this.minSize);
+    },
+    maxSizeNumber() {
+      return parseFloat(this.maxSize);
+    }
+  },
+  watch: {
+    sizeNumber(e) {
+      this.requestUpdate({ target: this, size: e });
+    },
+    minSizeNumber(e) {
+      this.requestUpdate({ target: this, min: e });
+    },
+    maxSizeNumber(e) {
+      this.requestUpdate({ target: this, max: e });
+    }
+  }
+}, z = {};
+var T = /* @__PURE__ */ S($, O, D, !1, q);
+function q(e) {
+  for (let t in z)
+    this[t] = z[t];
+}
+var U = /* @__PURE__ */ function() {
+  return T.exports;
+}();
+export {
+  U as p,
+  j as s
+};