bitz-react-admin-ui 2.4.6 → 2.4.7

package/dist/components/BitzTable/ToolBar/Modal/style.mjs

@@ -1,8 +1,8 @@
-import { css as r } from "../../../../node_modules/.store/@emotion_css@11.11.2/node_modules/@emotion/css/dist/emotion-css.esm.mjs";
-import { columnsSortStyles as l, appearanceConfigStyles as n, exportConfigStyles as d } from "../ColConfigIcon/style.mjs";
+import { css as n } from "../../../../node_modules/.store/@emotion_css@11.11.2/node_modules/@emotion/css/dist/emotion-css.esm.mjs";
+import { columnsSortStyles as l, appearanceConfigStyles as r, exportConfigStyles as i } from "../ColConfigIcon/style.mjs";
 const f = (o) => {
   var t, a, e;
-  return r`
+  return n`
   &.tableConfigModal {
     .ant-modal-content {
       max-height: calc(100vh - 200px);
@@ -35,9 +35,9 @@ const f = (o) => {
 
             ${l(o)}
 
-            ${n(o)}
+            ${r(o)}
 
-            ${d(o)}
+            ${i(o)}
           }
         }
       }
@@ -47,7 +47,7 @@ const f = (o) => {
         align-self: flex-end;
         text-align: left;
         margin: 0;
-        padding: 20px;
+        padding-inline: 24px;
         background-color: ${(e = o.Modal) == null ? void 0 : e.footerBg};
       }
     }

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);