@m4l/components 0.1.92 → 0.1.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l/components",
-  "version": "0.1.92",
+  "version": "0.1.93",
   "license": "UNLICENSED",
   "dependencies": {
     "@emotion/react": "^11.9.0",
@@ -12,13 +12,17 @@
     "@mui/lab": "5.0.0-alpha.89",
     "@mui/material": "5.10.4",
     "@mui/x-date-pickers": "6.11.1",
+    "chart.js": "^4.4.0",
+    "chartjs-chart-error-bars": "^4.3.3",
     "fast-equals": "^5.0.1",
     "immer": "^9.0.21",
     "install": "^0.13.0",
     "lodash.clonedeep": "^4.5.0",
     "lodash.debounce": "^4.0.8",
+    "jwt-decode": "^4.0.0",
     "lodash.throttle": "^4.1.1",
     "npm": "^9.6.2",
+    "react-chartjs-2": "^5.2.0",
     "react-dnd": "^16.0.1",
     "react-dnd-html5-backend": "^16.0.1",
     "react-helmet-async": "^1.3.0",

package/react-data-grid.d46d625e.js

@@ -1,6 +1,6 @@
-import { forwardRef, createContext, useContext, useState, useRef, useMemo, useImperativeHandle, useCallback, useEffect, useLayoutEffect as useLayoutEffect$1, memo } from "react";
+import { forwardRef, createContext, useState, useRef, useMemo, useImperativeHandle, useCallback, useEffect, useLayoutEffect as useLayoutEffect$1, useContext, memo } from "react";
 import clsx from "clsx";
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
 function styleInject(css, ref) {
   if (ref === void 0)
     ref = {};

package/react-draggable.e4725f3a.js

@@ -0,0 +1,630 @@
+import React__default from "react";
+import require$$1 from "prop-types";
+import require$$2 from "react-dom";
+import clsx from "clsx";
+import { d as domFns, s as shims, l as log, p as positionFns } from "./utils/index.6469f148.js";
+var cjs = { exports: {} };
+var Draggable$1 = {};
+var DraggableCore$2 = {};
+Object.defineProperty(DraggableCore$2, "__esModule", {
+  value: true
+});
+DraggableCore$2.default = void 0;
+var React = _interopRequireWildcard(React__default);
+var _propTypes = _interopRequireDefault(require$$1);
+var _reactDom = _interopRequireDefault(require$$2);
+var _domFns = domFns;
+var _positionFns = positionFns;
+var _shims = shims;
+var _log = _interopRequireDefault(log);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null)
+    return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== void 0) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object")
+      return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+const eventsFor = {
+  touch: {
+    start: "touchstart",
+    move: "touchmove",
+    stop: "touchend"
+  },
+  mouse: {
+    start: "mousedown",
+    move: "mousemove",
+    stop: "mouseup"
+  }
+};
+let dragEventFor = eventsFor.mouse;
+class DraggableCore$1 extends React.Component {
+  constructor() {
+    super(...arguments);
+    _defineProperty(this, "dragging", false);
+    _defineProperty(this, "lastX", NaN);
+    _defineProperty(this, "lastY", NaN);
+    _defineProperty(this, "touchIdentifier", null);
+    _defineProperty(this, "mounted", false);
+    _defineProperty(this, "handleDragStart", (e) => {
+      this.props.onMouseDown(e);
+      if (!this.props.allowAnyClick && typeof e.button === "number" && e.button !== 0)
+        return false;
+      const thisNode = this.findDOMNode();
+      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {
+        throw new Error("<DraggableCore> not mounted on DragStart!");
+      }
+      const {
+        ownerDocument
+      } = thisNode;
+      if (this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.handle, thisNode) || this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.cancel, thisNode)) {
+        return;
+      }
+      if (e.type === "touchstart")
+        e.preventDefault();
+      const touchIdentifier = (0, _domFns.getTouchIdentifier)(e);
+      this.touchIdentifier = touchIdentifier;
+      const position = (0, _positionFns.getControlPosition)(e, touchIdentifier, this);
+      if (position == null)
+        return;
+      const {
+        x,
+        y
+      } = position;
+      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
+      (0, _log.default)("DraggableCore: handleDragStart: %j", coreEvent);
+      (0, _log.default)("calling", this.props.onStart);
+      const shouldUpdate = this.props.onStart(e, coreEvent);
+      if (shouldUpdate === false || this.mounted === false)
+        return;
+      if (this.props.enableUserSelectHack)
+        (0, _domFns.addUserSelectStyles)(ownerDocument);
+      this.dragging = true;
+      this.lastX = x;
+      this.lastY = y;
+      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, this.handleDrag);
+      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, this.handleDragStop);
+    });
+    _defineProperty(this, "handleDrag", (e) => {
+      const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);
+      if (position == null)
+        return;
+      let {
+        x,
+        y
+      } = position;
+      if (Array.isArray(this.props.grid)) {
+        let deltaX = x - this.lastX, deltaY = y - this.lastY;
+        [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);
+        if (!deltaX && !deltaY)
+          return;
+        x = this.lastX + deltaX, y = this.lastY + deltaY;
+      }
+      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
+      (0, _log.default)("DraggableCore: handleDrag: %j", coreEvent);
+      const shouldUpdate = this.props.onDrag(e, coreEvent);
+      if (shouldUpdate === false || this.mounted === false) {
+        try {
+          this.handleDragStop(new MouseEvent("mouseup"));
+        } catch (err) {
+          const event = document.createEvent("MouseEvents");
+          event.initMouseEvent("mouseup", true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+          this.handleDragStop(event);
+        }
+        return;
+      }
+      this.lastX = x;
+      this.lastY = y;
+    });
+    _defineProperty(this, "handleDragStop", (e) => {
+      if (!this.dragging)
+        return;
+      const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);
+      if (position == null)
+        return;
+      let {
+        x,
+        y
+      } = position;
+      if (Array.isArray(this.props.grid)) {
+        let deltaX = x - this.lastX || 0;
+        let deltaY = y - this.lastY || 0;
+        [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);
+        x = this.lastX + deltaX, y = this.lastY + deltaY;
+      }
+      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
+      const shouldContinue = this.props.onStop(e, coreEvent);
+      if (shouldContinue === false || this.mounted === false)
+        return false;
+      const thisNode = this.findDOMNode();
+      if (thisNode) {
+        if (this.props.enableUserSelectHack)
+          (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);
+      }
+      (0, _log.default)("DraggableCore: handleDragStop: %j", coreEvent);
+      this.dragging = false;
+      this.lastX = NaN;
+      this.lastY = NaN;
+      if (thisNode) {
+        (0, _log.default)("DraggableCore: Removing handlers");
+        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, this.handleDrag);
+        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, this.handleDragStop);
+      }
+    });
+    _defineProperty(this, "onMouseDown", (e) => {
+      dragEventFor = eventsFor.mouse;
+      return this.handleDragStart(e);
+    });
+    _defineProperty(this, "onMouseUp", (e) => {
+      dragEventFor = eventsFor.mouse;
+      return this.handleDragStop(e);
+    });
+    _defineProperty(this, "onTouchStart", (e) => {
+      dragEventFor = eventsFor.touch;
+      return this.handleDragStart(e);
+    });
+    _defineProperty(this, "onTouchEnd", (e) => {
+      dragEventFor = eventsFor.touch;
+      return this.handleDragStop(e);
+    });
+  }
+  componentDidMount() {
+    this.mounted = true;
+    const thisNode = this.findDOMNode();
+    if (thisNode) {
+      (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+        passive: false
+      });
+    }
+  }
+  componentWillUnmount() {
+    this.mounted = false;
+    const thisNode = this.findDOMNode();
+    if (thisNode) {
+      const {
+        ownerDocument
+      } = thisNode;
+      (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);
+      (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);
+      (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);
+      (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);
+      (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+        passive: false
+      });
+      if (this.props.enableUserSelectHack)
+        (0, _domFns.removeUserSelectStyles)(ownerDocument);
+    }
+  }
+  findDOMNode() {
+    var _this$props, _this$props2;
+    return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 || (_this$props2 = _this$props2.nodeRef) === null || _this$props2 === void 0 ? void 0 : _this$props2.current : _reactDom.default.findDOMNode(this);
+  }
+  render() {
+    return /* @__PURE__ */ React.cloneElement(React.Children.only(this.props.children), {
+      onMouseDown: this.onMouseDown,
+      onMouseUp: this.onMouseUp,
+      onTouchEnd: this.onTouchEnd
+    });
+  }
+}
+DraggableCore$2.default = DraggableCore$1;
+_defineProperty(DraggableCore$1, "displayName", "DraggableCore");
+_defineProperty(DraggableCore$1, "propTypes", {
+  allowAnyClick: _propTypes.default.bool,
+  children: _propTypes.default.node.isRequired,
+  disabled: _propTypes.default.bool,
+  enableUserSelectHack: _propTypes.default.bool,
+  offsetParent: function(props, propName) {
+    if (props[propName] && props[propName].nodeType !== 1) {
+      throw new Error("Draggable's offsetParent must be a DOM Node.");
+    }
+  },
+  grid: _propTypes.default.arrayOf(_propTypes.default.number),
+  handle: _propTypes.default.string,
+  cancel: _propTypes.default.string,
+  nodeRef: _propTypes.default.object,
+  onStart: _propTypes.default.func,
+  onDrag: _propTypes.default.func,
+  onStop: _propTypes.default.func,
+  onMouseDown: _propTypes.default.func,
+  scale: _propTypes.default.number,
+  className: _shims.dontSetMe,
+  style: _shims.dontSetMe,
+  transform: _shims.dontSetMe
+});
+_defineProperty(DraggableCore$1, "defaultProps", {
+  allowAnyClick: false,
+  disabled: false,
+  enableUserSelectHack: true,
+  onStart: function() {
+  },
+  onDrag: function() {
+  },
+  onStop: function() {
+  },
+  onMouseDown: function() {
+  },
+  scale: 1
+});
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "DraggableCore", {
+    enumerable: true,
+    get: function() {
+      return _DraggableCore.default;
+    }
+  });
+  exports.default = void 0;
+  var React2 = _interopRequireWildcard2(React__default);
+  var _propTypes2 = _interopRequireDefault2(require$$1);
+  var _reactDom2 = _interopRequireDefault2(require$$2);
+  var _clsx = _interopRequireDefault2(clsx);
+  var _domFns2 = domFns;
+  var _positionFns2 = positionFns;
+  var _shims2 = shims;
+  var _DraggableCore = _interopRequireDefault2(DraggableCore$2);
+  var _log2 = _interopRequireDefault2(log);
+  function _interopRequireDefault2(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  function _getRequireWildcardCache2(nodeInterop) {
+    if (typeof WeakMap !== "function")
+      return null;
+    var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+    var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+    return (_getRequireWildcardCache2 = function(nodeInterop2) {
+      return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+  }
+  function _interopRequireWildcard2(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+      return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+      return { default: obj };
+    }
+    var cache = _getRequireWildcardCache2(nodeInterop);
+    if (cache && cache.has(obj)) {
+      return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var key in obj) {
+      if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+        if (desc && (desc.get || desc.set)) {
+          Object.defineProperty(newObj, key, desc);
+        } else {
+          newObj[key] = obj[key];
+        }
+      }
+    }
+    newObj.default = obj;
+    if (cache) {
+      cache.set(obj, newObj);
+    }
+    return newObj;
+  }
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+  function _defineProperty2(obj, key, value) {
+    key = _toPropertyKey2(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toPropertyKey2(arg) {
+    var key = _toPrimitive2(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+  function _toPrimitive2(input, hint) {
+    if (typeof input !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  class Draggable2 extends React2.Component {
+    static getDerivedStateFromProps(_ref, _ref2) {
+      let {
+        position
+      } = _ref;
+      let {
+        prevPropsPosition
+      } = _ref2;
+      if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {
+        (0, _log2.default)("Draggable: getDerivedStateFromProps %j", {
+          position,
+          prevPropsPosition
+        });
+        return {
+          x: position.x,
+          y: position.y,
+          prevPropsPosition: {
+            ...position
+          }
+        };
+      }
+      return null;
+    }
+    constructor(props) {
+      super(props);
+      _defineProperty2(this, "onDragStart", (e, coreData) => {
+        (0, _log2.default)("Draggable: onDragStart: %j", coreData);
+        const shouldStart = this.props.onStart(e, (0, _positionFns2.createDraggableData)(this, coreData));
+        if (shouldStart === false)
+          return false;
+        this.setState({
+          dragging: true,
+          dragged: true
+        });
+      });
+      _defineProperty2(this, "onDrag", (e, coreData) => {
+        if (!this.state.dragging)
+          return false;
+        (0, _log2.default)("Draggable: onDrag: %j", coreData);
+        const uiData = (0, _positionFns2.createDraggableData)(this, coreData);
+        const newState = {
+          x: uiData.x,
+          y: uiData.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const {
+            x,
+            y
+          } = newState;
+          newState.x += this.state.slackX;
+          newState.y += this.state.slackY;
+          const [newStateX, newStateY] = (0, _positionFns2.getBoundPosition)(this, newState.x, newState.y);
+          newState.x = newStateX;
+          newState.y = newStateY;
+          newState.slackX = this.state.slackX + (x - newState.x);
+          newState.slackY = this.state.slackY + (y - newState.y);
+          uiData.x = newState.x;
+          uiData.y = newState.y;
+          uiData.deltaX = newState.x - this.state.x;
+          uiData.deltaY = newState.y - this.state.y;
+        }
+        const shouldUpdate = this.props.onDrag(e, uiData);
+        if (shouldUpdate === false)
+          return false;
+        this.setState(newState);
+      });
+      _defineProperty2(this, "onDragStop", (e, coreData) => {
+        if (!this.state.dragging)
+          return false;
+        const shouldContinue = this.props.onStop(e, (0, _positionFns2.createDraggableData)(this, coreData));
+        if (shouldContinue === false)
+          return false;
+        (0, _log2.default)("Draggable: onDragStop: %j", coreData);
+        const newState = {
+          dragging: false,
+          slackX: 0,
+          slackY: 0
+        };
+        const controlled = Boolean(this.props.position);
+        if (controlled) {
+          const {
+            x,
+            y
+          } = this.props.position;
+          newState.x = x;
+          newState.y = y;
+        }
+        this.setState(newState);
+      });
+      this.state = {
+        dragging: false,
+        dragged: false,
+        x: props.position ? props.position.x : props.defaultPosition.x,
+        y: props.position ? props.position.y : props.defaultPosition.y,
+        prevPropsPosition: {
+          ...props.position
+        },
+        slackX: 0,
+        slackY: 0,
+        isElementSVG: false
+      };
+      if (props.position && !(props.onDrag || props.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() {
+      if (typeof window.SVGElement !== "undefined" && this.findDOMNode() instanceof window.SVGElement) {
+        this.setState({
+          isElementSVG: true
+        });
+      }
+    }
+    componentWillUnmount() {
+      this.setState({
+        dragging: false
+      });
+    }
+    findDOMNode() {
+      var _this$props$nodeRef$c, _this$props;
+      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 || (_this$props = _this$props.nodeRef) === null || _this$props === void 0 ? void 0 : _this$props.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom2.default.findDOMNode(this);
+    }
+    render() {
+      const {
+        axis,
+        bounds,
+        children,
+        defaultPosition,
+        defaultClassName,
+        defaultClassNameDragging,
+        defaultClassNameDragged,
+        position,
+        positionOffset,
+        scale,
+        ...draggableCoreProps
+      } = this.props;
+      let style = {};
+      let svgTransform = null;
+      const controlled = Boolean(position);
+      const draggable = !controlled || this.state.dragging;
+      const validPosition = position || defaultPosition;
+      const transformOpts = {
+        x: (0, _positionFns2.canDragX)(this) && draggable ? this.state.x : validPosition.x,
+        y: (0, _positionFns2.canDragY)(this) && draggable ? this.state.y : validPosition.y
+      };
+      if (this.state.isElementSVG) {
+        svgTransform = (0, _domFns2.createSVGTransform)(transformOpts, positionOffset);
+      } else {
+        style = (0, _domFns2.createCSSTransform)(transformOpts, positionOffset);
+      }
+      const className = (0, _clsx.default)(children.props.className || "", defaultClassName, {
+        [defaultClassNameDragging]: this.state.dragging,
+        [defaultClassNameDragged]: this.state.dragged
+      });
+      return /* @__PURE__ */ React2.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop
+      }), /* @__PURE__ */ React2.cloneElement(React2.Children.only(children), {
+        className,
+        style: {
+          ...children.props.style,
+          ...style
+        },
+        transform: svgTransform
+      }));
+    }
+  }
+  exports.default = Draggable2;
+  _defineProperty2(Draggable2, "displayName", "Draggable");
+  _defineProperty2(Draggable2, "propTypes", {
+    ..._DraggableCore.default.propTypes,
+    axis: _propTypes2.default.oneOf(["both", "x", "y", "none"]),
+    bounds: _propTypes2.default.oneOfType([_propTypes2.default.shape({
+      left: _propTypes2.default.number,
+      right: _propTypes2.default.number,
+      top: _propTypes2.default.number,
+      bottom: _propTypes2.default.number
+    }), _propTypes2.default.string, _propTypes2.default.oneOf([false])]),
+    defaultClassName: _propTypes2.default.string,
+    defaultClassNameDragging: _propTypes2.default.string,
+    defaultClassNameDragged: _propTypes2.default.string,
+    defaultPosition: _propTypes2.default.shape({
+      x: _propTypes2.default.number,
+      y: _propTypes2.default.number
+    }),
+    positionOffset: _propTypes2.default.shape({
+      x: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string]),
+      y: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string])
+    }),
+    position: _propTypes2.default.shape({
+      x: _propTypes2.default.number,
+      y: _propTypes2.default.number
+    }),
+    className: _shims2.dontSetMe,
+    style: _shims2.dontSetMe,
+    transform: _shims2.dontSetMe
+  });
+  _defineProperty2(Draggable2, "defaultProps", {
+    ..._DraggableCore.default.defaultProps,
+    axis: "both",
+    bounds: false,
+    defaultClassName: "react-draggable",
+    defaultClassNameDragging: "react-draggable-dragging",
+    defaultClassNameDragged: "react-draggable-dragged",
+    defaultPosition: {
+      x: 0,
+      y: 0
+    },
+    scale: 1
+  });
+})(Draggable$1);
+const {
+  default: Draggable,
+  DraggableCore
+} = Draggable$1;
+cjs.exports = Draggable;
+cjs.exports.default = Draggable;
+var DraggableCore_1 = cjs.exports.DraggableCore = DraggableCore;
+export {
+  DraggableCore_1 as D,
+  cjs as c
+};

package/{react-resizable.ba08699a.js → react-resizable.c07d63fb.js}

@@ -1,6 +1,6 @@
 import React__default from "react";
-import { c as cjs } from "./react-draggable.7abb5d0a.js";
-import { u as utils } from "./utils/index.c43a95f4.js";
+import { c as cjs } from "./react-draggable.e4725f3a.js";
+import { u as utils } from "./utils/index.6469f148.js";
 import require$$1 from "prop-types";
 var reactResizable = { exports: {} };
 var Resizable$2 = {};