@hitachivantara/uikit-react-core 3.52.5

package/dist/legacy/BaseCheckBox/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/BaseCheckBox/styles.js"],"names":["outlineStyles","styles","theme","root","padding","cursor","backgroundColor","hv","palette","atmosphere","atmo3","disabled","pointerEvents","fill","atmo5","focusVisible"],"mappings":";;;;;;;;;;;;;AAAA,SAASA,aAAT,QAA8B,iBAA9B;;AAEA,IAAMC,MAAM,GAAG,SAATA,MAAS,CAACC,KAAD;AAAA,SAAY;AACzBC,IAAAA,IAAI,EAAE;AACJC,MAAAA,OAAO,EAAE,CADL;AAEJC,MAAAA,MAAM,EAAE,SAFJ;AAGJ,iBAAW;AACTC,QAAAA,eAAe,EAAEJ,KAAK,CAACK,EAAN,CAASC,OAAT,CAAiBC,UAAjB,CAA4BC;AADpC;AAHP,KADmB;AAQzBC,IAAAA,QAAQ,EAAE;AACR;AACA,gBAAU;AACRN,QAAAA,MAAM,EAAE,aADA;AAERO,QAAAA,aAAa,EAAE;AAFP,OAFF;AAMR,eAAS;AACP,+BAAuB;AACrBC,UAAAA,IAAI,EAAEX,KAAK,CAACK,EAAN,CAASC,OAAT,CAAiBC,UAAjB,CAA4BK;AADb;AADhB;AAND,KARe;AAqBzBC,IAAAA,YAAY,EAAE;AACZ,iCACKf,aADL;AADY;AArBW,GAAZ;AAAA,CAAf;;AA4BA,eAAeC,MAAf","sourcesContent":["import { outlineStyles } from \"../Focus/styles\";\n\nconst styles = (theme) => ({\n  root: {\n    padding: 0,\n    cursor: \"pointer\",\n    \"&:hover\": {\n      backgroundColor: theme.hv.palette.atmosphere.atmo3,\n    },\n  },\n  disabled: {\n    // ensure more specificity than .MuiButtonBase-root.Mui-disabled and .MuiIconButton-root.Mui-disabled\n    \"$root&\": {\n      cursor: \"not-allowed\",\n      pointerEvents: \"initial\",\n    },\n    \"& svg\": {\n      \"& path:nth-child(2)\": {\n        fill: theme.hv.palette.atmosphere.atmo5,\n      },\n    },\n  },\n\n  focusVisible: {\n    \"& svg\": {\n      ...outlineStyles,\n    },\n  },\n});\n\nexport default styles;\n"],"file":"styles.js"}

package/dist/legacy/BaseDropdown/BaseDropdown.d.ts

