@mjsz-vbr-elements/core 2.1.4 → 2.1.5

package/dist/useSort-cf4549f9.js

@@ -0,0 +1,667 @@
+/**
+ * name: @mjsz-vbr-elements/core
+ * version: v2.1.5 - 16/12/2023, 17:02:50
+ * (c) 2023
+ * description: Data visualization for MJSZ VBR
+ * author: Ákos Stegner <akos.stegner@gmail.com>
+ */
+import { ref as O, readonly as Ae, watch as T, nextTick as Te, getCurrentScope as Pe, onScopeDispose as Se, unref as A, isRef as Ce, shallowRef as ee, computed as P, reactive as fe, defineComponent as xe, h as Re, provide as pe, inject as de, onErrorCaptured as je } from "vue";
+import { _ as k, j as Le, k as Ne, l as $e, m as De, n as ke, p as Be, q as R, s as j, r as Fe, t as Ue, u as ze } from "./datetime-2fb02df2.js";
+import { SORT_STATE_ORIGINAL as N, SORT_STATE_DESCEND as W, SORT_STATE_ASCEND as $ } from "./constants.js";
+const St = (e) => ({}.VITE_CSS_CLASS_PREFIX || "mjsz-vbr-") + e;
+function me(e) {
+  return Pe() ? (Se(e), !0) : !1;
+}
+function b(e) {
+  return typeof e == "function" ? e() : A(e);
+}
+const U = typeof window < "u", B = () => {
+}, Me = /* @__PURE__ */ We();
+function We() {
+  var e;
+  return U && ((e = window == null ? void 0 : window.navigator) == null ? void 0 : e.userAgent) && /* @__PURE__ */ /iP(ad|hone|od)/.test(window.navigator.userAgent);
+}
+function q(e, t = !1, n = "Timeout") {
+  return new Promise((r, a) => {
+    setTimeout(t ? () => a(n) : r, e);
+  });
+}
+function G(e, t = !1) {
+  function n(l, { flush: s = "sync", deep: f = !1, timeout: p, throwOnTimeout: I } = {}) {
+    let w = null;
+    const E = [new Promise((_) => {
+      w = T(
+        e,
+        (y) => {
+          l(y) !== t && (w == null || w(), _(y));
+        },
+        {
+          flush: s,
+          deep: f,
+          immediate: !0
+        }
+      );
+    })];
+    return p != null && E.push(
+      q(p, I).then(() => b(e)).finally(() => w == null ? void 0 : w())
+    ), Promise.race(E);
+  }
+  function r(l, s) {
+    if (!Ce(l))
+      return n((y) => y === l, s);
+    const { flush: f = "sync", deep: p = !1, timeout: I, throwOnTimeout: w } = s ?? {};
+    let v = null;
+    const _ = [new Promise((y) => {
+      v = T(
+        [e, l],
+        ([S, L]) => {
+          t !== (S === L) && (v == null || v(), y(S));
+        },
+        {
+          flush: f,
+          deep: p,
+          immediate: !0
+        }
+      );
+    })];
+    return I != null && _.push(
+      q(I, w).then(() => b(e)).finally(() => (v == null || v(), b(e)))
+    ), Promise.race(_);
+  }
+  function a(l) {
+    return n((s) => !!s, l);
+  }
+  function o(l) {
+    return r(null, l);
+  }
+  function c(l) {
+    return r(void 0, l);
+  }
+  function i(l) {
+    return n(Number.isNaN, l);
+  }
+  function u(l, s) {
+    return n((f) => {
+      const p = Array.from(f);
+      return p.includes(l) || p.includes(b(l));
+    }, s);
+  }
+  function d(l) {
+    return m(1, l);
+  }
+  function m(l = 1, s) {
+    let f = -1;
+    return n(() => (f += 1, f >= l), s);
+  }
+  return Array.isArray(b(e)) ? {
+    toMatch: n,
+    toContains: u,
+    changed: d,
+    changedTimes: m,
+    get not() {
+      return G(e, !t);
+    }
+  } : {
+    toMatch: n,
+    toBe: r,
+    toBeTruthy: a,
+    toBeNull: o,
+    toBeNaN: i,
+    toBeUndefined: c,
+    changed: d,
+    changedTimes: m,
+    get not() {
+      return G(e, !t);
+    }
+  };
+}
+function Ve(e) {
+  return G(e);
+}
+function qe(e, t, n = {}) {
+  const {
+    immediate: r = !0
+  } = n, a = O(!1);
+  let o = null;
+  function c() {
+    o && (clearTimeout(o), o = null);
+  }
+  function i() {
+    a.value = !1, c();
+  }
+  function u(...d) {
+    c(), a.value = !0, o = setTimeout(() => {
+      a.value = !1, o = null, e(...d);
+    }, b(t));
+  }
+  return r && (a.value = !0, U && u()), me(i), {
+    isPending: Ae(a),
+    start: u,
+    stop: i
+  };
+}
+function Ct(e, t, n) {
+  const r = T(e, (...a) => (Te(() => r()), t(...a)), n);
+}
+function xt(e, t, n) {
+  return T(
+    e,
+    (r, a, o) => {
+      r && t(r, a, o);
+    },
+    n
+  );
+}
+function x(e) {
+  var t;
+  const n = b(e);
+  return (t = n == null ? void 0 : n.$el) != null ? t : n;
+}
+const ye = U ? window : void 0, Ge = U ? window.document : void 0;
+function D(...e) {
+  let t, n, r, a;
+  if (typeof e[0] == "string" || Array.isArray(e[0]) ? ([n, r, a] = e, t = ye) : [t, n, r, a] = e, !t)
+    return B;
+  Array.isArray(n) || (n = [n]), Array.isArray(r) || (r = [r]);
+  const o = [], c = () => {
+    o.forEach((m) => m()), o.length = 0;
+  }, i = (m, l, s, f) => (m.addEventListener(l, s, f), () => m.removeEventListener(l, s, f)), u = T(
+    () => [x(t), b(a)],
+    ([m, l]) => {
+      c(), m && o.push(
+        ...n.flatMap((s) => r.map((f) => i(m, s, f, l)))
+      );
+    },
+    { immediate: !0, flush: "post" }
+  ), d = () => {
+    u(), c();
+  };
+  return me(d), d;
+}
+let te = !1;
+function Rt(e, t, n = {}) {
+  const { window: r = ye, ignore: a = [], capture: o = !0, detectIframe: c = !1 } = n;
+  if (!r)
+    return;
+  Me && !te && (te = !0, Array.from(r.document.body.children).forEach((s) => s.addEventListener("click", B)));
+  let i = !0;
+  const u = (s) => a.some((f) => {
+    if (typeof f == "string")
+      return Array.from(r.document.querySelectorAll(f)).some((p) => p === s.target || s.composedPath().includes(p));
+    {
+      const p = x(f);
+      return p && (s.target === p || s.composedPath().includes(p));
+    }
+  }), m = [
+    D(r, "click", (s) => {
+      const f = x(e);
+      if (!(!f || f === s.target || s.composedPath().includes(f))) {
+        if (s.detail === 0 && (i = !u(s)), !i) {
+          i = !0;
+          return;
+        }
+        t(s);
+      }
+    }, { passive: !0, capture: o }),
+    D(r, "pointerdown", (s) => {
+      const f = x(e);
+      f && (i = !s.composedPath().includes(f) && !u(s));
+    }, { passive: !0 }),
+    c && D(r, "blur", (s) => {
+      var f;
+      const p = x(e);
+      ((f = r.document.activeElement) == null ? void 0 : f.tagName) === "IFRAME" && !(p != null && p.contains(r.document.activeElement)) && t(s);
+    })
+  ].filter(Boolean);
+  return () => m.forEach((s) => s());
+}
+var He = Object.defineProperty, Ke = Object.defineProperties, Xe = Object.getOwnPropertyDescriptors, ne = Object.getOwnPropertySymbols, Je = Object.prototype.hasOwnProperty, Qe = Object.prototype.propertyIsEnumerable, re = (e, t, n) => t in e ? He(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, Ye = (e, t) => {
+  for (var n in t || (t = {}))
+    Je.call(t, n) && re(e, n, t[n]);
+  if (ne)
+    for (var n of ne(t))
+      Qe.call(t, n) && re(e, n, t[n]);
+  return e;
+}, Ze = (e, t) => Ke(e, Xe(t));
+function et(e, t, n) {
+  const {
+    immediate: r = !0,
+    delay: a = 0,
+    onError: o = B,
+    onSuccess: c = B,
+    resetOnExecute: i = !0,
+    shallow: u = !0,
+    throwError: d
+  } = n ?? {}, m = u ? ee(t) : O(t), l = O(!1), s = O(!1), f = ee(void 0);
+  async function p(v = 0, ...E) {
+    i && (m.value = t), f.value = void 0, l.value = !1, s.value = !0, v > 0 && await q(v);
+    const _ = typeof e == "function" ? e(...E) : e;
+    try {
+      const y = await _;
+      m.value = y, l.value = !0, c(y);
+    } catch (y) {
+      if (f.value = y, o(y), d)
+        throw y;
+    } finally {
+      s.value = !1;
+    }
+    return m.value;
+  }
+  r && p(a);
+  const I = {
+    state: m,
+    isReady: l,
+    isLoading: s,
+    error: f,
+    execute: p
+  };
+  function w() {
+    return new Promise((v, E) => {
+      Ve(s).toBe(!1).then(() => v(I)).catch(E);
+    });
+  }
+  return Ze(Ye({}, I), {
+    then(v, E) {
+      return w().then(v, E);
+    }
+  });
+}
+function jt({ document: e = Ge } = {}) {
+  if (!e)
+    return O("visible");
+  const t = O(e.visibilityState);
+  return D(e, "visibilitychange", () => {
+    t.value = e.visibilityState;
+  }), t;
+}
+var tt = Object.defineProperty, oe = Object.getOwnPropertySymbols, nt = Object.prototype.hasOwnProperty, rt = Object.prototype.propertyIsEnumerable, ae = (e, t, n) => t in e ? tt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, ot = (e, t) => {
+  for (var n in t || (t = {}))
+    nt.call(t, n) && ae(e, n, t[n]);
+  if (oe)
+    for (var n of oe(t))
+      rt.call(t, n) && ae(e, n, t[n]);
+  return e;
+};
+async function at(e) {
+  return new Promise((t, n) => {
+    const r = new Image(), { src: a, srcset: o, sizes: c, class: i, loading: u, crossorigin: d } = e;
+    r.src = a, o && (r.srcset = o), c && (r.sizes = c), i && (r.className = i), u && (r.loading = u), d && (r.crossOrigin = d), r.onload = () => t(r), r.onerror = n;
+  });
+}
+function Lt(e, t = {}) {
+  const n = et(
+    () => at(b(e)),
+    void 0,
+    ot({
+      resetOnExecute: !0
+    }, t)
+  );
+  return T(
+    () => b(e),
+    () => n.execute(t.delay),
+    { deep: !0 }
+  ), n;
+}
+function Nt(e = [], t = {}) {
+  const { delay: n = 0 } = t, r = O(!1), a = P(() => {
+    const i = A(e);
+    return Array.isArray(i) ? i.map((u) => A(u)).some(Boolean) : i;
+  }), { start: o, stop: c } = qe(() => {
+    r.value = !0;
+  }, n);
+  return T(
+    a,
+    (i) => {
+      if (i)
+        return o();
+      c(), r.value = !1;
+    },
+    { immediate: !0, deep: !0 }
+  ), r;
+}
+function st(e) {
+  var t = Object.prototype.toString.call(e);
+  return t === "[object Uint8ClampedArray]" || t === "[object Int8Array]" || t === "[object Uint8Array]" || t === "[object Int16Array]" || t === "[object Uint16Array]" || t === "[object Int32Array]" || t === "[object Uint32Array]" || t === "[object Float32Array]" || t === "[object Float64Array]" || t === "[object BigInt64Array]" || t === "[object BigUint64Array]";
+}
+var it = /* @__PURE__ */ k(function(t) {
+  return t != null && typeof t["fantasy-land/empty"] == "function" ? t["fantasy-land/empty"]() : t != null && t.constructor != null && typeof t.constructor["fantasy-land/empty"] == "function" ? t.constructor["fantasy-land/empty"]() : t != null && typeof t.empty == "function" ? t.empty() : t != null && t.constructor != null && typeof t.constructor.empty == "function" ? t.constructor.empty() : Le(t) ? [] : Ne(t) ? "" : $e(t) ? {} : De(t) ? function() {
+    return arguments;
+  }() : st(t) ? t.constructor.from("") : void 0;
+}), ct = /* @__PURE__ */ k(function(t) {
+  return t != null && ke(t, it(t));
+});
+const ut = ct;
+var lt = /* @__PURE__ */ Be(function(t, n) {
+  for (var r = {}, a = {}, o = 0, c = t.length; o < c; )
+    a[t[o]] = 1, o += 1;
+  for (var i in n)
+    a.hasOwnProperty(i) || (r[i] = n[i]);
+  return r;
+});
+const ft = lt;
+var C = `	
+\v\f\r                　\u2028\u2029\uFEFF`, pt = "​", dt = typeof String.prototype.trim == "function", mt = !dt || /* @__PURE__ */ C.trim() || !/* @__PURE__ */ pt.trim() ? /* @__PURE__ */ k(function(t) {
+  var n = new RegExp("^[" + C + "][" + C + "]*"), r = new RegExp("[" + C + "][" + C + "]*$");
+  return t.replace(n, "").replace(r, "");
+}) : /* @__PURE__ */ k(function(t) {
+  return t.trim();
+});
+const F = mt, ve = Symbol("I18nContext"), h = fe({
+  messages: {},
+  locale: "",
+  fallbackLocale: ""
+}), $t = ({ messages: e = {}, locale: t = "", fallbackLocale: n = "" }) => {
+  h.messages = e, h.locale = t, h.fallbackLocale = n;
+  const r = (u, d = {}) => {
+    const m = !ut(d), l = R(F, j(".", u));
+    return P(() => {
+      const f = ge(l);
+      return m ? gt(f, d) : f;
+    }).value;
+  }, a = (u) => {
+    const d = R(F, j(".", u));
+    return !!H(h.locale, d, h.messages);
+  }, o = (u) => {
+    h.locale = u;
+  }, i = {
+    locale: P({
+      get() {
+        return h.locale;
+      },
+      set(u) {
+        h.locale = u;
+      }
+    }),
+    setLocale: o,
+    translate: r,
+    hasTranlation: a
+  };
+  return pe(ve, i), {
+    translate: r
+  };
+}, yt = (e) => {
+  e && (h.messages = e.messages, h.locale = e.locale, h.fallbackLocale = e.fallbackLocale);
+  const t = vt();
+  return {
+    locale: t.locale,
+    t: t.translate,
+    setLocale: t.setLocale,
+    hasTranlation: t.hasTranlation
+  };
+}, vt = () => {
+  const e = de(ve, null);
+  if (e === null)
+    throw new Error("Privider is missing a parent component.");
+  return e;
+}, ge = (e = []) => {
+  let t = H(h.locale, e, h.messages);
+  return !t && h.fallbackLocale && (t = H(h.fallbackLocale, e, h.messages)), t || e.join(".");
+};
+function H(e, t, n) {
+  return Fe([e, ...t], n);
+}
+const gt = function(e, t) {
+  return e.replace(/\{(\w+)\}/g, function(n, r) {
+    return t[r];
+  });
+}, Dt = xe({
+  props: {
+    tag: {
+      type: String,
+      default: "div"
+    },
+    path: {
+      type: String,
+      defult: ""
+    }
+  },
+  setup(e, { slots: t }) {
+    const n = R(F, j(".", e.path)), r = ge(n), a = j(/{|}/, r), o = Object.keys(t).map((c) => {
+      const i = a.indexOf(c);
+      return i > -1 && (a[i] = t[c]()[0]), a;
+    });
+    return () => Re(e.tag, o);
+  }
+}), he = Symbol("ErrorProviderContext"), kt = () => {
+  const e = O(""), t = O({}), n = (o) => {
+    console.error({ error: o }), e.value = o.message || o.error.message, t.value = {
+      message: o.message,
+      key: o.key || Ue(o.message),
+      cause: o.cause
+    };
+  };
+  return pe(he, {
+    onError: n,
+    reset: () => {
+      e.value = "", t.value = {};
+    }
+  }), window.onerror = (o) => {
+    console.error("WINDOW_ONERROR:", o);
+  }, je((o, c, i) => {
+    console.error("onErrorCaptured:", o, c, i);
+  }), {
+    hasError: P(() => e.value.length > 0),
+    message: e,
+    error: t,
+    onError: n
+  };
+}, Bt = () => {
+  const e = ht();
+  return {
+    onError: e.onError,
+    reset: e.reset
+  };
+}, ht = () => {
+  const e = de(he, null);
+  if (e === null)
+    throw new Error("Privider is missing a parent component.");
+  return e;
+}, Ft = (e, t = "", n = {}) => {
+  const r = O(""), { t: a } = yt(), o = P(() => {
+    if (A(t))
+      try {
+        const u = wt(A(e), A(t));
+        return ft(u, A(e));
+      } catch (u) {
+        r.value = u;
+      }
+    return A(e);
+  }), c = (u) => ({
+    ...u,
+    ...u.label && { label: a(u.label ?? "", A(n)) },
+    ...u.tooltip && { tooltip: a(u.tooltip ?? "") }
+  });
+  return {
+    columns: P(() => R(c, o.value)),
+    error: r
+  };
+}, wt = (e, t = "") => {
+  const n = R(F, j(",", t)), r = ze(e);
+  if (n[0] === "")
+    return resolve([]);
+  const a = n.findIndex((o) => !r.includes(o));
+  if (a > -1)
+    throw n[a];
+  return n;
+};
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+function se(e, t) {
+  var n = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!n)
+    return e;
+  var r, a, o = n.call(e), c = [];
+  try {
+    for (; (t === void 0 || t-- > 0) && !(r = o.next()).done; )
+      c.push(r.value);
+  } catch (i) {
+    a = { error: i };
+  } finally {
+    try {
+      r && !r.done && (n = o.return) && n.call(o);
+    } finally {
+      if (a)
+        throw a.error;
+    }
+  }
+  return c;
+}
+var ie;
+(function(e) {
+  e[e.NotStarted = 0] = "NotStarted", e[e.Running = 1] = "Running", e[e.Stopped = 2] = "Stopped";
+})(ie || (ie = {}));
+var Et = { type: "xstate.init" };
+function V(e) {
+  return e === void 0 ? [] : [].concat(e);
+}
+function ce(e, t) {
+  return typeof (e = typeof e == "string" && t && t[e] ? t[e] : e) == "string" ? { type: e } : typeof e == "function" ? { type: e.name, exec: e } : e;
+}
+function K(e) {
+  return function(t) {
+    return e === t;
+  };
+}
+function _t(e) {
+  return typeof e == "string" ? { type: e } : e;
+}
+function ue(e, t) {
+  return { value: e, context: t, actions: [], changed: !1, matches: K(e) };
+}
+function le(e, t, n) {
+  var r = t, a = !1;
+  return [e.filter(function(o) {
+    if (o.type === "xstate.assign") {
+      a = !0;
+      var c = Object.assign({}, r);
+      return typeof o.assignment == "function" ? c = o.assignment(r, n) : Object.keys(o.assignment).forEach(function(i) {
+        c[i] = typeof o.assignment[i] == "function" ? o.assignment[i](r, n) : o.assignment[i];
+      }), r = c, !1;
+    }
+    return !0;
+  }), r, a];
+}
+function bt(e, t) {
+  t === void 0 && (t = {});
+  var n = se(le(V(e.states[e.initial].entry).map(function(c) {
+    return ce(c, t.actions);
+  }), e.context, Et), 2), r = n[0], a = n[1], o = { config: e, _options: t, initialState: { value: e.initial, actions: r, context: a, matches: K(e.initial) }, transition: function(c, i) {
+    var u, d, m = typeof c == "string" ? { value: c, context: e.context } : c, l = m.value, s = m.context, f = _t(i), p = e.states[l];
+    if (p.on) {
+      var I = V(p.on[f.type]);
+      try {
+        for (var w = function(g) {
+          var M = typeof Symbol == "function" && Symbol.iterator, Y = M && g[M], Z = 0;
+          if (Y)
+            return Y.call(g);
+          if (g && typeof g.length == "number")
+            return { next: function() {
+              return g && Z >= g.length && (g = void 0), { value: g && g[Z++], done: !g };
+            } };
+          throw new TypeError(M ? "Object is not iterable." : "Symbol.iterator is not defined.");
+        }(I), v = w.next(); !v.done; v = w.next()) {
+          var E = v.value;
+          if (E === void 0)
+            return ue(l, s);
+          var _ = typeof E == "string" ? { target: E } : E, y = _.target, S = _.actions, L = S === void 0 ? [] : S, X = _.cond, we = X === void 0 ? function() {
+            return !0;
+          } : X, Ee = y === void 0, _e = y ?? l, be = e.states[_e];
+          if (we(s, f)) {
+            var z = se(le((Ee ? V(L) : [].concat(p.exit, L, be.entry).filter(function(g) {
+              return g;
+            })).map(function(g) {
+              return ce(g, o._options.actions);
+            }), s, f), 3), J = z[0], Oe = z[1], Ie = z[2], Q = y ?? l;
+            return { value: Q, context: Oe, actions: J, changed: y !== l || J.length > 0 || Ie, matches: K(Q) };
+          }
+        }
+      } catch (g) {
+        u = { error: g };
+      } finally {
+        try {
+          v && !v.done && (d = w.return) && d.call(w);
+        } finally {
+          if (u)
+            throw u.error;
+        }
+      }
+    }
+    return ue(l, s);
+  } };
+  return o;
+}
+const Ot = bt({
+  id: "sort",
+  initial: N,
+  states: {
+    [N]: {
+      on: {
+        DIRECTION1: W,
+        DIRECTION2: $
+      }
+    },
+    [W]: {
+      on: {
+        DIRECTION1: $,
+        DIRECTION2: N
+      }
+    },
+    [$]: {
+      on: {
+        DIRECTION1: N,
+        DIRECTION2: W
+      }
+    }
+  }
+}), It = (e, t) => {
+  const n = t === $ ? "DIRECTION2" : "DIRECTION1";
+  return Ot.transition(e, n).value;
+};
+function Ut(e = {}) {
+  const { sortTarget: t = null, orders: n = [] } = e, r = fe({ sortTarget: t, orders: n });
+  return {
+    sort: r,
+    change: ({ target: o, orders: c }) => {
+      if (r.sortTarget !== o) {
+        r.sortTarget = o, r.orders = c;
+        return;
+      }
+      const i = c.map((u, d) => ({
+        ...u,
+        direction: It(r.orders[d].direction, u.direction)
+      }));
+      r.sortTarget = o, r.orders = i;
+    }
+  };
+}
+export {
+  kt as a,
+  Bt as b,
+  $t as c,
+  yt as d,
+  Nt as e,
+  St as f,
+  Ut as g,
+  Lt as h,
+  Dt as i,
+  Ct as j,
+  et as k,
+  jt as l,
+  B as n,
+  Rt as o,
+  Ft as u,
+  wt as v,
+  xt as w
+};