bitz-react-admin-ui 1.4.23 → 1.6.2

package/dist/node_modules/@dnd-kit/modifiers/dist/modifiers.esm.mjs

@@ -0,0 +1,27 @@
+import "react";
+function f(e, l, t) {
+  const i = {
+    ...e
+  };
+  return l.top + e.y <= t.top ? i.y = t.top - l.top : l.bottom + e.y >= t.top + t.height && (i.y = t.top + t.height - l.bottom), l.left + e.x <= t.left ? i.x = t.left - l.left : l.right + e.x >= t.left + t.width && (i.x = t.left + t.width - l.right), i;
+}
+const r = (e) => {
+  let {
+    transform: l
+  } = e;
+  return {
+    ...l,
+    x: 0
+  };
+}, h = (e) => {
+  let {
+    transform: l,
+    draggingNodeRect: t,
+    windowRect: i
+  } = e;
+  return !t || !i ? l : f(l, t, i);
+};
+export {
+  r as restrictToVerticalAxis,
+  h as restrictToWindowEdges
+};

package/dist/node_modules/@dnd-kit/sortable/dist/sortable.esm.mjs

@@ -0,0 +1,367 @@
+import H, { useMemo as E, useRef as z, useEffect as L, useContext as le, useState as fe } from "react";
+import { KeyboardCode as O, useDndContext as ge, useDroppable as pe, useDraggable as ve, getClientRect as be } from "../../core/dist/core.esm.mjs";
+import { useUniqueId as me, useIsomorphicLayoutEffect as K, useCombinedRefs as Ie, isKeyboardEvent as xe, CSS as U } from "../../utilities/dist/utilities.esm.mjs";
+function V(e, n, t) {
+  const r = e.slice();
+  return r.splice(t < 0 ? r.length + t : t, 0, r.splice(n, 1)[0]), r;
+}
+function he(e, n) {
+  return e.reduce((t, r, o) => {
+    const s = n.get(r);
+    return s && (t[o] = s), t;
+  }, Array(e.length));
+}
+function N(e) {
+  return e !== null && e >= 0;
+}
+function ye(e, n) {
+  if (e === n)
+    return !0;
+  if (e.length !== n.length)
+    return !1;
+  for (let t = 0; t < e.length; t++)
+    if (e[t] !== n[t])
+      return !1;
+  return !0;
+}
+function Re(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const j = (e) => {
+  let {
+    rects: n,
+    activeIndex: t,
+    overIndex: r,
+    index: o
+  } = e;
+  const s = V(n, r, t), i = n[o], a = s[o];
+  return !a || !i ? null : {
+    x: a.left - i.left,
+    y: a.top - i.top,
+    scaleX: a.width / i.width,
+    scaleY: a.height / i.height
+  };
+}, A = {
+  scaleX: 1,
+  scaleY: 1
+}, ze = (e) => {
+  var n;
+  let {
+    activeIndex: t,
+    activeNodeRect: r,
+    index: o,
+    rects: s,
+    overIndex: i
+  } = e;
+  const a = (n = s[t]) != null ? n : r;
+  if (!a)
+    return null;
+  if (o === t) {
+    const d = s[i];
+    return d ? {
+      x: 0,
+      y: t < i ? d.top + d.height - (a.top + a.height) : d.top - a.top,
+      ...A
+    } : null;
+  }
+  const l = De(s, o, t);
+  return o > t && o <= i ? {
+    x: 0,
+    y: -a.height - l,
+    ...A
+  } : o < t && o >= i ? {
+    x: 0,
+    y: a.height + l,
+    ...A
+  } : {
+    x: 0,
+    y: 0,
+    ...A
+  };
+};
+function De(e, n, t) {
+  const r = e[n], o = e[n - 1], s = e[n + 1];
+  return r ? t < n ? o ? r.top - (o.top + o.height) : s ? s.top - (r.top + r.height) : 0 : s ? s.top - (r.top + r.height) : o ? r.top - (o.top + o.height) : 0 : 0;
+}
+const k = "Sortable", J = /* @__PURE__ */ H.createContext({
+  activeIndex: -1,
+  containerId: k,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: j,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function Pe(e) {
+  let {
+    children: n,
+    id: t,
+    items: r,
+    strategy: o = j,
+    disabled: s = !1
+  } = e;
+  const {
+    active: i,
+    dragOverlay: a,
+    droppableRects: l,
+    over: d,
+    measureDroppableContainers: c
+  } = ge(), p = me(k, t), b = a.rect !== null, f = E(() => r.map((m) => typeof m == "object" && "id" in m ? m.id : m), [r]), w = i != null, h = i ? f.indexOf(i.id) : -1, v = d ? f.indexOf(d.id) : -1, T = z(f), y = !ye(f, T.current), R = v !== -1 && h === -1 || y, g = Re(s);
+  K(() => {
+    y && w && c(f);
+  }, [y, f, w, c]), L(() => {
+    T.current = f;
+  }, [f]);
+  const D = E(
+    () => ({
+      activeIndex: h,
+      containerId: p,
+      disabled: g,
+      disableTransforms: R,
+      items: f,
+      overIndex: v,
+      useDragOverlay: b,
+      sortedRects: he(f, l),
+      strategy: o
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [h, p, g.draggable, g.droppable, R, f, v, l, b, o]
+  );
+  return H.createElement(J.Provider, {
+    value: D
+  }, n);
+}
+const Se = (e) => {
+  let {
+    id: n,
+    items: t,
+    activeIndex: r,
+    overIndex: o
+  } = e;
+  return V(t, r, o).indexOf(n);
+}, Ce = (e) => {
+  let {
+    containerId: n,
+    isSorting: t,
+    wasDragging: r,
+    index: o,
+    items: s,
+    newIndex: i,
+    previousItems: a,
+    previousContainerId: l,
+    transition: d
+  } = e;
+  return !d || !r || a !== s && o === i ? !1 : t ? !0 : i !== o && n === l;
+}, we = {
+  duration: 200,
+  easing: "ease"
+}, Q = "transform", Te = /* @__PURE__ */ U.Transition.toString({
+  property: Q,
+  duration: 0,
+  easing: "linear"
+}), Oe = {
+  roleDescription: "sortable"
+};
+function Ne(e) {
+  let {
+    disabled: n,
+    index: t,
+    node: r,
+    rect: o
+  } = e;
+  const [s, i] = fe(null), a = z(t);
+  return K(() => {
+    if (!n && t !== a.current && r.current) {
+      const l = o.current;
+      if (l) {
+        const d = be(r.current, {
+          ignoreTransform: !0
+        }), c = {
+          x: l.left - d.left,
+          y: l.top - d.top,
+          scaleX: l.width / d.width,
+          scaleY: l.height / d.height
+        };
+        (c.x || c.y) && i(c);
+      }
+    }
+    t !== a.current && (a.current = t);
+  }, [n, t, r, o]), L(() => {
+    s && i(null);
+  }, [s]), s;
+}
+function Xe(e) {
+  let {
+    animateLayoutChanges: n = Ce,
+    attributes: t,
+    disabled: r,
+    data: o,
+    getNewIndex: s = Se,
+    id: i,
+    strategy: a,
+    resizeObserverConfig: l,
+    transition: d = we
+  } = e;
+  const {
+    items: c,
+    containerId: p,
+    activeIndex: b,
+    disabled: f,
+    disableTransforms: w,
+    sortedRects: h,
+    overIndex: v,
+    useDragOverlay: T,
+    strategy: y
+  } = le(J), R = Ae(r, f), g = c.indexOf(i), D = E(() => ({
+    sortable: {
+      containerId: p,
+      index: g,
+      items: c
+    },
+    ...o
+  }), [p, o, g, c]), m = E(() => c.slice(c.indexOf(i)), [c, i]), {
+    rect: P,
+    node: X,
+    isOver: W,
+    setNodeRef: G
+  } = pe({
+    id: i,
+    data: D,
+    disabled: R.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: m,
+      ...l
+    }
+  }), {
+    active: S,
+    activatorEvent: Z,
+    activeNodeRect: ee,
+    attributes: te,
+    setNodeRef: M,
+    listeners: re,
+    isDragging: _,
+    over: ne,
+    setActivatorNodeRef: oe,
+    transform: ie
+  } = ve({
+    id: i,
+    data: D,
+    attributes: {
+      ...Oe,
+      ...t
+    },
+    disabled: R.draggable
+  }), se = Ie(G, M), I = !!S, Y = I && !w && N(b) && N(v), q = !T && _, B = q && Y ? ie : null, ae = Y ? B ?? (a ?? y)({
+    rects: h,
+    activeNodeRect: ee,
+    activeIndex: b,
+    overIndex: v,
+    index: g
+  }) : null, C = N(b) && N(v) ? s({
+    id: i,
+    items: c,
+    activeIndex: b,
+    overIndex: v
+  }) : g, x = S == null ? void 0 : S.id, u = z({
+    activeId: x,
+    items: c,
+    newIndex: C,
+    containerId: p
+  }), ce = c !== u.current.items, F = n({
+    active: S,
+    containerId: p,
+    isDragging: _,
+    isSorting: I,
+    id: i,
+    index: g,
+    items: c,
+    newIndex: u.current.newIndex,
+    previousItems: u.current.items,
+    previousContainerId: u.current.containerId,
+    transition: d,
+    wasDragging: u.current.activeId != null
+  }), $ = Ne({
+    disabled: !F,
+    index: g,
+    node: X,
+    rect: P
+  });
+  return L(() => {
+    I && u.current.newIndex !== C && (u.current.newIndex = C), p !== u.current.containerId && (u.current.containerId = p), c !== u.current.items && (u.current.items = c);
+  }, [I, C, p, c]), L(() => {
+    if (x === u.current.activeId)
+      return;
+    if (x && !u.current.activeId) {
+      u.current.activeId = x;
+      return;
+    }
+    const ue = setTimeout(() => {
+      u.current.activeId = x;
+    }, 50);
+    return () => clearTimeout(ue);
+  }, [x]), {
+    active: S,
+    activeIndex: b,
+    attributes: te,
+    data: D,
+    rect: P,
+    index: g,
+    newIndex: C,
+    items: c,
+    isOver: W,
+    isSorting: I,
+    isDragging: _,
+    listeners: re,
+    node: X,
+    overIndex: v,
+    over: ne,
+    setNodeRef: se,
+    setActivatorNodeRef: oe,
+    setDroppableNodeRef: G,
+    setDraggableNodeRef: M,
+    transform: $ ?? ae,
+    transition: de()
+  };
+  function de() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      $ || // Or to prevent items jumping to back to their "new" position when items change
+      ce && u.current.newIndex === g
+    )
+      return Te;
+    if (!(q && !xe(Z) || !d) && (I || F))
+      return U.Transition.toString({
+        ...d,
+        property: Q
+      });
+  }
+}
+function Ae(e, n) {
+  var t, r;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (t = e == null ? void 0 : e.draggable) != null ? t : n.draggable,
+    droppable: (r = e == null ? void 0 : e.droppable) != null ? r : n.droppable
+  };
+}
+O.Down, O.Right, O.Up, O.Left;
+export {
+  Pe as SortableContext,
+  V as arrayMove,
+  Ce as defaultAnimateLayoutChanges,
+  Se as defaultNewIndexGetter,
+  j as rectSortingStrategy,
+  Xe as useSortable,
+  ze as verticalListSortingStrategy
+};

package/dist/node_modules/@dnd-kit/utilities/dist/utilities.esm.mjs

@@ -0,0 +1,235 @@
+import { useLayoutEffect as R, useEffect as g, useRef as o, useMemo as l, useCallback as i } from "react";
+function Y() {
+  for (var n = arguments.length, t = new Array(n), e = 0; e < n; e++)
+    t[e] = arguments[e];
+  return l(
+    () => (u) => {
+      t.forEach((r) => r(u));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const D = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function a(n) {
+  const t = Object.prototype.toString.call(n);
+  return t === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  t === "[object global]";
+}
+function b(n) {
+  return "nodeType" in n;
+}
+function c(n) {
+  var t, e;
+  return n ? a(n) ? n : b(n) && (t = (e = n.ownerDocument) == null ? void 0 : e.defaultView) != null ? t : window : window;
+}
+function j(n) {
+  const {
+    Document: t
+  } = c(n);
+  return n instanceof t;
+}
+function C(n) {
+  return a(n) ? !1 : n instanceof c(n).HTMLElement;
+}
+function L(n) {
+  return n instanceof c(n).SVGElement;
+}
+function x(n) {
+  return n ? a(n) ? n.document : b(n) ? j(n) ? n : C(n) || L(n) ? n.ownerDocument : document : document : document;
+}
+const E = D ? R : g;
+function M(n) {
+  const t = o(n);
+  return E(() => {
+    t.current = n;
+  }), i(function() {
+    for (var e = arguments.length, u = new Array(e), r = 0; r < e; r++)
+      u[r] = arguments[r];
+    return t.current == null ? void 0 : t.current(...u);
+  }, []);
+}
+function A() {
+  const n = o(null), t = i((u, r) => {
+    n.current = setInterval(u, r);
+  }, []), e = i(() => {
+    n.current !== null && (clearInterval(n.current), n.current = null);
+  }, []);
+  return [t, e];
+}
+function I(n, t) {
+  t === void 0 && (t = [n]);
+  const e = o(n);
+  return E(() => {
+    e.current !== n && (e.current = n);
+  }, t), e;
+}
+function v(n, t) {
+  const e = o();
+  return l(
+    () => {
+      const u = n(e.current);
+      return e.current = u, u;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function N(n) {
+  const t = M(n), e = o(null), u = i(
+    (r) => {
+      r !== e.current && (t == null || t(r, e.current)), e.current = r;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [e, u];
+}
+function F(n) {
+  const t = o();
+  return g(() => {
+    t.current = n;
+  }, [n]), t.current;
+}
+let f = {};
+function H(n, t) {
+  return l(() => {
+    if (t)
+      return t;
+    const e = f[n] == null ? 0 : f[n] + 1;
+    return f[n] = e, n + "-" + e;
+  }, [n, t]);
+}
+function S(n) {
+  return function(t) {
+    for (var e = arguments.length, u = new Array(e > 1 ? e - 1 : 0), r = 1; r < e; r++)
+      u[r - 1] = arguments[r];
+    return u.reduce((s, T) => {
+      const y = Object.entries(T);
+      for (const [d, p] of y) {
+        const m = s[d];
+        m != null && (s[d] = m + n * p);
+      }
+      return s;
+    }, {
+      ...t
+    });
+  };
+}
+const W = /* @__PURE__ */ S(1), q = /* @__PURE__ */ S(-1);
+function O(n) {
+  return "clientX" in n && "clientY" in n;
+}
+function z(n) {
+  if (!n)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = c(n.target);
+  return t && n instanceof t;
+}
+function V(n) {
+  if (!n)
+    return !1;
+  const {
+    TouchEvent: t
+  } = c(n.target);
+  return t && n instanceof t;
+}
+function G(n) {
+  if (V(n)) {
+    if (n.touches && n.touches.length) {
+      const {
+        clientX: t,
+        clientY: e
+      } = n.touches[0];
+      return {
+        x: t,
+        y: e
+      };
+    } else if (n.changedTouches && n.changedTouches.length) {
+      const {
+        clientX: t,
+        clientY: e
+      } = n.changedTouches[0];
+      return {
+        x: t,
+        y: e
+      };
+    }
+  }
+  return O(n) ? {
+    x: n.clientX,
+    y: n.clientY
+  } : null;
+}
+const w = /* @__PURE__ */ Object.freeze({
+  Translate: {
+    toString(n) {
+      if (!n)
+        return;
+      const {
+        x: t,
+        y: e
+      } = n;
+      return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (e ? Math.round(e) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(n) {
+      if (!n)
+        return;
+      const {
+        scaleX: t,
+        scaleY: e
+      } = n;
+      return "scaleX(" + t + ") scaleY(" + e + ")";
+    }
+  },
+  Transform: {
+    toString(n) {
+      if (n)
+        return [w.Translate.toString(n), w.Scale.toString(n)].join(" ");
+    }
+  },
+  Transition: {
+    toString(n) {
+      let {
+        property: t,
+        duration: e,
+        easing: u
+      } = n;
+      return t + " " + e + "ms " + u;
+    }
+  }
+}), h = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function K(n) {
+  return n.matches(h) ? n : n.querySelector(h);
+}
+export {
+  w as CSS,
+  W as add,
+  D as canUseDOM,
+  K as findFirstFocusableNode,
+  G as getEventCoordinates,
+  x as getOwnerDocument,
+  c as getWindow,
+  O as hasViewportRelativeCoordinates,
+  j as isDocument,
+  C as isHTMLElement,
+  z as isKeyboardEvent,
+  b as isNode,
+  L as isSVGElement,
+  V as isTouchEvent,
+  a as isWindow,
+  q as subtract,
+  Y as useCombinedRefs,
+  M as useEvent,
+  A as useInterval,
+  E as useIsomorphicLayoutEffect,
+  I as useLatestValue,
+  v as useLazyMemo,
+  N as useNodeRef,
+  F as usePrevious,
+  H as useUniqueId
+};