@@ -0,0 +1,111 @@
+import * as React from "react";
+import { StandardProps } from "@material-ui/core";
+import { PopperProps } from "@material-ui/core/Popper";
+
+export type HvBaseDropdownClassKey =
+  | "root"
+  | "rootDisabled"
+  | "container"
+  | "header"
+  | "headerOpen"
+  | "headerOpenUp"
+  | "headerOpenDown"
+  | "headerDisabled"
+  | "arrow"
+  | "selection"
+  | "truncate"
+  | "selectionDisabled"
+  | "panel"
+  | "inputExtensionOpen"
+  | "inputExtensionLeftPosition"
+  | "inputExtensionOpenShadow"
+  | "inputExtensionFloatRight"
+  | "inputExtensionFloatLeft";
+
+export interface HvBaseDropdownProps
+  extends StandardProps<
+    React.HTMLAttributes<HTMLDivElement>,
+    HvBaseDropdownClassKey,
+    "placeholder"
+  > {
+  /**
+   * The role of the element that triggers the popup.
+   *
+   * Defaults to "combobox" if `component` and the default
+   * "textbox" header is used, undefined otherwise.
+   */
+  role?: string;
+  /**
+   * Header placeholder.
+   */
+  placeholder?: string | React.ReactNode;
+  /**
+   * If `true` the dropdown is disabled unable to be interacted, if `false` it is enabled.
+   */
+  disabled?: boolean;
+  /**
+   * Disable the portal behavior.
+   * The children stay within it's parent DOM hierarchy.
+   */
+  disablePortal?: boolean;
+  /**
+   * If `true` the dropdown width depends size of content if `false` the width depends on the header size.
+   * Defaults to `false`.
+   */
+  variableWidth?: boolean;
+  /**
+   * If `true` the dropdown starts opened if `false` it starts closed.
+   */
+  expanded?: boolean;
+  /**
+   * When uncontrolled, defines the initial expanded state.
+   */
+  defaultExpanded?: boolean;
+  /**
+   * An object containing props to be wired to the popper component.
+   */
+  popperProps?: Partial<PopperProps>;
+  /**
+   * Node to be rendered.
+   */
+  children?: React.ReactNode;
+  /**
+   * Placement of the dropdown.
+   */
+  placement?: "left" | "right";
+  /**
+   * Replacement for the header component.
+   */
+  component?: React.ReactNode;
+  /**
+   * Adornment to replace the default arrows.
+   */
+  adornment?: React.ReactNode;
+  /**
+   * When dropdown changes the expanded state.
+   */
+  onToggle?: (event: Event) => void;
+  /**
+   * When user click outside the open container.
+   */
+  onClickOutside?: (event: Event) => void;
+  /**
+   * Callback called when the dropdown is opened and ready,
+   * commonly used to set focus to the content.
+   */
+  onContainerCreation: (containerRef: React.Ref<HTMLDivElement>) => void;
+  /**
+   * When expanded dropdown changes position.
+   */
+  onFlip?: (flipped: boolean) => void;
+  /**
+   * Attributes applied to the dropdown header element.
+   */
+  dropdownHeaderProps?: React.HTMLAttributes<HTMLDivElement>;
+  /**
+   * Pass a ref to the dropdown header element.
+   */
+  dropdownHeaderRef?: React.Ref<any>;
+}
+
+export default function HvBaseDropdown(props: HvBaseDropdownProps): JSX.Element | null;

package/dist/legacy/BaseDropdown/BaseDropdown.js

