"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.Button = void 0;
var _react = _interopRequireDefault(require("react"));
var _classnames = _interopRequireDefault(require("classnames"));
var _mergeRefs = _interopRequireDefault(require("../utilities/mergeRefs"));
var _useButtonAnalytics2 = _interopRequireDefault(require("./useButtonAnalytics"));
var _excluded = ["analytics", "analyticsLabelOverride", "analyticsEventTypeOverride", "analyticsParentHeading", "analyticsParentType", "onAnalyticsEvent", "children", "className", "inputRef", "isAlternate", "onClick", "onDark", "size", "variation"];
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
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; }
// Collect all the additional properties that one could supply to a button component
// that will be passed down to whatever element or component is being used. This is
// generally permissive in order to keep the typing simple at the expense of being
// more accurate. In a previous version of this, `OtherProps` was generic so that we
// could extract any props from a custom component that is being passed in; however,
// we are deprecating that prop because it's not actually needed and creates
// unnecessary complexity that we have to maintain.

/**
 * For information about how and when to use this component,
 * [refer to its full documentation page](https://design.cms.gov/components/button/).
 */
var Button = function Button(props) {
  var analytics = props.analytics,
    analyticsLabelOverride = props.analyticsLabelOverride,
    analyticsEventTypeOverride = props.analyticsEventTypeOverride,
    analyticsParentHeading = props.analyticsParentHeading,
    analyticsParentType = props.analyticsParentType,
    onAnalyticsEvent = props.onAnalyticsEvent,
    children = props.children,
    className = props.className,
    inputRef = props.inputRef,
    isAlternate = props.isAlternate,
    onClick = props.onClick,
    onDark = props.onDark,
    size = props.size,
    variation = props.variation,
    otherProps = _objectWithoutProperties(props, _excluded);
  var _useButtonAnalytics = (0, _useButtonAnalytics2.default)(props),
    contentRef = _useButtonAnalytics.contentRef,
    sendButtonEvent = _useButtonAnalytics.sendButtonEvent;
  var ComponentType = props.href ? 'a' : 'button';
  var colorSchemeClass = isAlternate && "ds-c-button--alternate";
  var modeClass = onDark && "ds-c-button--on-dark";
  var sizeClass = size && "ds-c-button--".concat(size);
  var variationClass = variation && "ds-c-button--".concat(variation);
  var allClassNames = (0, _classnames.default)('ds-c-button', colorSchemeClass, modeClass, sizeClass, variationClass, className);
  var attrs = _objectSpread(_objectSpread({}, otherProps), {}, {
    className: allClassNames
  });
  if (ComponentType !== 'button') {
    delete attrs.disabled;
    delete attrs.type;
    if (props.disabled) {
      attrs.role = 'link';
      attrs['aria-disabled'] = true;
      delete attrs.href;
    }
  }
  function handleClick(e) {
    if (!props.disabled) {
      sendButtonEvent();
      if (onClick) {
        onClick(e);
      }
    }
  }
  function handleKeyPress(e) {
    // Trigger onClick on space key event for `<a>` elements
    if (e.key === ' ') {
      handleClick(e);
    }
  }
  return /*#__PURE__*/_react.default.createElement(ComponentType, _extends({
    ref: (0, _mergeRefs.default)([inputRef, contentRef]),
    onClick: handleClick,
    onKeyPress: ComponentType === 'a' ? handleKeyPress : undefined
  }, attrs), children);
};
exports.Button = Button;
Button.defaultProps = {
  isAlternate: false,
  onDark: false,
  type: 'button'
};
var _default = Button;
exports.default = _default;