@entur/expand 3.6.12 → 3.6.13-beta.0

package/dist/expand.esm.js

@@ -1,248 +1,867 @@
-import { useRandomId, warnAboutMissingStyles } from '@entur/utils';
-import React from 'react';
-import classNames from 'classnames';
-import { Heading5, SubParagraph, Paragraph, Heading2, Heading3, Heading4 } from '@entur/typography';
-import { UnmountClosed } from 'react-collapse';
-import { DownArrowIcon } from '@entur/icons';
-
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function (n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
-function _objectDestructuringEmpty(t) {
-  if (null == t) throw new TypeError("Cannot destructure " + t);
-}
-function _objectWithoutPropertiesLoose(r, e) {
-  if (null == r) return {};
-  var t = {};
-  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.includes(n)) continue;
-    t[n] = r[n];
-  }
-  return t;
-}
-
-var AccordionContext = /*#__PURE__*/React.createContext(null);
-var Accordion = function Accordion(_ref) {
-  var rest = _extends({}, (_objectDestructuringEmpty(_ref), _ref));
-  var currentlyOpenState = React.useState(null);
-  return React.createElement(AccordionContext.Provider, _extends({
-    value: currentlyOpenState
-  }, rest));
+import { useRandomId, warnAboutMissingStyles } from "@entur/utils";
+import { jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Heading5, SubParagraph, Paragraph, Heading2, Heading3, Heading4 } from "@entur/typography";
+import { DownArrowIcon } from "@entur/icons";
+const AccordionContext = React.createContext(null);
+const Accordion = ({ ...rest }) => {
+  const currentlyOpenState = React.useState(null);
+  return /* @__PURE__ */ jsx(AccordionContext.Provider, { value: currentlyOpenState, ...rest });
 };
-var useAccordion = function useAccordion(_ref2) {
-  var id = _ref2.id,
-    defaultOpen = _ref2.defaultOpen;
-  var contextValue = React.useContext(AccordionContext);
+const useAccordion = ({ id, defaultOpen }) => {
+  const contextValue = React.useContext(AccordionContext);
   if (!contextValue) {
-    throw new Error('You need to wrap your AccordionItem inside an Accordion');
+    throw new Error("You need to wrap your AccordionItem inside an Accordion");
   }
-  var openId = contextValue[0],
-    setOpenId = contextValue[1];
-  React.useEffect(function () {
+  const [openId, setOpenId] = contextValue;
+  React.useEffect(() => {
     if (defaultOpen) {
       setOpenId(id);
     }
   }, [defaultOpen, id, setOpenId]);
-  var isOpen = openId === id;
+  const isOpen = openId === id;
   return {
-    isOpen: isOpen,
-    toggle: function toggle() {
-      return setOpenId(isOpen ? null : id);
-    }
+    isOpen,
+    toggle: () => setOpenId(isOpen ? null : id)
   };
 };
-
-var _excluded$6 = ["open"];
-var BaseExpand = function BaseExpand(_ref) {
-  var open = _ref.open,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$6);
-  return React.createElement(UnmountClosed, {
-    isOpened: open
-  }, React.createElement("div", _extends({}, rest)));
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var classnames = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+var hasRequiredClassnames;
+function requireClassnames() {
+  if (hasRequiredClassnames) return classnames.exports;
+  hasRequiredClassnames = 1;
+  (function(module) {
+    (function() {
+      var hasOwn = {}.hasOwnProperty;
+      function classNames2() {
+        var classes = "";
+        for (var i = 0; i < arguments.length; i++) {
+          var arg = arguments[i];
+          if (arg) {
+            classes = appendClass(classes, parseValue(arg));
+          }
+        }
+        return classes;
+      }
+      function parseValue(arg) {
+        if (typeof arg === "string" || typeof arg === "number") {
+          return arg;
+        }
+        if (typeof arg !== "object") {
+          return "";
+        }
+        if (Array.isArray(arg)) {
+          return classNames2.apply(null, arg);
+        }
+        if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+          return arg.toString();
+        }
+        var classes = "";
+        for (var key in arg) {
+          if (hasOwn.call(arg, key) && arg[key]) {
+            classes = appendClass(classes, key);
+          }
+        }
+        return classes;
+      }
+      function appendClass(value, newClass) {
+        if (!newClass) {
+          return value;
+        }
+        if (value) {
+          return value + " " + newClass;
+        }
+        return value + newClass;
+      }
+      if (module.exports) {
+        classNames2.default = classNames2;
+        module.exports = classNames2;
+      } else {
+        window.classNames = classNames2;
+      }
+    })();
+  })(classnames);
+  return classnames.exports;
+}
+var classnamesExports = requireClassnames();
+const classNames = /* @__PURE__ */ getDefaultExportFromCjs(classnamesExports);
+var Collapse = {};
+var hasRequiredCollapse;
+function requireCollapse() {
+  if (hasRequiredCollapse) return Collapse;
+  hasRequiredCollapse = 1;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function _typeof2(obj2) {
+        return typeof obj2;
+      };
+    } else {
+      _typeof = function _typeof2(obj2) {
+        return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      };
+    }
+    return _typeof(obj);
+  }
+  Object.defineProperty(Collapse, "__esModule", {
+    value: true
+  });
+  Collapse.Collapse = void 0;
+  var _react = _interopRequireDefault(React);
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { "default": obj };
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+  }
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+      o2.__proto__ = p2;
+      return o2;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+      var Super = _getPrototypeOf(Derived), result;
+      if (hasNativeReflectConstruct) {
+        var NewTarget = _getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return _possibleConstructorReturn(this, result);
+    };
+  }
+  function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+      return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
+    }
+    return _assertThisInitialized(self);
+  }
+  function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+  }
+  function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      }));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+      return o2.__proto__ || Object.getPrototypeOf(o2);
+    };
+    return _getPrototypeOf(o);
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var Collapse$1 = /* @__PURE__ */ function(_React$Component) {
+    _inherits(Collapse2, _React$Component);
+    var _super = _createSuper(Collapse2);
+    function Collapse2(props) {
+      var _this;
+      _classCallCheck(this, Collapse2);
+      _this = _super.call(this, props);
+      _defineProperty(_assertThisInitialized(_this), "timeout", void 0);
+      _defineProperty(_assertThisInitialized(_this), "container", void 0);
+      _defineProperty(_assertThisInitialized(_this), "content", void 0);
+      _defineProperty(_assertThisInitialized(_this), "onResize", function() {
+        clearTimeout(_this.timeout);
+        if (!_this.container || !_this.content) {
+          return;
+        }
+        var _this$props = _this.props, isOpened = _this$props.isOpened, checkTimeout = _this$props.checkTimeout;
+        var containerHeight = Math.floor(_this.container.clientHeight);
+        var contentHeight = Math.floor(_this.content.clientHeight);
+        var isFullyOpened = isOpened && Math.abs(contentHeight - containerHeight) <= 1;
+        var isFullyClosed = !isOpened && Math.abs(containerHeight) <= 1;
+        if (isFullyOpened || isFullyClosed) {
+          _this.onRest({
+            isFullyOpened,
+            isFullyClosed,
+            isOpened,
+            containerHeight,
+            contentHeight
+          });
+        } else {
+          _this.onWork({
+            isFullyOpened,
+            isFullyClosed,
+            isOpened,
+            containerHeight,
+            contentHeight
+          });
+          _this.timeout = setTimeout(function() {
+            return _this.onResize();
+          }, checkTimeout);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRest", function(_ref) {
+        var isFullyOpened = _ref.isFullyOpened, isFullyClosed = _ref.isFullyClosed, isOpened = _ref.isOpened, containerHeight = _ref.containerHeight, contentHeight = _ref.contentHeight;
+        if (!_this.container || !_this.content) {
+          return;
+        }
+        var hasOpened = isOpened && _this.container.style.height === "".concat(contentHeight, "px");
+        var hasClosed = !isOpened && _this.container.style.height === "0px";
+        if (hasOpened || hasClosed) {
+          _this.container.style.overflow = isOpened ? "initial" : "hidden";
+          _this.container.style.height = isOpened ? "auto" : "0px";
+          var onRest = _this.props.onRest;
+          if (onRest) {
+            onRest({
+              isFullyOpened,
+              isFullyClosed,
+              isOpened,
+              containerHeight,
+              contentHeight
+            });
+          }
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onWork", function(_ref2) {
+        var isFullyOpened = _ref2.isFullyOpened, isFullyClosed = _ref2.isFullyClosed, isOpened = _ref2.isOpened, containerHeight = _ref2.containerHeight, contentHeight = _ref2.contentHeight;
+        if (!_this.container || !_this.content) {
+          return;
+        }
+        var isOpenining = isOpened && _this.container.style.height === "".concat(contentHeight, "px");
+        var isClosing = !isOpened && _this.container.style.height === "0px";
+        if (isOpenining || isClosing) {
+          return;
+        }
+        _this.container.style.overflow = "hidden";
+        _this.container.style.height = isOpened ? "".concat(contentHeight, "px") : "0px";
+        var onWork = _this.props.onWork;
+        if (onWork) {
+          onWork({
+            isFullyOpened,
+            isFullyClosed,
+            isOpened,
+            containerHeight,
+            contentHeight
+          });
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRefContainer", function(container) {
+        _this.container = container;
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRefContent", function(content) {
+        _this.content = content;
+      });
+      if (props.initialStyle) {
+        _this.initialStyle = props.initialStyle;
+      } else {
+        _this.initialStyle = props.isOpened ? {
+          height: "auto",
+          overflow: "initial"
+        } : {
+          height: "0px",
+          overflow: "hidden"
+        };
+      }
+      return _this;
+    }
+    _createClass(Collapse2, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.onResize();
+      }
+    }, {
+      key: "shouldComponentUpdate",
+      value: function shouldComponentUpdate(nextProps) {
+        var _this$props2 = this.props, theme = _this$props2.theme, isOpened = _this$props2.isOpened, children = _this$props2.children;
+        return children !== nextProps.children || isOpened !== nextProps.isOpened || Object.keys(theme).some(function(c) {
+          return theme[c] !== nextProps.theme[c];
+        });
+      }
+    }, {
+      key: "getSnapshotBeforeUpdate",
+      value: function getSnapshotBeforeUpdate() {
+        if (!this.container || !this.content) {
+          return null;
+        }
+        if (this.container.style.height === "auto") {
+          var contentHeight = this.content.clientHeight;
+          this.container.style.height = "".concat(contentHeight, "px");
+        }
+        return null;
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate() {
+        this.onResize();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        clearTimeout(this.timeout);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props3 = this.props, theme = _this$props3.theme, children = _this$props3.children, isOpened = _this$props3.isOpened;
+        return /* @__PURE__ */ _react["default"].createElement("div", {
+          ref: this.onRefContainer,
+          className: theme.collapse,
+          style: this.initialStyle,
+          "aria-hidden": !isOpened
+        }, /* @__PURE__ */ _react["default"].createElement("div", {
+          ref: this.onRefContent,
+          className: theme.content
+        }, children));
+      }
+    }]);
+    return Collapse2;
+  }(_react["default"].Component);
+  Collapse.Collapse = Collapse$1;
+  _defineProperty(Collapse$1, "defaultProps", {
+    theme: {
+      collapse: "ReactCollapse--collapse",
+      content: "ReactCollapse--content"
+    },
+    initialStyle: void 0,
+    onRest: void 0,
+    onWork: void 0,
+    checkTimeout: 50
+  });
+  return Collapse;
+}
+var UnmountClosed = {};
+var hasRequiredUnmountClosed;
+function requireUnmountClosed() {
+  if (hasRequiredUnmountClosed) return UnmountClosed;
+  hasRequiredUnmountClosed = 1;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function _typeof2(obj2) {
+        return typeof obj2;
+      };
+    } else {
+      _typeof = function _typeof2(obj2) {
+        return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      };
+    }
+    return _typeof(obj);
+  }
+  Object.defineProperty(UnmountClosed, "__esModule", {
+    value: true
+  });
+  UnmountClosed.UnmountClosed = void 0;
+  var _react = _interopRequireDefault(React);
+  var _Collapse = requireCollapse();
+  var _excluded = ["isOpened"], _excluded2 = ["isOpened"];
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { "default": obj };
+  }
+  function _extends() {
+    _extends = Object.assign || 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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) {
+        symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+      }
+      keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _objectSpread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+      if (i % 2) {
+        ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+    }
+    return target;
+  }
+  function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
+    }
+    return target;
+  }
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+    return target;
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+  }
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+      o2.__proto__ = p2;
+      return o2;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+      var Super = _getPrototypeOf(Derived), result;
+      if (hasNativeReflectConstruct) {
+        var NewTarget = _getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return _possibleConstructorReturn(this, result);
+    };
+  }
+  function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+      return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
+    }
+    return _assertThisInitialized(self);
+  }
+  function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+  }
+  function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      }));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+      return o2.__proto__ || Object.getPrototypeOf(o2);
+    };
+    return _getPrototypeOf(o);
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var UnmountClosed$1 = /* @__PURE__ */ function(_React$PureComponent) {
+    _inherits(UnmountClosed2, _React$PureComponent);
+    var _super = _createSuper(UnmountClosed2);
+    function UnmountClosed2(props) {
+      var _this;
+      _classCallCheck(this, UnmountClosed2);
+      _this = _super.call(this, props);
+      _defineProperty(_assertThisInitialized(_this), "onWork", function(_ref) {
+        var isOpened = _ref.isOpened, rest = _objectWithoutProperties(_ref, _excluded);
+        _this.setState({
+          isResting: false,
+          isOpened
+        });
+        var onWork = _this.props.onWork;
+        if (onWork) {
+          onWork(_objectSpread({
+            isOpened
+          }, rest));
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRest", function(_ref2) {
+        var isOpened = _ref2.isOpened, rest = _objectWithoutProperties(_ref2, _excluded2);
+        _this.setState({
+          isResting: true,
+          isOpened,
+          isInitialRender: false
+        });
+        var onRest = _this.props.onRest;
+        if (onRest) {
+          onRest(_objectSpread({
+            isOpened
+          }, rest));
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "getInitialStyle", function() {
+        var _this$state = _this.state, isOpened = _this$state.isOpened, isInitialRender = _this$state.isInitialRender;
+        if (isInitialRender) {
+          return isOpened ? {
+            height: "auto",
+            overflow: "initial"
+          } : {
+            height: "0px",
+            overflow: "hidden"
+          };
+        }
+        return {
+          height: "0px",
+          overflow: "hidden"
+        };
+      });
+      _this.state = {
+        isResting: true,
+        isOpened: props.isOpened,
+        isInitialRender: true
+      };
+      return _this;
+    }
+    _createClass(UnmountClosed2, [{
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var isOpened = this.props.isOpened;
+        if (prevProps.isOpened !== isOpened) {
+          this.setState({
+            isResting: false,
+            isOpened,
+            isInitialRender: false
+          });
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$state2 = this.state, isResting = _this$state2.isResting, isOpened = _this$state2.isOpened;
+        return isResting && !isOpened ? null : /* @__PURE__ */ _react["default"].createElement(_Collapse.Collapse, _extends({}, this.props, {
+          initialStyle: this.getInitialStyle(),
+          onWork: this.onWork,
+          onRest: this.onRest
+        }));
+      }
+    }]);
+    return UnmountClosed2;
+  }(_react["default"].PureComponent);
+  UnmountClosed.UnmountClosed = UnmountClosed$1;
+  _defineProperty(UnmountClosed$1, "defaultProps", {
+    onWork: void 0,
+    onRest: void 0
+  });
+  return UnmountClosed;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  var _require = requireCollapse(), Collapse2 = _require.Collapse;
+  var _require2 = requireUnmountClosed(), UnmountClosed2 = _require2.UnmountClosed;
+  lib = UnmountClosed2;
+  UnmountClosed2.Collapse = Collapse2;
+  UnmountClosed2.UnmountClosed = UnmountClosed2;
+  return lib;
+}
+var libExports = requireLib();
+const BaseExpand = ({ open, ...rest }) => {
+  return /* @__PURE__ */ jsx(libExports.UnmountClosed, { isOpened: open, children: /* @__PURE__ */ jsx("div", { ...rest }) });
 };
-
-var _excluded$5 = ["open", "className"];
-var ExpandArrow = function ExpandArrow(_ref) {
-  var _ref$open = _ref.open,
-    open = _ref$open === void 0 ? false : _ref$open,
-    className = _ref.className,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$5);
-  return React.createElement(DownArrowIcon, _extends({
-    className: classNames(className, 'eds-expandable-arrow', {
-      'eds-expandable-arrow--open': open
-    })
-  }, rest, {
-    "aria-hidden": "true"
-  }));
+const ExpandArrow = ({
+  open = false,
+  className,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsx(
+    DownArrowIcon,
+    {
+      className: classNames(className, "eds-expandable-arrow", {
+        "eds-expandable-arrow--open": open
+      }),
+      ...rest,
+      "aria-hidden": "true"
+    }
+  );
 };
-
-var _excluded$4 = ["title", "children", "className", "id", "open", "onToggle", "contentStyle", "disableAnimation"];
-var BaseExpandablePanel = function BaseExpandablePanel(_ref) {
-  var title = _ref.title,
-    children = _ref.children,
-    className = _ref.className,
-    id = _ref.id,
-    open = _ref.open,
-    onToggle = _ref.onToggle,
-    contentStyle = _ref.contentStyle,
-    disableAnimation = _ref.disableAnimation,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
-  return React.createElement("div", {
-    className: classNames('eds-expandable-panel', className, {
-      'eds-expandable-panel--disable-animation': disableAnimation
-    })
-  }, React.createElement("button", _extends({
-    type: "button",
-    className: "eds-expandable-panel__trigger",
-    onClick: onToggle,
-    "aria-expanded": open,
-    "aria-controls": open ? id : undefined
-  }, rest), React.createElement("span", {
-    className: "eds-expandable-panel__grid"
-  }, React.createElement(Heading5, {
-    margin: "none",
-    as: "span"
-  }, title), React.createElement("span", {
-    className: "eds-expandable-panel__icon-container"
-  }, React.createElement(ExpandArrow, {
-    open: open
-  })))), React.createElement(BaseExpand, {
-    className: "eds-expandable-panel__content",
-    id: id,
-    open: open,
-    style: contentStyle
-  }, children));
+const BaseExpandablePanel = ({
+  title,
+  children,
+  className,
+  id,
+  open,
+  onToggle,
+  contentStyle,
+  disableAnimation,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classNames("eds-expandable-panel", className, {
+        "eds-expandable-panel--disable-animation": disableAnimation
+      }),
+      children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "eds-expandable-panel__trigger",
+            onClick: onToggle,
+            "aria-expanded": open,
+            "aria-controls": open ? id : void 0,
+            ...rest,
+            children: /* @__PURE__ */ jsxs("span", { className: "eds-expandable-panel__grid", children: [
+              /* @__PURE__ */ jsx(Heading5, { margin: "none", as: "span", children: title }),
+              /* @__PURE__ */ jsx("span", { className: "eds-expandable-panel__icon-container", children: /* @__PURE__ */ jsx(ExpandArrow, { open }) })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          BaseExpand,
+          {
+            className: "eds-expandable-panel__content",
+            id,
+            open,
+            style: contentStyle,
+            children
+          }
+        )
+      ]
+    }
+  );
 };
-
-var _excluded$3 = ["defaultOpen", "id", "contentStyle"];
-var AccordionItem = function AccordionItem(_ref) {
-  var _ref$defaultOpen = _ref.defaultOpen,
-    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen,
-    overrideId = _ref.id,
-    contentStyle = _ref.contentStyle,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
-  var randomId = useRandomId('eds-accordion-item');
-  var id = overrideId || randomId;
-  var _useAccordion = useAccordion({
-      id: id,
-      defaultOpen: defaultOpen
-    }),
-    isOpen = _useAccordion.isOpen,
-    toggle = _useAccordion.toggle;
-  return React.createElement(BaseExpandablePanel, _extends({}, rest, {
-    contentStyle: contentStyle,
-    id: id,
-    onToggle: toggle,
-    open: isOpen
-  }));
+const AccordionItem = ({
+  defaultOpen = false,
+  id: overrideId,
+  contentStyle,
+  ...rest
+}) => {
+  const randomId = useRandomId("eds-accordion-item");
+  const id = overrideId || randomId;
+  const { isOpen, toggle } = useAccordion({ id, defaultOpen });
+  return /* @__PURE__ */ jsx(
+    BaseExpandablePanel,
+    {
+      ...rest,
+      contentStyle,
+      id,
+      onToggle: toggle,
+      open: isOpen
+    }
+  );
 };
-
-var _excluded$2 = ["defaultOpen", "contentStyle"];
-var ExpandablePanel = function ExpandablePanel(_ref) {
-  var _ref$defaultOpen = _ref.defaultOpen,
-    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen,
-    contentStyle = _ref.contentStyle,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-  var randomId = useRandomId('eds-expandable');
-  var _React$useState = React.useState(defaultOpen),
-    isOpen = _React$useState[0],
-    setOpen = _React$useState[1];
-  return React.createElement(BaseExpandablePanel, _extends({
-    id: randomId,
-    open: isOpen,
-    onToggle: function onToggle() {
-      return setOpen(function (prev) {
-        return !prev;
-      });
-    },
-    contentStyle: contentStyle
-  }, rest));
+const ExpandablePanel = ({
+  defaultOpen = false,
+  contentStyle,
+  ...rest
+}) => {
+  const randomId = useRandomId("eds-expandable");
+  const [isOpen, setOpen] = React.useState(defaultOpen);
+  return /* @__PURE__ */ jsx(
+    BaseExpandablePanel,
+    {
+      id: randomId,
+      open: isOpen,
+      onToggle: () => setOpen((prev) => !prev),
+      contentStyle,
+      ...rest
+    }
+  );
 };
-
-var _excluded$1 = ["children", "open", "onToggle", "as"];
-var ExpandableTextButton = function ExpandableTextButton(_ref) {
-  var children = _ref.children,
-    open = _ref.open,
-    onToggle = _ref.onToggle,
-    _ref$as = _ref.as,
-    Component = _ref$as === void 0 ? Heading5 : _ref$as,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-  return React.createElement("button", _extends({
-    className: "eds-expandable-text__trigger",
-    "aria-expanded": open,
-    type: "button",
-    onClick: onToggle
-  }, rest), React.createElement(Component, null, children), React.createElement(ExpandArrow, {
-    open: open,
-    className: "eds-expandable-text__arrow"
-  }));
+const ExpandableTextButton = ({
+  children,
+  open,
+  onToggle,
+  as: Component = Heading5,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: "eds-expandable-text__trigger",
+      "aria-expanded": open,
+      type: "button",
+      onClick: onToggle,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsx(Component, { children }),
+        /* @__PURE__ */ jsx(ExpandArrow, { open, className: "eds-expandable-text__arrow" })
+      ]
+    }
+  );
 };
-
-var _excluded = ["title", "children", "defaultOpen", "contentStyle", "titleElement", "disableAnimation", "className"];
-var ExpandableText = function ExpandableText(_ref) {
-  var title = _ref.title,
-    children = _ref.children,
-    _ref$defaultOpen = _ref.defaultOpen,
-    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen,
-    contentStyle = _ref.contentStyle,
-    _ref$titleElement = _ref.titleElement,
-    titleElement = _ref$titleElement === void 0 ? 'Heading5' : _ref$titleElement,
-    disableAnimation = _ref.disableAnimation,
-    className = _ref.className,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded);
-  var randomId = useRandomId('eds-expandable-text');
-  var _React$useState = React.useState(defaultOpen),
-    isOpen = _React$useState[0],
-    setOpen = _React$useState[1];
-  var Element = React.useMemo(function () {
-    return GetTypographyComponent(titleElement);
-  }, [titleElement]);
-  return React.createElement("div", {
-    className: classNames('eds-expandable-text', className, {
-      'eds-expandable-text--disable-animation': disableAnimation
-    })
-  }, React.createElement(ExpandableTextButton, _extends({
-    open: isOpen,
-    onToggle: function onToggle() {
-      return setOpen(function (prev) {
-        return !prev;
-      });
-    },
-    "aria-controls": isOpen ? randomId : undefined,
-    as: Element
-  }, rest), title), React.createElement(BaseExpand, _extends({
-    className: "eds-expandable-text__content",
-    id: randomId,
-    open: isOpen,
-    style: contentStyle
-  }, rest), children));
+const ExpandableText = ({
+  title,
+  children,
+  defaultOpen = false,
+  contentStyle,
+  titleElement = "Heading5",
+  disableAnimation,
+  className,
+  ...rest
+}) => {
+  const randomId = useRandomId("eds-expandable-text");
+  const [isOpen, setOpen] = React.useState(defaultOpen);
+  const Element = React.useMemo(
+    () => GetTypographyComponent(titleElement),
+    [titleElement]
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classNames("eds-expandable-text", className, {
+        "eds-expandable-text--disable-animation": disableAnimation
+      }),
+      children: [
+        /* @__PURE__ */ jsx(
+          ExpandableTextButton,
+          {
+            open: isOpen,
+            onToggle: () => setOpen((prev) => !prev),
+            "aria-controls": isOpen ? randomId : void 0,
+            as: Element,
+            ...rest,
+            children: title
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          BaseExpand,
+          {
+            className: "eds-expandable-text__content",
+            id: randomId,
+            open: isOpen,
+            style: contentStyle,
+            ...rest,
+            children
+          }
+        )
+      ]
+    }
+  );
 };
 function GetTypographyComponent(element) {
   switch (element) {
-    case 'Heading5':
+    case "Heading5":
       return Heading5;
-    case 'Heading4':
+    case "Heading4":
       return Heading4;
-    case 'Heading3':
+    case "Heading3":
       return Heading3;
-    case 'Heading2':
+    case "Heading2":
       return Heading2;
-    case 'Paragraph':
+    case "Paragraph":
       return Paragraph;
-    case 'SubParagraph':
+    case "SubParagraph":
       return SubParagraph;
     default:
       return Heading5;
   }
 }
-
-warnAboutMissingStyles('expand', 'typography', 'icons');
-
-export { Accordion, AccordionItem, BaseExpand, ExpandArrow, ExpandablePanel, ExpandableText, ExpandableTextButton, useAccordion };
+warnAboutMissingStyles("expand", "typography", "icons");
+export {
+  Accordion,
+  AccordionItem,
+  BaseExpand,
+  ExpandArrow,
+  ExpandablePanel,
+  ExpandableText,
+  ExpandableTextButton,
+  useAccordion
+};
 //# sourceMappingURL=expand.esm.js.map