@@ -0,0 +1,520 @@
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["id", "role", "classes", "className", "placeholder", "disabled", "expanded", "defaultExpanded", "placement", "popperProps", "onToggle", "onClickOutside", "onContainerCreation", "disablePortal", "component", "adornment", "children", "variableWidth", "dropdownHeaderProps", "dropdownHeaderRef"],
+    _excluded2 = ["modifiers"];
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.string.anchor.js";
+
+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; }
+
+/* eslint-disable jsx-a11y/no-noninteractive-tabindex */
+import ReactDOM from "react-dom";
+import React, { useState, useCallback, useMemo } from "react";
+import PropTypes from "prop-types";
+import { ClickAwayListener, withStyles } from "@material-ui/core";
+import { usePopper } from "react-popper";
+import maxSize from "popper-max-size-modifier";
+import clsx from "clsx";
+import { DropUpXS, DropDownXS } from "@hitachivantara/uikit-react-icons";
+import { HvTypography, useUniqueId } from "..";
+import { getFirstAndLastFocus, isKeypress, KeyboardCodes, setId, refType, useControlled, useForkRef } from "../utils";
+import styles from "./styles";
+import BaseDropdownContext from "./BaseDropdownContext";
+var Tab = KeyboardCodes.Tab,
+    Enter = KeyboardCodes.Enter,
+    Esc = KeyboardCodes.Esc,
+    Space = KeyboardCodes.Space,
+    ArrowDown = KeyboardCodes.ArrowDown;
+
+var HvBaseDropdown = function HvBaseDropdown(_ref) {
+  var id = _ref.id,
+      role = _ref.role,
+      classes = _ref.classes,
+      className = _ref.className,
+      placeholder = _ref.placeholder,
+      _ref$disabled = _ref.disabled,
+      disabled = _ref$disabled === void 0 ? false : _ref$disabled,
+      expanded = _ref.expanded,
+      _ref$defaultExpanded = _ref.defaultExpanded,
+      defaultExpanded = _ref$defaultExpanded === void 0 ? false : _ref$defaultExpanded,
+      _ref$placement = _ref.placement,
+      placement = _ref$placement === void 0 ? "right" : _ref$placement,
+      _ref$popperProps = _ref.popperProps,
+      popperProps = _ref$popperProps === void 0 ? {} : _ref$popperProps,
+      onToggle = _ref.onToggle,
+      onClickOutside = _ref.onClickOutside,
+      onContainerCreation = _ref.onContainerCreation,
+      _ref$disablePortal = _ref.disablePortal,
+      disablePortal = _ref$disablePortal === void 0 ? false : _ref$disablePortal,
+      component = _ref.component,
+      adornment = _ref.adornment,
+      children = _ref.children,
+      _ref$variableWidth = _ref.variableWidth,
+      variableWidth = _ref$variableWidth === void 0 ? false : _ref$variableWidth,
+      dropdownHeaderProps = _ref.dropdownHeaderProps,
+      dropdownHeaderRefProp = _ref.dropdownHeaderRef,
+      others = _objectWithoutProperties(_ref, _excluded);
+
+  var _useControlled = useControlled(expanded, Boolean(defaultExpanded)),
+      _useControlled2 = _slicedToArray(_useControlled, 2),
+      isOpen = _useControlled2[0],
+      setIsOpen = _useControlled2[1];
+
+  var bottom = placement && "bottom-".concat(placement === "right" ? "start" : "end");
+
+  var _useState = useState(null),
+      _useState2 = _slicedToArray(_useState, 2),
+      referenceElement = _useState2[0],
+      setReferenceElement = _useState2[1];
+
+  var _useState3 = useState({}),
+      _useState4 = _slicedToArray(_useState3, 2),
+      popperMaxSize = _useState4[0],
+      setPopperMaxSize = _useState4[1];
+
+  var handleDropdownHeaderRefProp = useForkRef(dropdownHeaderRefProp, dropdownHeaderProps === null || dropdownHeaderProps === void 0 ? void 0 : dropdownHeaderProps.ref);
+  var handleDropdownHeaderRef = useForkRef(setReferenceElement, handleDropdownHeaderRefProp);
+
+  var _useState5 = useState(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      popperElement = _useState6[0],
+      setPopperElement = _useState6[1];
+
+  var extensionWidth = referenceElement ? referenceElement.offsetWidth : "inherit";
+
+  var _popperProps$modifier = popperProps.modifiers,
+      popperPropsModifiers = _popperProps$modifier === void 0 ? [] : _popperProps$modifier,
+      otherPopperProps = _objectWithoutProperties(popperProps, _excluded2);
+
+  var onFirstUpdate = useCallback(function () {
+    if (onContainerCreation) onContainerCreation(popperElement);
+  }, [onContainerCreation, popperElement]);
+  var widthCalculator = useCallback(function (_ref2) {
+    var state = _ref2.state;
+    // eslint-disable-next-line no-param-reassign
+    state.styles.popper.width = "".concat(state.rects.reference.width, "px");
+  }, []);
+  var widthCalculatorEffect = useCallback(function (_ref3) {
+    var state = _ref3.state;
+    // eslint-disable-next-line no-param-reassign
+    state.elements.popper.style.width = "".concat(state.elements.reference.offsetWidth, "px");
+  }, []);
+  var maxSizeCalculator = useCallback(function (_ref4) {
+    var state = _ref4.state;
+    // The `maxSize` modifier provides this data
+    var _state$modifiersData$ = state.modifiersData.maxSize,
+        width = _state$modifiersData$.width,
+        height = _state$modifiersData$.height;
+
+    if (width !== popperMaxSize.width || height !== popperMaxSize.height) {
+      setPopperMaxSize({
+        width: width,
+        height: height
+      });
+    } // eslint-disable-next-line no-param-reassign
+
+
+    state.styles.popper = _objectSpread(_objectSpread({}, state.styles.popper), {}, {
+      maxWidth: "".concat(width, "px"),
+      maxHeight: "".concat(height, "px")
+    });
+  }, [popperMaxSize]);
+  var modifiers = useMemo(function () {
+    return [{
+      name: "variableWidth",
+      enabled: !variableWidth,
+      phase: "beforeWrite",
+      requires: ["computeStyles"],
+      fn: widthCalculator,
+      effect: widthCalculatorEffect
+    }, maxSize, {
+      name: "applyMaxSize",
+      enabled: true,
+      phase: "beforeWrite",
+      requires: ["maxSize"],
+      fn: maxSizeCalculator
+    }].concat(_toConsumableArray(popperPropsModifiers));
+  }, [maxSizeCalculator, popperPropsModifiers, variableWidth, widthCalculator, widthCalculatorEffect]);
+
+  var _usePopper = usePopper(referenceElement, popperElement, _objectSpread({
+    placement: bottom,
+    modifiers: modifiers,
+    onFirstUpdate: onFirstUpdate
+  }, otherPopperProps)),
+      popperStyles = _usePopper.styles,
+      attributes = _usePopper.attributes;
+
+  var elementId = useUniqueId(id, "hvbasedropdown");
+  var ariaRole = role || (component == null ? "combobox" : undefined);
+  var popperPlacement = "bottom";
+
+  if (attributes.popper) {
+    popperPlacement = attributes.popper["data-popper-placement"];
+  }
+
+  var handleToggle = useCallback(function (event) {
+    if (event && !isKeypress(event, Tab)) {
+      event.preventDefault();
+    } // we are checking specifically for false because if "isKeypress" returns true or undefined it should continue
+
+
+    var notControlKey = [Tab, Enter, Esc, ArrowDown, Space].every(function (key) {
+      return isKeypress(event, key) === false;
+    });
+    var ignoredCombinations = isKeypress(event, Esc) && !isOpen || isKeypress(event, ArrowDown) && isOpen || isKeypress(event, Tab) && !isOpen;
+    if (disabled || notControlKey || ignoredCombinations) return;
+    var newOpen = !isOpen;
+    /* If about to close focus on the header component. */
+
+    var focusHeader = function focusHeader() {
+      if (!newOpen) {
+        // focus-ring won't be visible even if using the keyboard:
+        // https://github.com/WICG/focus-visible/issues/88
+        referenceElement.focus({
+          preventScroll: true
+        });
+      }
+
+      return newOpen;
+    };
+
+    setIsOpen(focusHeader());
+    onToggle === null || onToggle === void 0 ? void 0 : onToggle(event, newOpen);
+  }, [isOpen, disabled, setIsOpen, onToggle, referenceElement]);
+
+  var headerComponent = function () {
+    var _others$ariaLabel, _others$ariaLabelled;
+
+    if (component) {
+      return /*#__PURE__*/React.cloneElement(component, {
+        ref: handleDropdownHeaderRef
+      });
+    }
+
+    return /*#__PURE__*/React.createElement("div", _extends({
+      id: setId(id, "header"),
+      className: clsx(classes.header, isOpen && [classes.headerOpen, popperPlacement.includes("top") && classes.headerOpenUp, popperPlacement.includes("bottom") && classes.headerOpenDown], disabled && classes.headerDisabled),
+      role: ariaRole === "combobox" ? "textbox" : undefined,
+      style: disabled ? {
+        pointerEvents: "none"
+      } : undefined,
+      "aria-controls": isOpen ? setId(elementId, "children-container") : undefined,
+      "aria-label": (_others$ariaLabel = others["aria-label"]) !== null && _others$ariaLabel !== void 0 ? _others$ariaLabel : undefined,
+      "aria-labelledby": (_others$ariaLabelled = others["aria-labelledby"]) !== null && _others$ariaLabelled !== void 0 ? _others$ariaLabelled : undefined,
+      tabIndex: disabled ? -1 : 0,
+      ref: handleDropdownHeaderRef
+    }, dropdownHeaderProps), /*#__PURE__*/React.createElement("div", {
+      className: classes.selection
+    }, placeholder && typeof placeholder === "string" ? /*#__PURE__*/React.createElement(HvTypography, {
+      noWrap: true,
+      className: clsx(classes.placeholder, disabled && classes.selectionDisabled),
+      variant: "placeholderText"
+    }, placeholder) : placeholder), adornment || (isOpen ? /*#__PURE__*/React.createElement(DropUpXS, {
+      iconSize: "XS",
+      className: classes.arrow
+    }) : /*#__PURE__*/React.createElement(DropDownXS, {
+      iconSize: "XS",
+      className: classes.arrow,
+      color: disabled ? "atmo5" : undefined
+    })));
+  }();
+
+  var containerComponent = function () {
+    /**
+     *  Handle keyboard inside children container.
+     */
+    var handleContainerKeyDown = function handleContainerKeyDown(event) {
+      if (isKeypress(event, Esc)) {
+        handleToggle(event);
+      }
+
+      if (isKeypress(event, Tab) && !event.shiftKey) {
+        var focusList = getFirstAndLastFocus(popperElement);
+
+        if (document.activeElement === (focusList === null || focusList === void 0 ? void 0 : focusList.last)) {
+          var _focusList$first;
+
+          event.preventDefault();
+          focusList === null || focusList === void 0 ? void 0 : (_focusList$first = focusList.first) === null || _focusList$first === void 0 ? void 0 : _focusList$first.focus();
+        }
+      }
+    };
+
+    var handleOutside = function handleOutside(event) {
+      var isButtonClick = referenceElement === null || referenceElement === void 0 ? void 0 : referenceElement.contains(event.target);
+
+      if (!isButtonClick) {
+        onClickOutside === null || onClickOutside === void 0 ? void 0 : onClickOutside(event);
+        setIsOpen(false);
+        onToggle === null || onToggle === void 0 ? void 0 : onToggle(event, false);
+      }
+    };
+
+    var container = /*#__PURE__*/React.createElement("div", _extends({
+      role: "tooltip",
+      ref: setPopperElement,
+      className: classes.container,
+      style: popperStyles.popper
+    }, attributes.popper), /*#__PURE__*/React.createElement(ClickAwayListener, {
+      onClickAway: handleOutside
+    }, /*#__PURE__*/React.createElement("div", {
+      onKeyDown: handleContainerKeyDown
+    }, popperPlacement.includes("bottom") && /*#__PURE__*/React.createElement("div", {
+      style: {
+        width: extensionWidth
+      },
+      className: clsx(classes.inputExtensionOpen, popperPlacement.includes("end") && classes.inputExtensionLeftPosition)
+    }), /*#__PURE__*/React.createElement(BaseDropdownContext.Provider, {
+      value: popperMaxSize
+    }, /*#__PURE__*/React.createElement("div", {
+      id: setId(elementId, "children-container"),
+      className: classes.panel
+    }, children)), popperPlacement.includes("top") && /*#__PURE__*/React.createElement("div", {
+      style: {
+        width: extensionWidth
+      },
+      className: clsx(classes.inputExtensionOpen, classes.inputExtensionOpenShadow, popperPlacement.includes("start") && classes.inputExtensionFloatRight, popperPlacement.includes("end") && classes.inputExtensionFloatLeft)
+    }))));
+    if (disablePortal) return container;
+    return /*#__PURE__*/ReactDOM.createPortal(container, document.body);
+  }();
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: classes.root
+  }, /*#__PURE__*/React.createElement("div", _extends({
+    id: id,
+    role: ariaRole,
+    "aria-expanded": !!isOpen,
+    "aria-owns": isOpen ? setId(elementId, "children-container") : undefined,
+    className: clsx(className, classes.anchor, disabled && classes.rootDisabled),
+    onKeyDown: handleToggle,
+    onClick: handleToggle,
+    tabIndex: -1
+  }, others), headerComponent), isOpen ? containerComponent : null);
+};
+
+HvBaseDropdown.propTypes = {
+  /**
+   * Class names to be applied.
+   */
+  className: PropTypes.string,
+
+  /**
+   * Id to be applied to the root node.
+   */
+  id: PropTypes.string,
+
+  /**
+   * The role of the element that triggers the popup.
+   *
+   * Defaults to "combobox" if `component` and the default
+   * "textbox" header is used, undefined otherwise.
+   */
+  role: PropTypes.string,
+
+  /**
+   * A Jss Object used to override or extend the component styles applied.
+   */
+  classes: PropTypes.shape({
+    /**
+     * Styles applied to the root.
+     */
+    root: PropTypes.string,
+
+    /**
+     * Styles applied to the root when disabled.
+     */
+    rootDisabled: PropTypes.string,
+
+    /**
+     * Styles applied to the element that serves as reference for the popper when disabled.
+     */
+    anchor: PropTypes.string,
+
+    /**
+     * Styles applied to the popper element when it is inside the root element hierarchy.
+     */
+    container: PropTypes.string,
+
+    /**
+     * Styles applied to the header
+     */
+    header: PropTypes.string,
+
+    /**
+     * Styles applied to the component when is open.
+     */
+    headerOpen: PropTypes.string,
+
+    /**
+     * Styles applied to the header when the container is opened up.
+     */
+    headerOpenUp: PropTypes.string,
+
+    /**
+     * Styles applied to the header when the container is opened down.
+     */
+    headerOpenDown: PropTypes.string,
+
+    /**
+     * Styles applied to the header when is disable.
+     */
+    headerDisabled: PropTypes.string,
+
+    /**
+     * Styles applied to the arrow
+     */
+    arrow: PropTypes.string,
+
+    /**
+     * Styles applied to the selection
+     */
+    selection: PropTypes.string,
+
+    /**
+     * Styles applied for truncating the container elements.
+     */
+    placeholder: PropTypes.string,
+
+    /**
+     * Styles applied when the selection is disabled.
+     */
+    selectionDisabled: PropTypes.string,
+
+    /**
+     * Styles applied to the dropdown panel.
+     */
+    panel: PropTypes.string,
+
+    /**
+     * Styles applied to the extension when open.
+     */
+    inputExtensionOpen: PropTypes.string,
+
+    /**
+     * Styles applied when position is left.
+     */
+    inputExtensionLeftPosition: PropTypes.string,
+
+    /**
+     * Styles applied to set the shadow when open.
+     */
+    inputExtensionOpenShadow: PropTypes.string,
+
+    /**
+     * Styles applied when position is right and the position is up.
+     */
+    inputExtensionFloatRight: PropTypes.string,
+
+    /**
+     * Styles applied when position is left and the position is up.
+     */
+    inputExtensionFloatLeft: PropTypes.string
+  }).isRequired,
+
+  /**
+   * Header placeholder. String or node.
+   */
+  placeholder: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
+
+  /**
+   * If `true` the dropdown is disabled unable to be interacted, if `false` it is enabled.
+   */
+  disabled: PropTypes.bool,
+
+  /**
+   * Disable the portal behavior.
+   * The children stay within it's parent DOM hierarchy.
+   */
+  disablePortal: PropTypes.bool,
+
+  /**
+   * If `true` the dropdown width depends size of content if `false` the width depends on the header size.
+   * Defaults to `false`.
+   */
+  variableWidth: PropTypes.bool,
+
+  /**
+   * If `true` the dropdown starts opened if `false` it starts closed.
+   */
+  expanded: PropTypes.bool,
+
+  /**
+   * When uncontrolled, defines the initial expanded state.
+   */
+  defaultExpanded: PropTypes.bool,
+
+  /**
+   * An object containing props to be wired to the popper component.
+   */
+  popperProps: PropTypes.shape(),
+
+  /**
+   * Node to be rendered.
+   */
+  children: PropTypes.node,
+
+  /**
+   * Placement of the dropdown.
+   */
+  placement: PropTypes.oneOf(["left", "right"]),
+
+  /**
+   * Replacement for the header component.
+   */
+  component: PropTypes.node,
+
+  /**
+   * Adornment to replace the default arrows.
+   */
+  adornment: PropTypes.node,
+
+  /**
+   * When dropdown changes the expanded state.
+   */
+  onToggle: PropTypes.func,
+
+  /**
+   * When user click outside the open container.
+   */
+  onClickOutside: PropTypes.func,
+
+  /**
+   * Callback called when the dropdown is opened and ready,
+   * commonly used to set focus to the content.
+   */
+  onContainerCreation: PropTypes.func,
+
+  /**
+   * When expanded dropdown flips position.
+   */
+  onFlip: PropTypes.func,
+
+  /**
+   * Attributes applied to the dropdown header element.
+   */
+  dropdownHeaderProps: PropTypes.instanceOf(Object),
+
+  /**
+   * Pass a ref to the dropdown header element.
+   */
+  dropdownHeaderRef: refType
+};
+export default withStyles(styles, {
+  name: "HvBaseDropdown"
+})(HvBaseDropdown);
+//# sourceMappingURL=BaseDropdown.js.map