@orangesk/orange-design-system 2.0.0-alpha.0 → 2.0.0-alpha.1

package/build/components/Accordion/index.js

@@ -0,0 +1,1170 @@
+import React, { createContext, useRef, useEffect, useContext } from 'react';
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: false
+  }), e;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+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) {
+		/* global define */
+
+		(function () {
+
+			var hasOwn = {}.hasOwnProperty;
+
+			function classNames () {
+				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 classNames.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) {
+				classNames.default = classNames;
+				module.exports = classNames;
+			} else {
+				window.classNames = classNames;
+			}
+		}()); 
+	} (classnames));
+	return classnames.exports;
+}
+
+var classnamesExports = requireClassnames();
+var cx = /*@__PURE__*/getDefaultExportFromCjs(classnamesExports);
+
+// we use array to include old browser key names like IE11
+// ie. navigation keys https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values#navigation_keys
+var keys = {
+  TAB: ['Tab'],
+  ARROWLEFT: ['Left', 'ArrowLeft'],
+  ARROWUP: ['Up', 'ArrowUp'],
+  ARROWRIGHT: ['Right', 'ArrowRight'],
+  ARROWDOWN: ['Down', 'ArrowDown']
+};
+
+var RovingTabindex = /*#__PURE__*/function () {
+  function RovingTabindex(elems) {
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      direction: 'horizontal'
+    };
+    _classCallCheck(this, RovingTabindex);
+    this.elems = elems;
+    this.config = config;
+    this.isActive = false;
+    this.onKeydown = this.onKeydown.bind(this);
+  }
+  return _createClass(RovingTabindex, [{
+    key: "init",
+    value: function init() {
+      document.addEventListener('keydown', this.onKeydown);
+      this.isActive = true;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      document.removeEventListener('keydown', this.onKeydown);
+      this.isActive = false;
+    }
+  }, {
+    key: "update",
+    value: function update(elems) {
+      this.elems = elems;
+    }
+  }, {
+    key: "onKeydown",
+    value: function onKeydown(e) {
+      var activeElemIndex = this.elems.indexOf(document.activeElement);
+      if ((keys.ARROWUP.includes(e.key) || keys.ARROWDOWN.includes(e.key)) && this.config.direction === 'horizontal') {
+        return;
+      }
+      if ((keys.ARROWLEFT.includes(e.key) || keys.ARROWRIGHT.includes(e.key)) && this.config.direction === 'vertical') {
+        return;
+      }
+      if (keys.ARROWDOWN.includes(e.key) || keys.ARROWRIGHT.includes(e.key)) {
+        e.preventDefault();
+        if (activeElemIndex >= 0 && activeElemIndex < this.elems.length - 1) {
+          this.elems[activeElemIndex + 1].focus();
+        } else {
+          this.elems[0].focus();
+        }
+      }
+      if (keys.ARROWUP.includes(e.key) || keys.ARROWLEFT.includes(e.key)) {
+        e.preventDefault();
+        if (activeElemIndex >= 1) {
+          this.elems[activeElemIndex - 1].focus();
+        } else {
+          this.elems[this.elems.length - 1].focus();
+        }
+      }
+      if (keys.TAB.includes(e.key)) {
+        this.destroy();
+      }
+    }
+  }]);
+}();
+
+var TRIGGER_EVT = 'toggleTrigger';
+var TOGGLE_EVT = 'toggle';
+var defaultConfig$1 = {
+  activeClass: 'is-active',
+  settingsAttr: 'data-toggle'
+};
+var Toggle = /*#__PURE__*/function () {
+  function Toggle(element, config) {
+    _classCallCheck(this, Toggle);
+    this.element = element;
+    this.config = _objectSpread2(_objectSpread2({}, defaultConfig$1), config);
+    this.settings = {};
+    this.targets = [];
+    this.handleClick = this.handleClick.bind(this);
+    this.element.ODS_Toggle = this;
+    this.init();
+    return this;
+  }
+  return _createClass(Toggle, [{
+    key: "doToggle",
+    value: function doToggle(props) {
+      var _props$dispatchEvent = props.dispatchEvent,
+        dispatchEvent = _props$dispatchEvent === void 0 ? true : _props$dispatchEvent;
+      var element = props.element,
+        attribute = props.attribute,
+        value = props.value,
+        action = props.action;
+      var returnProps = _objectSpread2({}, props);
+      var eventDetail = {
+        trigger: this.element,
+        element: element
+      };
+      if (attribute === 'icon') {
+        attribute = 'xlink:href';
+        element = element.querySelector('use');
+      }
+      if (attribute === 'text') {
+        element = element.querySelector('[data-toggle-text-target]') || element;
+      }
+      if (typeof value === 'undefined') {
+        value = false;
+      }
+      returnProps.value = toggle({
+        element: element,
+        attribute: attribute,
+        action: action,
+        value: value,
+        dispatchEvent: dispatchEvent,
+        eventDetail: eventDetail
+      });
+      return returnProps;
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      this.settings = this.parseSettings();
+      this.targets = this.setupTargets();
+      this.element.addEventListener('click', this.handleClick);
+      return this.targets;
+    }
+  }, {
+    key: "handleClick",
+    value: function handleClick() {
+      var _this = this;
+      this.targets = this.targets.map(function (target) {
+        return _this.doToggle(target);
+      });
+      this.element.dispatchEvent(new CustomEvent(TRIGGER_EVT, {
+        bubbles: true
+      }));
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.element.removeEventListener('click', this.handleClick);
+      this.settings = [];
+      this.targets = [];
+    }
+  }, {
+    key: "update",
+    value: function update() {
+      this.removeNonExistentTargets();
+      this.addNewTargets();
+    }
+  }, {
+    key: "parseSettings",
+    value: function parseSettings() {
+      var jsonSettings = this.element.getAttribute(this.config.settingsAttr);
+      var ariaControls = this.element.getAttribute('aria-controls');
+      var settings = JSON.parse(jsonSettings);
+      if (ariaControls) {
+        var ariaExpanded = this.element.getAttribute('aria-expanded');
+        settings = [].concat(_toConsumableArray(ariaExpanded ? [{
+          target: 'self',
+          attribute: 'aria-expanded'
+        }] : []), [{
+          target: ariaControls.split(' ').map(function (a) {
+            return "#".concat(a);
+          }).join(','),
+          attribute: 'hidden'
+        }], _toConsumableArray(Array.isArray(settings) ? settings : []));
+      }
+      return settings;
+    }
+
+    // get all the possible settings for all target elements
+  }, {
+    key: "setupTargets",
+    value: function setupTargets() {
+      var trigger = this.element;
+      return this.settings.reduce(function (allSettings, setting) {
+        return [].concat(_toConsumableArray(allSettings), _toConsumableArray(setting === null || setting === void 0 ? void 0 : setting.target.split(',') // separate target selectors
+        .reduce(function (targetSettings, target) {
+          return [].concat(_toConsumableArray(targetSettings), _toConsumableArray(Toggle
+          // get target elements from DOM
+          .getTargetElementsFromString({
+            target: target,
+            trigger: trigger
+          })
+          // duplicate setting for each DOM element
+          .map(function (element) {
+            return _objectSpread2(_objectSpread2({}, setting), {}, {
+              element: element
+            });
+          })));
+        }, [])));
+      }, []);
+    }
+  }, {
+    key: "removeNonExistentTargets",
+    value: function removeNonExistentTargets() {
+      this.targets = this.targets.filter(function (target) {
+        return document.contains(target.element);
+      });
+    }
+  }, {
+    key: "addNewTargets",
+    value: function addNewTargets() {
+      var _this2 = this;
+      var allTargets = this.setupTargets();
+      var newTargets = allTargets.filter(function (newTarget) {
+        return !_this2.targets.find(function (target) {
+          return target.element === newTarget.element && target.action === newTarget.action;
+        });
+      });
+      this.targets = [].concat(_toConsumableArray(this.targets), _toConsumableArray(newTargets));
+    }
+  }], [{
+    key: "getTargetElementsFromString",
+    value: function getTargetElementsFromString(_ref) {
+      var target = _ref.target,
+        trigger = _ref.trigger;
+      var selector = target.trim();
+      if (selector === 'self') {
+        return [trigger];
+      }
+      if (selector === 'parent') {
+        return [trigger.parentNode];
+      }
+      if (selector === 'previous') {
+        return [trigger.previousElementSibling];
+      }
+      if (selector === 'next') {
+        return [trigger.nextElementSibling];
+      }
+      if (typeof selector === 'string') {
+        // don't be tempted to remove this querySelectorAll
+        // selector like '.target-elements' whould not work as expected
+        return Array.from(document.querySelectorAll(selector));
+      }
+
+      // add log why we endup here
+      return selector;
+    }
+  }, {
+    key: "getInstance",
+    value: function getInstance(el) {
+      return el && el.ODS_Toggle ? el.ODS_Toggle : null;
+    }
+  }]);
+}();
+Toggle.getTargetElements;
+Toggle.setTargets;
+
+function toggle(props) {
+  var element = props.element,
+    attribute = props.attribute,
+    action = props.action,
+    value = props.value,
+    _props$dispatchEvent = props.dispatchEvent,
+    dispatchEvent = _props$dispatchEvent === void 0 ? true : _props$dispatchEvent,
+    eventDetail = props.eventDetail;
+  var returnValue = null;
+  if (!element || !(element instanceof Element)) {
+    return returnValue;
+  }
+  if (action === 'focus') {
+    setTimeout(element.focus(), 20);
+  }
+  if (action === 'click') {
+    element.click();
+  }
+  if (attribute === 'class') {
+    element.classList.toggle(value);
+    returnValue = value;
+  }
+  if (attribute === 'text') {
+    var oldText = element.textContent;
+    element.textContent = value;
+    returnValue = oldText;
+  }
+  if (attribute !== 'class' && attribute !== 'text' && typeof action === 'undefined') {
+    returnValue = element.getAttribute(attribute);
+    if (attribute === 'hidden') {
+      if (element.hasAttribute(attribute)) {
+        element.removeAttribute(attribute);
+      } else {
+        element.setAttribute(attribute, '');
+      }
+    } else if (!value) {
+      element.setAttribute(attribute, !(returnValue === 'true'));
+    } else {
+      element.setAttribute(attribute, value);
+    }
+  }
+  if (dispatchEvent) {
+    element.dispatchEvent(new CustomEvent(TOGGLE_EVT, {
+      detail: eventDetail,
+      bubbles: true
+    }));
+  }
+  return returnValue;
+}
+
+var defaultConfig = {
+  buttonSelector: '[data-accordion-toggle]'
+};
+var Accordion$1 = /*#__PURE__*/function () {
+  function Accordion(element, config) {
+    _classCallCheck(this, Accordion);
+    this.element = element;
+    this.config = Object.assign(Object.assign({}, defaultConfig), config);
+    this.onFocus = this.onFocus.bind(this);
+    this.onClick = this.onClick.bind(this);
+    this.element.ODS_Accordion = this;
+    this.init();
+    return this;
+  }
+  return _createClass(Accordion, [{
+    key: "onFocus",
+    value: function onFocus(e) {
+      if (!this.rovingTabindex.isActive) {
+        this.rovingTabindex.init();
+      }
+      var button = e.currentTarget;
+      if (window.location.hash.substring(1) === button.getAttribute('id') && button.getAttribute('aria-expanded') === 'false') {
+        button.click();
+      }
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var _this = this;
+      this.buttons = Array.from(this.element.querySelectorAll(this.config.buttonSelector));
+      if (!this.rovingTabindex) {
+        this.rovingTabindex = new RovingTabindex(this.buttons, {
+          direction: 'vertical'
+        });
+      } else {
+        this.rovingTabindex.update(this.buttons);
+      }
+      this.buttons.forEach(function (button) {
+        button.addEventListener('focus', _this.onFocus);
+        // only add click events when there are no toggle actions defined
+        if (!button.getAttribute('data-toggle')) {
+          button.addEventListener('click', _this.onClick);
+        }
+      });
+    }
+  }, {
+    key: "onClick",
+    value: function onClick(e) {
+      var button = e.currentTarget;
+      var accordionSection = this.element.querySelector("#".concat(button.getAttribute('aria-controls')));
+      toggle({
+        element: button,
+        attribute: 'aria-expanded'
+      });
+      toggle({
+        element: accordionSection,
+        attribute: 'hidden'
+      });
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this2 = this;
+      this.rovingTabindex.destroy();
+      this.buttons.forEach(function (button) {
+        button.removeEventListener('focus', _this2.onFocus);
+        button.removeEventListener('click', _this2.onClick);
+      });
+    }
+  }, {
+    key: "update",
+    value: function update() {
+      this.destroy();
+      this.init();
+    }
+  }], [{
+    key: "getInstance",
+    value: function getInstance(el) {
+      return el && el.ODS_Accordion ? el.ODS_Accordion : null;
+    }
+  }]);
+}();
+
+var HeadingContext = /*#__PURE__*/createContext(null);
+
+var jsxRuntime = {exports: {}};
+
+var reactJsxRuntime_production = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_production;
+
+function requireReactJsxRuntime_production () {
+	if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+	hasRequiredReactJsxRuntime_production = 1;
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+	  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+	function jsxProd(type, config, maybeKey) {
+	  var key = null;
+	  void 0 !== maybeKey && (key = "" + maybeKey);
+	  void 0 !== config.key && (key = "" + config.key);
+	  if ("key" in config) {
+	    maybeKey = {};
+	    for (var propName in config)
+	      "key" !== propName && (maybeKey[propName] = config[propName]);
+	  } else maybeKey = config;
+	  config = maybeKey.ref;
+	  return {
+	    $$typeof: REACT_ELEMENT_TYPE,
+	    type: type,
+	    key: key,
+	    ref: void 0 !== config ? config : null,
+	    props: maybeKey
+	  };
+	}
+	reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+	reactJsxRuntime_production.jsx = jsxProd;
+	reactJsxRuntime_production.jsxs = jsxProd;
+	return reactJsxRuntime_production;
+}
+
+var reactJsxRuntime_development = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_development;
+
+function requireReactJsxRuntime_development () {
+	if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+	hasRequiredReactJsxRuntime_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function getComponentNameFromType(type) {
+	      if (null == type) return null;
+	      if ("function" === typeof type)
+	        return type.$$typeof === REACT_CLIENT_REFERENCE
+	          ? null
+	          : type.displayName || type.name || null;
+	      if ("string" === typeof type) return type;
+	      switch (type) {
+	        case REACT_FRAGMENT_TYPE:
+	          return "Fragment";
+	        case REACT_PROFILER_TYPE:
+	          return "Profiler";
+	        case REACT_STRICT_MODE_TYPE:
+	          return "StrictMode";
+	        case REACT_SUSPENSE_TYPE:
+	          return "Suspense";
+	        case REACT_SUSPENSE_LIST_TYPE:
+	          return "SuspenseList";
+	        case REACT_ACTIVITY_TYPE:
+	          return "Activity";
+	      }
+	      if ("object" === typeof type)
+	        switch (
+	          ("number" === typeof type.tag &&
+	            console.error(
+	              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+	            ),
+	          type.$$typeof)
+	        ) {
+	          case REACT_PORTAL_TYPE:
+	            return "Portal";
+	          case REACT_CONTEXT_TYPE:
+	            return (type.displayName || "Context") + ".Provider";
+	          case REACT_CONSUMER_TYPE:
+	            return (type._context.displayName || "Context") + ".Consumer";
+	          case REACT_FORWARD_REF_TYPE:
+	            var innerType = type.render;
+	            type = type.displayName;
+	            type ||
+	              ((type = innerType.displayName || innerType.name || ""),
+	              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
+	            return type;
+	          case REACT_MEMO_TYPE:
+	            return (
+	              (innerType = type.displayName || null),
+	              null !== innerType
+	                ? innerType
+	                : getComponentNameFromType(type.type) || "Memo"
+	            );
+	          case REACT_LAZY_TYPE:
+	            innerType = type._payload;
+	            type = type._init;
+	            try {
+	              return getComponentNameFromType(type(innerType));
+	            } catch (x) {}
+	        }
+	      return null;
+	    }
+	    function testStringCoercion(value) {
+	      return "" + value;
+	    }
+	    function checkKeyStringCoercion(value) {
+	      try {
+	        testStringCoercion(value);
+	        var JSCompiler_inline_result = !1;
+	      } catch (e) {
+	        JSCompiler_inline_result = true;
+	      }
+	      if (JSCompiler_inline_result) {
+	        JSCompiler_inline_result = console;
+	        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+	        var JSCompiler_inline_result$jscomp$0 =
+	          ("function" === typeof Symbol &&
+	            Symbol.toStringTag &&
+	            value[Symbol.toStringTag]) ||
+	          value.constructor.name ||
+	          "Object";
+	        JSCompiler_temp_const.call(
+	          JSCompiler_inline_result,
+	          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+	          JSCompiler_inline_result$jscomp$0
+	        );
+	        return testStringCoercion(value);
+	      }
+	    }
+	    function getTaskName(type) {
+	      if (type === REACT_FRAGMENT_TYPE) return "<>";
+	      if (
+	        "object" === typeof type &&
+	        null !== type &&
+	        type.$$typeof === REACT_LAZY_TYPE
+	      )
+	        return "<...>";
+	      try {
+	        var name = getComponentNameFromType(type);
+	        return name ? "<" + name + ">" : "<...>";
+	      } catch (x) {
+	        return "<...>";
+	      }
+	    }
+	    function getOwner() {
+	      var dispatcher = ReactSharedInternals.A;
+	      return null === dispatcher ? null : dispatcher.getOwner();
+	    }
+	    function UnknownOwner() {
+	      return Error("react-stack-top-frame");
+	    }
+	    function hasValidKey(config) {
+	      if (hasOwnProperty.call(config, "key")) {
+	        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+	        if (getter && getter.isReactWarning) return false;
+	      }
+	      return void 0 !== config.key;
+	    }
+	    function defineKeyPropWarningGetter(props, displayName) {
+	      function warnAboutAccessingKey() {
+	        specialPropKeyWarningShown ||
+	          ((specialPropKeyWarningShown = true),
+	          console.error(
+	            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+	            displayName
+	          ));
+	      }
+	      warnAboutAccessingKey.isReactWarning = true;
+	      Object.defineProperty(props, "key", {
+	        get: warnAboutAccessingKey,
+	        configurable: true
+	      });
+	    }
+	    function elementRefGetterWithDeprecationWarning() {
+	      var componentName = getComponentNameFromType(this.type);
+	      didWarnAboutElementRef[componentName] ||
+	        ((didWarnAboutElementRef[componentName] = true),
+	        console.error(
+	          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+	        ));
+	      componentName = this.props.ref;
+	      return void 0 !== componentName ? componentName : null;
+	    }
+	    function ReactElement(
+	      type,
+	      key,
+	      self,
+	      source,
+	      owner,
+	      props,
+	      debugStack,
+	      debugTask
+	    ) {
+	      self = props.ref;
+	      type = {
+	        $$typeof: REACT_ELEMENT_TYPE,
+	        type: type,
+	        key: key,
+	        props: props,
+	        _owner: owner
+	      };
+	      null !== (void 0 !== self ? self : null)
+	        ? Object.defineProperty(type, "ref", {
+	            enumerable: false,
+	            get: elementRefGetterWithDeprecationWarning
+	          })
+	        : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+	      type._store = {};
+	      Object.defineProperty(type._store, "validated", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: 0
+	      });
+	      Object.defineProperty(type, "_debugInfo", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: null
+	      });
+	      Object.defineProperty(type, "_debugStack", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: debugStack
+	      });
+	      Object.defineProperty(type, "_debugTask", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: debugTask
+	      });
+	      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+	      return type;
+	    }
+	    function jsxDEVImpl(
+	      type,
+	      config,
+	      maybeKey,
+	      isStaticChildren,
+	      source,
+	      self,
+	      debugStack,
+	      debugTask
+	    ) {
+	      var children = config.children;
+	      if (void 0 !== children)
+	        if (isStaticChildren)
+	          if (isArrayImpl(children)) {
+	            for (
+	              isStaticChildren = 0;
+	              isStaticChildren < children.length;
+	              isStaticChildren++
+	            )
+	              validateChildKeys(children[isStaticChildren]);
+	            Object.freeze && Object.freeze(children);
+	          } else
+	            console.error(
+	              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+	            );
+	        else validateChildKeys(children);
+	      if (hasOwnProperty.call(config, "key")) {
+	        children = getComponentNameFromType(type);
+	        var keys = Object.keys(config).filter(function (k) {
+	          return "key" !== k;
+	        });
+	        isStaticChildren =
+	          0 < keys.length
+	            ? "{key: someKey, " + keys.join(": ..., ") + ": ...}"
+	            : "{key: someKey}";
+	        didWarnAboutKeySpread[children + isStaticChildren] ||
+	          ((keys =
+	            0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}"),
+	          console.error(
+	            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+	            isStaticChildren,
+	            children,
+	            keys,
+	            children
+	          ),
+	          (didWarnAboutKeySpread[children + isStaticChildren] = true));
+	      }
+	      children = null;
+	      void 0 !== maybeKey &&
+	        (checkKeyStringCoercion(maybeKey), (children = "" + maybeKey));
+	      hasValidKey(config) &&
+	        (checkKeyStringCoercion(config.key), (children = "" + config.key));
+	      if ("key" in config) {
+	        maybeKey = {};
+	        for (var propName in config)
+	          "key" !== propName && (maybeKey[propName] = config[propName]);
+	      } else maybeKey = config;
+	      children &&
+	        defineKeyPropWarningGetter(
+	          maybeKey,
+	          "function" === typeof type
+	            ? type.displayName || type.name || "Unknown"
+	            : type
+	        );
+	      return ReactElement(
+	        type,
+	        children,
+	        self,
+	        source,
+	        getOwner(),
+	        maybeKey,
+	        debugStack,
+	        debugTask
+	      );
+	    }
+	    function validateChildKeys(node) {
+	      "object" === typeof node &&
+	        null !== node &&
+	        node.$$typeof === REACT_ELEMENT_TYPE &&
+	        node._store &&
+	        (node._store.validated = 1);
+	    }
+	    var React$1 = React,
+	      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+	      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+	      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+	      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+	      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+	    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+	      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+	      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+	      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+	      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+	      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+	      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+	      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+	      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+	      ReactSharedInternals =
+	        React$1.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+	      hasOwnProperty = Object.prototype.hasOwnProperty,
+	      isArrayImpl = Array.isArray,
+	      createTask = console.createTask
+	        ? console.createTask
+	        : function () {
+	            return null;
+	          };
+	    React$1 = {
+	      "react-stack-bottom-frame": function (callStackForError) {
+	        return callStackForError();
+	      }
+	    };
+	    var specialPropKeyWarningShown;
+	    var didWarnAboutElementRef = {};
+	    var unknownOwnerDebugStack = React$1["react-stack-bottom-frame"].bind(
+	      React$1,
+	      UnknownOwner
+	    )();
+	    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+	    var didWarnAboutKeySpread = {};
+	    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+	    reactJsxRuntime_development.jsx = function (type, config, maybeKey, source, self) {
+	      var trackActualOwner =
+	        1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+	      return jsxDEVImpl(
+	        type,
+	        config,
+	        maybeKey,
+	        false,
+	        source,
+	        self,
+	        trackActualOwner
+	          ? Error("react-stack-top-frame")
+	          : unknownOwnerDebugStack,
+	        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+	      );
+	    };
+	    reactJsxRuntime_development.jsxs = function (type, config, maybeKey, source, self) {
+	      var trackActualOwner =
+	        1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+	      return jsxDEVImpl(
+	        type,
+	        config,
+	        maybeKey,
+	        true,
+	        source,
+	        self,
+	        trackActualOwner
+	          ? Error("react-stack-top-frame")
+	          : unknownOwnerDebugStack,
+	        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+	      );
+	    };
+	  })();
+	return reactJsxRuntime_development;
+}
+
+var hasRequiredJsxRuntime;
+
+function requireJsxRuntime () {
+	if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+	hasRequiredJsxRuntime = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  jsxRuntime.exports = requireReactJsxRuntime_production();
+	} else {
+	  jsxRuntime.exports = requireReactJsxRuntime_development();
+	}
+	return jsxRuntime.exports;
+}
+
+var jsxRuntimeExports = requireJsxRuntime();
+
+var CLASS_ROOT$3 = 'accordion';
+var Accordion = function Accordion(_a) {
+  var className = _a.className,
+    children = _a.children,
+    _a$headingLevel = _a.headingLevel,
+    headingLevel = _a$headingLevel === void 0 ? 3 : _a$headingLevel,
+    size = _a.size,
+    isEnclosed = _a.isEnclosed,
+    other = __rest(_a, ["className", "children", "headingLevel", "size", "isEnclosed"]);
+  var accordionRef = useRef(null);
+  var classes = cx(CLASS_ROOT$3, _defineProperty(_defineProperty({}, "".concat(CLASS_ROOT$3, "--").concat(size), size), "".concat(CLASS_ROOT$3, "--enclosed"), isEnclosed), className);
+  useEffect(function () {
+    if (accordionRef.current) {
+      var accordion = new Accordion$1(accordionRef.current);
+      return function () {
+        accordion.destroy();
+      };
+    }
+  }, []);
+  return /*#__PURE__*/jsxRuntimeExports.jsx(HeadingContext.Provider, {
+    value: headingLevel,
+    children: /*#__PURE__*/jsxRuntimeExports.jsx("ul", _objectSpread2(_objectSpread2({
+      "data-accordion": true,
+      className: classes,
+      ref: accordionRef
+    }, other), {}, {
+      children: children
+    }))
+  });
+};
+Accordion.displayName = 'Accordion';
+
+var idx = 0;
+var uuid = function uuid() {
+  return idx += 1;
+};
+/**
+ * Generates a unique ID string with an optional name prefix
+ * @param name Optional prefix for the ID
+ * @returns A unique ID string
+ */
+function generateId(name) {
+  return "id".concat('', "-").concat(uuid());
+}
+
+var SpritePathContext = /*#__PURE__*/React.createContext("/sprite.svg");
+
+var CLASS_ROOT$2 = "icon";
+var Icon = function Icon(_a) {
+  var className = _a.className,
+    alt = _a.alt,
+    color = _a.color,
+    name = _a.name,
+    size = _a.size,
+    _a$spritePath = _a.spritePath,
+    spritePath = _a$spritePath === void 0 ? "/sprite.svg" : _a$spritePath,
+    other = __rest(_a, ["className", "alt", "color", "name", "size", "spritePath"]);
+  var contextPath = useContext(SpritePathContext);
+  var classes = cx(CLASS_ROOT$2, _defineProperty(_defineProperty({}, "".concat(CLASS_ROOT$2, "--").concat(size), size), "".concat(CLASS_ROOT$2, "--").concat(color), color), className);
+  return /*#__PURE__*/jsxRuntimeExports.jsxs("svg", _objectSpread2(_objectSpread2({
+    className: classes,
+    "aria-hidden": alt !== undefined ? undefined : "true",
+    role: alt !== undefined ? "img" : undefined
+  }, other), {}, {
+    children: [alt !== undefined && alt.length > 0 && /*#__PURE__*/jsxRuntimeExports.jsx("title", {
+      children: alt
+    }), /*#__PURE__*/jsxRuntimeExports.jsx("use", {
+      xlinkHref: spritePath !== "/sprite.svg" || typeof contextPath === "undefined" ? "".concat(spritePath, "#").concat(name) : "".concat(contextPath, "#").concat(name)
+    })]
+  }));
+};
+Icon.displayName = "Icon";
+
+var CLASS_ROOT$1 = 'accordion';
+var AccordionHeader = function AccordionHeader(_a) {
+  var className = _a.className,
+    title = _a.title,
+    id = _a.id,
+    isActive = _a.isActive,
+    other = __rest(_a, ["className", "title", "id", "isActive"]);
+  var headingLevel = React.useContext(HeadingContext);
+  var Heading = "h".concat(headingLevel || 3);
+  return /*#__PURE__*/jsxRuntimeExports.jsx(Heading, {
+    className: cx("".concat(CLASS_ROOT$1, "__header"), className),
+    children: /*#__PURE__*/jsxRuntimeExports.jsxs("button", _objectSpread2(_objectSpread2({
+      type: "button",
+      "aria-expanded": isActive,
+      className: "".concat(CLASS_ROOT$1, "__button"),
+      "aria-controls": "".concat(id, "-section"),
+      id: id,
+      "data-accordion-toggle": true
+    }, other), {}, {
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("span", {
+        className: "accordion__title",
+        children: title
+      }), /*#__PURE__*/jsxRuntimeExports.jsx(Icon, {
+        className: "".concat(CLASS_ROOT$1, "__icon"),
+        name: "chevron-down",
+        size: "medium"
+      })]
+    }))
+  });
+};
+AccordionHeader.displayName = 'AccordionHeader';
+
+var CLASS_ROOT = 'accordion__item';
+var AccordionItem = function AccordionItem(_a) {
+  var id = _a.id,
+    isActive = _a.isActive,
+    title = _a.title,
+    renderHeader = _a.renderHeader,
+    children = _a.children,
+    className = _a.className,
+    other = __rest(_a, ["id", "isActive", "title", "renderHeader", "children", "className"]);
+  var classes = cx(CLASS_ROOT, className);
+  var currentId = id || generateId();
+  return /*#__PURE__*/jsxRuntimeExports.jsxs("li", {
+    className: classes,
+    children: [renderHeader ? renderHeader(title, currentId, isActive || false) : /*#__PURE__*/jsxRuntimeExports.jsx(AccordionHeader, _objectSpread2({
+      id: currentId,
+      isActive: isActive,
+      title: title
+    }, other)), isActive ? /*#__PURE__*/jsxRuntimeExports.jsx("div", {
+      id: "".concat(currentId, "-section"),
+      "aria-labelledby": currentId,
+      className: cx('accordion__body', {
+        'is-active': isActive
+      }),
+      children: children
+    }) : /*#__PURE__*/jsxRuntimeExports.jsx("div", {
+      id: "".concat(currentId, "-section"),
+      "aria-labelledby": currentId,
+      className: cx('accordion__body', {
+        'is-active': isActive
+      }),
+      hidden: true,
+      children: children
+    })]
+  });
+};
+AccordionItem.displayName = 'AccordionItem';
+
+export { AccordionItem, Accordion as default };
+//# sourceMappingURL=index.js.map