bitz-react-admin-ui 2.2.6 → 2.2.8

package/dist/hooks/use-event-listener.mjs

@@ -14,20 +14,11 @@ if (i)
 function w(e, o, c = {}) {
   if (!i)
     return;
-  const {
-    target: n = window,
-    passive: d = !1,
-    capture: r = !1,
-    depends: l = []
-  } = c;
+  const { target: n = window, passive: d = !1, capture: r = !1, depends: l = [] } = c;
   let s;
   const p = () => {
     const t = a(n);
-    t && !s && (t.addEventListener(
-      e,
-      o,
-      f ? { capture: r, passive: d } : r
-    ), s = !0);
+    t && !s && (t.addEventListener(e, o, f ? { capture: r, passive: d } : r), s = !0);
   }, u = () => {
     const t = a(n);
     t && s && (t.removeEventListener(e, o, r), s = !1);

package/dist/hooks/use-lock-fn.mjs

@@ -1,20 +1,17 @@
 import { useRef as u, useCallback as n } from "react";
 function s(t) {
   const r = u(!1);
-  return n(
-    async (...c) => {
-      if (!r.current) {
-        r.current = !0;
-        try {
-          const e = await t(...c);
-          return r.current = !1, e;
-        } catch (e) {
-          throw r.current = !1, e;
-        }
+  return n(async (...c) => {
+    if (!r.current) {
+      r.current = !0;
+      try {
+        const e = await t(...c);
+        return r.current = !1, e;
+      } catch (e) {
+        throw r.current = !1, e;
       }
-    },
-    [t]
-  );
+    }
+  }, [t]);
 }
 export {
   s as default

package/dist/hooks/use-scroll-parent.mjs

@@ -1,34 +1,32 @@
 import "react";
-function c(t, n) {
-  if (!t)
-    return n;
+function w(n, t) {
+  if (!n)
+    return t;
   let e;
-  return typeof t == "function" ? e = t() : "current" in t ? e = t.current : e = t, e;
+  return typeof n == "function" ? e = n() : "current" in n ? e = n.current : e = n, e;
 }
 const l = typeof window < "u", o = /scroll|auto/i, f = l ? window : void 0;
-function u(t) {
-  return t.tagName !== "HTML" && t.tagName !== "BODY" && t.nodeType === 1;
+function u(n) {
+  return n.tagName !== "HTML" && n.tagName !== "BODY" && n.nodeType === 1;
 }
-function d(t, n = f) {
-  n === void 0 && (n = window);
-  let e = t;
-  for (; e && e !== n && u(e); ) {
+function c(n, t = f) {
+  t === void 0 && (t = window);
+  let e = n;
+  for (; e && e !== t && u(e); ) {
     const { overflowY: i } = window.getComputedStyle(e);
     if (o.test(i)) {
       if (e.tagName !== "BODY")
         return e;
-      const r = window.getComputedStyle(
-        e.parentNode
-      ).overflowY;
+      const r = window.getComputedStyle(e.parentNode).overflowY;
       if (o.test(r))
         return e;
     }
     e = e.parentNode;
   }
-  return n;
+  return t;
 }
 export {
-  d as getScrollParent,
-  c as getTargetElement,
+  c as getScrollParent,
+  w as getTargetElement,
   l as inBrowser
 };

package/dist/hooks/useEvent.mjs

@@ -1,13 +1,10 @@
 import * as n from "react";
 function c(r) {
   const e = n.useRef();
-  return e.current = r, n.useCallback(
-    (...o) => {
-      var t;
-      return (t = e.current) == null ? void 0 : t.call(e, ...o);
-    },
-    []
-  );
+  return e.current = r, n.useCallback((...o) => {
+    var t;
+    return (t = e.current) == null ? void 0 : t.call(e, ...o);
+  }, []);
 }
 export {
   c as default

package/dist/hooks/useMergedState.mjs

@@ -1,21 +1,21 @@
 import p from "../node_modules/.store/ahooks@3.7.11/node_modules/ahooks/es/useUpdateLayoutEffect/index.mjs";
 import l from "./useEvent.mjs";
-import g from "./useState.mjs";
-function s(t) {
-  return t !== void 0;
+import d from "./useState.mjs";
+function s(n) {
+  return n !== void 0;
 }
-function S(t, m) {
-  const { defaultValue: n, value: e, onChange: v, postState: a } = m || {}, [u, f] = g(() => s(e) ? e : s(n) ? typeof n == "function" ? n() : n : typeof t == "function" ? t() : t), o = e !== void 0 ? e : u, d = a ? a(o) : o, V = l(v), [i, h] = g([o]);
+function S(n, g) {
+  const { defaultValue: t, value: e, onChange: m, postState: f } = g || {}, [u, a] = d(() => s(e) ? e : s(t) ? typeof t == "function" ? t() : t : typeof n == "function" ? n() : n), r = e !== void 0 ? e : u, V = f ? f(r) : r, v = l(m), [i, h] = d([r]);
   p(() => {
-    const r = i[0];
-    u !== r && V(u, r);
+    const o = i[0];
+    u !== o && v(u, o);
   }, [i]), p(() => {
-    s(e) || f(e);
+    s(e) || a(e);
   }, [e]);
-  const C = l((r, c) => {
-    f(r, c), h([o], c);
+  const C = l((o, c) => {
+    a(o, c), h([r], c);
   });
-  return [d, C];
+  return [V, C];
 }
 export {
   S as default

package/dist/node_modules/.store/clsx@1.2.1/node_modules/clsx/dist/clsx.m.mjs

@@ -0,0 +1,22 @@
+function o(r) {
+  var f, n, t = "";
+  if (typeof r == "string" || typeof r == "number")
+    t += r;
+  else if (typeof r == "object")
+    if (Array.isArray(r))
+      for (f = 0; f < r.length; f++)
+        r[f] && (n = o(r[f])) && (t && (t += " "), t += n);
+    else
+      for (f in r)
+        r[f] && (t && (t += " "), t += f);
+  return t;
+}
+function a() {
+  for (var r, f, n = 0, t = ""; n < arguments.length; )
+    (r = arguments[n++]) && (f = o(r)) && (t && (t += " "), t += f);
+  return t;
+}
+export {
+  a as clsx,
+  a as default
+};

package/dist/node_modules/.store/prop-types@15.8.1/node_modules/prop-types/index.mjs

@@ -1,15 +1,16 @@
 import { getDefaultExportFromCjs as e } from "../../../../../_virtual/_commonjsHelpers.mjs";
 import { __module as r } from "../../../../../_virtual/index.mjs";
 import { __require as o } from "../../../react-is@16.13.1/node_modules/react-is/index.mjs";
-import { __require as t } from "./factoryWithTypeCheckers.mjs";
-import { __require as p } from "./factoryWithThrowingShims.mjs";
+import { __require as p } from "./factoryWithTypeCheckers.mjs";
+import { __require as t } from "./factoryWithThrowingShims.mjs";
 if (process.env.NODE_ENV !== "production") {
   var s = o(), i = !0;
-  r.exports = t()(s.isElement, i);
+  r.exports = p()(s.isElement, i);
 } else
-  r.exports = p()();
-var m = r.exports;
-const q = /* @__PURE__ */ e(m);
+  r.exports = t()();
+var a = r.exports;
+const q = /* @__PURE__ */ e(a);
 export {
-  q as default
+  q as default,
+  a as p
 };

package/dist/node_modules/.store/react-draggable@4.4.6/node_modules/react-draggable/build/cjs/Draggable.mjs

@@ -0,0 +1,343 @@
+import { __exports as F } from "../../../../../../../_virtual/Draggable.mjs";
+import G from "react";
+import { p as V } from "../../../../../prop-types@15.8.1/node_modules/prop-types/index.mjs";
+import W from "react-dom";
+import $ from "../../../../../../../_virtual/clsx.m.mjs";
+import "./utils/domFns.mjs";
+import "./utils/positionFns.mjs";
+import "./utils/shims.mjs";
+import "./DraggableCore.mjs";
+import "./utils/log.mjs";
+import { __exports as q } from "../../../../../../../_virtual/domFns.mjs";
+import { __exports as B } from "../../../../../../../_virtual/positionFns.mjs";
+import { __exports as U } from "../../../../../../../_virtual/shims.mjs";
+import { __exports as A } from "../../../../../../../_virtual/DraggableCore.mjs";
+import { __exports as I } from "../../../../../../../_virtual/log.mjs";
+(function(p) {
+  Object.defineProperty(p, "__esModule", {
+    value: !0
+  }), Object.defineProperty(p, "DraggableCore", {
+    enumerable: !0,
+    get: function() {
+      return m.default;
+    }
+  }), p.default = void 0;
+  var c = E(G), n = d(V), M = d(W), T = d($), S = q, l = B, v = U, m = d(A), h = d(I);
+  function d(t) {
+    return t && t.__esModule ? t : { default: t };
+  }
+  function _(t) {
+    if (typeof WeakMap != "function")
+      return null;
+    var e = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+    return (_ = function(a) {
+      return a ? r : e;
+    })(t);
+  }
+  function E(t, e) {
+    if (!e && t && t.__esModule)
+      return t;
+    if (t === null || typeof t != "object" && typeof t != "function")
+      return { default: t };
+    var r = _(e);
+    if (r && r.has(t))
+      return r.get(t);
+    var a = {}, o = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var s in t)
+      if (s !== "default" && Object.prototype.hasOwnProperty.call(t, s)) {
+        var i = o ? Object.getOwnPropertyDescriptor(t, s) : null;
+        i && (i.get || i.set) ? Object.defineProperty(a, s, i) : a[s] = t[s];
+      }
+    return a.default = t, r && r.set(t, a), a;
+  }
+  function b() {
+    return b = Object.assign ? Object.assign.bind() : function(t) {
+      for (var e = 1; e < arguments.length; e++) {
+        var r = arguments[e];
+        for (var a in r)
+          Object.prototype.hasOwnProperty.call(r, a) && (t[a] = r[a]);
+      }
+      return t;
+    }, b.apply(this, arguments);
+  }
+  function f(t, e, r) {
+    return e = X(e), e in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+  }
+  function X(t) {
+    var e = Y(t, "string");
+    return typeof e == "symbol" ? e : String(e);
+  }
+  function Y(t, e) {
+    if (typeof t != "object" || t === null)
+      return t;
+    var r = t[Symbol.toPrimitive];
+    if (r !== void 0) {
+      var a = r.call(t, e || "default");
+      if (typeof a != "object")
+        return a;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (e === "string" ? String : Number)(t);
+  }
+  class y extends c.Component {
+    // React 16.3+
+    // Arity (props, state)
+    static getDerivedStateFromProps(e, r) {
+      let {
+        position: a
+      } = e, {
+        prevPropsPosition: o
+      } = r;
+      return a && (!o || a.x !== o.x || a.y !== o.y) ? ((0, h.default)("Draggable: getDerivedStateFromProps %j", {
+        position: a,
+        prevPropsPosition: o
+      }), {
+        x: a.x,
+        y: a.y,
+        prevPropsPosition: {
+          ...a
+        }
+      }) : null;
+    }
+    constructor(e) {
+      super(e), f(this, "onDragStart", (r, a) => {
+        if ((0, h.default)("Draggable: onDragStart: %j", a), this.props.onStart(r, (0, l.createDraggableData)(this, a)) === !1)
+          return !1;
+        this.setState({
+          dragging: !0,
+          dragged: !0
+        });
+      }), f(this, "onDrag", (r, a) => {
+        if (!this.state.dragging)
+          return !1;
+        (0, h.default)("Draggable: onDrag: %j", a);
+        const o = (0, l.createDraggableData)(this, a), s = {
+          x: o.x,
+          y: o.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const {
+            x: g,
+            y: u
+          } = s;
+          s.x += this.state.slackX, s.y += this.state.slackY;
+          const [D, x] = (0, l.getBoundPosition)(this, s.x, s.y);
+          s.x = D, s.y = x, s.slackX = this.state.slackX + (g - s.x), s.slackY = this.state.slackY + (u - s.y), o.x = s.x, o.y = s.y, o.deltaX = s.x - this.state.x, o.deltaY = s.y - this.state.y;
+        }
+        if (this.props.onDrag(r, o) === !1)
+          return !1;
+        this.setState(s);
+      }), f(this, "onDragStop", (r, a) => {
+        if (!this.state.dragging || this.props.onStop(r, (0, l.createDraggableData)(this, a)) === !1)
+          return !1;
+        (0, h.default)("Draggable: onDragStop: %j", a);
+        const s = {
+          dragging: !1,
+          slackX: 0,
+          slackY: 0
+        };
+        if (!!this.props.position) {
+          const {
+            x: g,
+            y: u
+          } = this.props.position;
+          s.x = g, s.y = u;
+        }
+        this.setState(s);
+      }), this.state = {
+        // Whether or not we are currently dragging.
+        dragging: !1,
+        // Whether or not we have been dragged before.
+        dragged: !1,
+        // Current transform x and y.
+        x: e.position ? e.position.x : e.defaultPosition.x,
+        y: e.position ? e.position.y : e.defaultPosition.y,
+        prevPropsPosition: {
+          ...e.position
+        },
+        // Used for compensating for out-of-bounds drags
+        slackX: 0,
+        slackY: 0,
+        // Can only determine if SVG after mounting
+        isElementSVG: !1
+      }, e.position && !(e.onDrag || e.onStop) && console.warn("A `position` was applied to this <Draggable>, without drag handlers. This will make this component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the `position` of this element.");
+    }
+    componentDidMount() {
+      typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({
+        isElementSVG: !0
+      });
+    }
+    componentWillUnmount() {
+      this.setState({
+        dragging: !1
+      });
+    }
+    // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+    // the underlying DOM node ourselves. See the README for more information.
+    findDOMNode() {
+      var e, r;
+      return (e = (r = this.props) === null || r === void 0 || (r = r.nodeRef) === null || r === void 0 ? void 0 : r.current) !== null && e !== void 0 ? e : M.default.findDOMNode(this);
+    }
+    render() {
+      const {
+        axis: e,
+        bounds: r,
+        children: a,
+        defaultPosition: o,
+        defaultClassName: s,
+        defaultClassNameDragging: i,
+        defaultClassNameDragged: g,
+        position: u,
+        positionOffset: D,
+        scale: x,
+        ...R
+      } = this.props;
+      let P = {}, O = null;
+      const w = !!!u || this.state.dragging, C = u || o, N = {
+        // Set left if horizontal drag is enabled
+        x: (0, l.canDragX)(this) && w ? this.state.x : C.x,
+        // Set top if vertical drag is enabled
+        y: (0, l.canDragY)(this) && w ? this.state.y : C.y
+      };
+      this.state.isElementSVG ? O = (0, S.createSVGTransform)(N, D) : P = (0, S.createCSSTransform)(N, D);
+      const k = (0, T.default)(a.props.className || "", s, {
+        [i]: this.state.dragging,
+        [g]: this.state.dragged
+      });
+      return /* @__PURE__ */ c.createElement(m.default, b({}, R, {
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop
+      }), /* @__PURE__ */ c.cloneElement(c.Children.only(a), {
+        className: k,
+        style: {
+          ...a.props.style,
+          ...P
+        },
+        transform: O
+      }));
+    }
+  }
+  p.default = y, f(y, "displayName", "Draggable"), f(y, "propTypes", {
+    // Accepts all props <DraggableCore> accepts.
+    ...m.default.propTypes,
+    /**
+     * `axis` determines which axis the draggable can move.
+     *
+     *  Note that all callbacks will still return data as normal. This only
+     *  controls flushing to the DOM.
+     *
+     * 'both' allows movement horizontally and vertically.
+     * 'x' limits movement to horizontal axis.
+     * 'y' limits movement to vertical axis.
+     * 'none' limits all movement.
+     *
+     * Defaults to 'both'.
+     */
+    axis: n.default.oneOf(["both", "x", "y", "none"]),
+    /**
+     * `bounds` determines the range of movement available to the element.
+     * Available values are:
+     *
+     * 'parent' restricts movement within the Draggable's parent node.
+     *
+     * Alternatively, pass an object with the following properties, all of which are optional:
+     *
+     * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}
+     *
+     * All values are in px.
+     *
+     * Example:
+     *
+     * ```jsx
+     *   let App = React.createClass({
+     *       render: function () {
+     *         return (
+     *            <Draggable bounds={{right: 300, bottom: 300}}>
+     *              <div>Content</div>
+     *           </Draggable>
+     *         );
+     *       }
+     *   });
+     * ```
+     */
+    bounds: n.default.oneOfType([n.default.shape({
+      left: n.default.number,
+      right: n.default.number,
+      top: n.default.number,
+      bottom: n.default.number
+    }), n.default.string, n.default.oneOf([!1])]),
+    defaultClassName: n.default.string,
+    defaultClassNameDragging: n.default.string,
+    defaultClassNameDragged: n.default.string,
+    /**
+     * `defaultPosition` specifies the x and y that the dragged item should start at
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable defaultPosition={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    defaultPosition: n.default.shape({
+      x: n.default.number,
+      y: n.default.number
+    }),
+    positionOffset: n.default.shape({
+      x: n.default.oneOfType([n.default.number, n.default.string]),
+      y: n.default.oneOfType([n.default.number, n.default.string])
+    }),
+    /**
+     * `position`, if present, defines the current position of the element.
+     *
+     *  This is similar to how form elements in React work - if no `position` is supplied, the component
+     *  is uncontrolled.
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable position={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    position: n.default.shape({
+      x: n.default.number,
+      y: n.default.number
+    }),
+    /**
+     * These properties should be defined on the child, not here.
+     */
+    className: v.dontSetMe,
+    style: v.dontSetMe,
+    transform: v.dontSetMe
+  }), f(y, "defaultProps", {
+    ...m.default.defaultProps,
+    axis: "both",
+    bounds: !1,
+    defaultClassName: "react-draggable",
+    defaultClassNameDragging: "react-draggable-dragging",
+    defaultClassNameDragged: "react-draggable-dragged",
+    defaultPosition: {
+      x: 0,
+      y: 0
+    },
+    scale: 1
+  });
+})(F);