@planningcenter/tapestry-react 2.10.0-rc.8 → 2.10.0

package/dist/cjs/Button/Button.js

@@ -0,0 +1,319 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.Button = Button;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _system = require("../system");
+
+var _Icon = _interopRequireDefault(require("../Icon"));
+
+var _Link = _interopRequireDefault(require("../Link"));
+
+var _Spinner = _interopRequireDefault(require("../Spinner"));
+
+var _StackView = require("../StackView");
+
+var _Tooltip = _interopRequireDefault(require("../Tooltip"));
+
+var _utils = require("../utils");
+
+var _useAccessibilityViolation = require("../hooks/use-accessibility-violation");
+
+var _designTokens = require("../designTokens");
+
+var _Input = _interopRequireDefault(require("./Input"));
+
+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) { (0, _defineProperty2["default"])(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 Button(_ref) {
+  var children = _ref.children,
+      disabled = _ref.disabled,
+      external = _ref.external,
+      icon = _ref.icon,
+      iconLeft = _ref.iconLeft,
+      iconRight = _ref.iconRight,
+      onClick = _ref.onClick,
+      onKeyDown = _ref.onKeyDown,
+      size = _ref.size,
+      spinner = _ref.spinner,
+      square = _ref.square,
+      _ref$theme = _ref.theme,
+      theme = _ref$theme === void 0 ? 'default' : _ref$theme,
+      title = _ref.title,
+      to = _ref.to,
+      tooltip = _ref.tooltip,
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? 'button' : _ref$type,
+      variant = _ref.variant,
+      restProps = (0, _objectWithoutPropertiesLoose2["default"])(_ref, ["children", "disabled", "external", "icon", "iconLeft", "iconRight", "onClick", "onKeyDown", "size", "spinner", "square", "theme", "title", "to", "tooltip", "type", "variant"]);
+  var buttonThemes = (0, _system.useThemeValue)('button.themes');
+
+  var _useBoxSize = (0, _system.useBoxSize)(size),
+      boxSize = _useBoxSize.boxSize,
+      fontSize = _useBoxSize.fontSize,
+      lineHeight = _useBoxSize.lineHeight,
+      paddingHorizontal = _useBoxSize.paddingHorizontal,
+      paddingHorizontalDense = _useBoxSize.paddingHorizontalDense,
+      paddingVertical = _useBoxSize.paddingVertical;
+
+  var buttonProps = {
+    alignment: 'center',
+    as: restProps.href || to ? 'a' : 'button',
+    axis: 'horizontal',
+    distribution: 'center',
+    fontSize: fontSize,
+    fontWeight: 700,
+    inline: true,
+    lineHeight: lineHeight,
+    position: 'relative',
+    radius: _designTokens.designTokens.button.borderRadius,
+    strokeAlign: 'inside',
+    strokeWeight: 1,
+    userSelect: 'none',
+    zIndex: 1,
+    type: type
+  };
+  var spinnerColor;
+
+  if (theme) {
+    var buttonTheme = buttonThemes[theme];
+
+    if (buttonTheme) {
+      var buttonThemeVariant = buttonTheme[variant || 'fill'];
+
+      if (buttonThemeVariant) {
+        buttonProps = _objectSpread(_objectSpread({}, buttonProps), buttonThemeVariant);
+      } else {
+        console.warn("Could not find \"" + variant + "\" in \"" + theme + "\" theme. Check your ThemeProvider and make sure \"" + variant + "\" variant exists in \"" + theme + "\".");
+      }
+    } else if (theme === 'false') {
+      console.warn("The string \"false\" is not a valid theme. Please pass a boolean %cfalse%c instead.", 'color:red', 'color:inherit');
+    } else {
+      console.warn("Could not find \"" + theme + "\" in button.themes. Check your ThemeProvider and make sure \"" + theme + "\" exists.");
+    }
+  } // normalize strings that should end up as objects
+
+
+  if (typeof icon === 'string') {
+    icon = {
+      name: icon
+    };
+  }
+
+  if (typeof iconLeft === 'string') {
+    iconLeft = {
+      name: iconLeft
+    };
+  }
+
+  if (typeof iconRight === 'string') {
+    iconRight = {
+      name: iconRight
+    };
+  }
+
+  if (typeof tooltip === 'string') {
+    tooltip = {
+      title: tooltip
+    };
+  } // if using an icon only button, apply dense padding and possibly an aria label
+
+
+  if (icon) {
+    paddingHorizontal = paddingHorizontalDense;
+    buttonProps['aria-label'] = tooltip ? tooltip['title'] : title;
+  } // square width and height if applicable props present
+
+
+  if (square) {
+    buttonProps.width = boxSize;
+    buttonProps.height = boxSize;
+  } else if (icon) {
+    buttonProps.minWidth = boxSize;
+    buttonProps.minHeight = boxSize;
+  } // handle padding based on the incoming radius or whether icons are present or not
+
+
+  if (restProps['radius'] === 'pill') {
+    buttonProps.paddingHorizontal = paddingHorizontal * 1.25;
+  } else if (restProps['radius'] === 'pill-left') {
+    buttonProps.paddingLeft = paddingHorizontal * 1.25;
+    buttonProps.paddingRight = paddingHorizontal;
+  } else if (restProps['radius'] === 'pill-right') {
+    buttonProps.paddingLeft = paddingHorizontal;
+    buttonProps.paddingRight = paddingHorizontal * 1.25;
+  } else if (!(icon && !iconLeft && !iconRight)) {
+    buttonProps.paddingHorizontal = paddingHorizontal;
+    buttonProps.paddingVertical = paddingVertical;
+  } // clear text and/or icons when spinner is present
+
+
+  if (spinner) {
+    spinnerColor = buttonProps.color;
+    buttonProps.color = 'transparent';
+
+    if (icon) {
+      icon['color'] = 'transparent';
+    }
+
+    if (iconLeft) {
+      iconLeft['color'] = 'transparent';
+    }
+
+    if (iconRight) {
+      iconRight['color'] = 'transparent';
+    }
+  }
+
+  if (disabled) {
+    var themeData = buttonThemes[theme];
+
+    if (themeData) {
+      var variantData = themeData[variant];
+
+      if (variantData && variantData.disabled) {
+        buttonProps = _objectSpread(_objectSpread({}, buttonProps), variantData.disabled);
+      } else {
+        buttonProps.opacity = 0.65;
+      }
+    }
+
+    buttonProps['aria-disabled'] = true;
+    buttonProps.cursor = 'not-allowed';
+
+    buttonProps.onClick = function (event) {
+      return event.preventDefault();
+    };
+
+    buttonProps.onKeyDown = function (event) {
+      if (event.key === 'Enter' || event.key === ' ') {
+        event.preventDefault();
+      }
+    };
+  } // don't apply hover/active styles or events when disabled or spinner is present
+
+
+  if (disabled || spinner) {
+    buttonProps.hover = undefined;
+    buttonProps.active = undefined;
+  } else {
+    buttonProps.focus = _objectSpread({
+      zIndex: 5
+    }, buttonProps.focus);
+    buttonProps.cursor = 'pointer';
+    buttonProps.touchAction = 'manipulation';
+    buttonProps.onClick = onClick;
+
+    buttonProps.onKeyDown = function (event) {
+      if (onClick && (event.key === 'Enter' || event.key === ' ')) {
+        event.preventDefault();
+        onClick(event);
+      }
+
+      if (onKeyDown) {
+        onKeyDown(event);
+      }
+    };
+  } // apply rel and target for external links
+
+
+  if (external) {
+    buttonProps.rel = 'noopener noreferrer';
+    buttonProps.target = '_blank';
+  } // apply href value when specified
+
+
+  if (to) {
+    restProps['href'] = to;
+  } // remove `type` if either `to` or `href` is specified
+
+
+  if (to || restProps.href) {
+    buttonProps = _objectSpread(_objectSpread({}, buttonProps), {}, {
+      type: null
+    });
+  } // apply stroke defaults and higher z-index when hovering to show outline in group properly
+
+
+  if (variant === 'outline') {
+    buttonProps = _objectSpread(_objectSpread({}, buttonProps), {}, {
+      hover: _objectSpread({
+        strokeAlign: 'inside',
+        strokeWeight: 1,
+        zIndex: 2
+      }, buttonProps.hover)
+    });
+  } // pass to if as is defined
+
+
+  if (restProps.as) {
+    buttonProps.to = to; // remove type if it is not a button
+
+    if (restProps.as !== 'button') {
+      buttonProps = _objectSpread(_objectSpread({}, buttonProps), {}, {
+        type: null
+      });
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (icon && !(title || tooltip && tooltip.title)) {
+      var _useAccessibilityViol = (0, _useAccessibilityViolation.useAccessibilityViolation)( /*#__PURE__*/React.createElement(React.Fragment, null, "Icon only buttons must define either a", ' ', /*#__PURE__*/React.createElement(_Link["default"], {
+        external: true,
+        to: "https://planningcenter.github.io/tapestry-react/button#tooltip",
+        weight: 700
+      }, "tooltip"), ' ', "or", ' ', /*#__PURE__*/React.createElement(_Link["default"], {
+        external: true,
+        to: "https://planningcenter.github.io/tapestry-react/button#title",
+        weight: 700
+      }, "title"), ' ', "prop."), "Tapestry-React: <Button/> icon only buttons must define either a \"tooltip\" or \"title\" prop for proper accessibility."),
+          tooltipProps = _useAccessibilityViol.tooltipProps,
+          wrapperProps = _useAccessibilityViol.wrapperProps;
+
+      tooltip = tooltipProps;
+      restProps = (0, _utils.mergeProps)(restProps, wrapperProps);
+    }
+
+    if (buttonProps.type && restProps.as && restProps.as !== 'button') {
+      console.log("Tapestry-React: <Button/> type prop is only supported by <button> and not <" + restProps.as + ">.");
+    }
+  }
+
+  return /*#__PURE__*/React.createElement(_Tooltip["default"], tooltip, /*#__PURE__*/React.createElement(_StackView.StackView, (0, _extends2["default"])({}, buttonProps, restProps, {
+    css: {
+      '&:focus-visible': _objectSpread({}, buttonProps.focusVisible)
+    }
+  }), iconLeft && /*#__PURE__*/React.createElement(_Icon["default"], (0, _extends2["default"])({
+    size: size,
+    color: buttonProps.color,
+    marginRight: paddingHorizontalDense
+  }, iconLeft)), icon ? /*#__PURE__*/React.createElement(_Icon["default"], (0, _extends2["default"])({
+    size: size,
+    color: buttonProps.color
+  }, icon)) : title || children, iconRight && /*#__PURE__*/React.createElement(_Icon["default"], (0, _extends2["default"])({
+    size: size,
+    color: buttonProps.color,
+    marginLeft: paddingHorizontalDense
+  }, iconRight)), spinner && /*#__PURE__*/React.createElement(_Spinner["default"], (0, _extends2["default"])({
+    size: size,
+    color: spinnerColor
+  }, spinner, {
+    center: true
+  }))));
+}
+
+Button.Input = _Input["default"];

package/dist/cjs/Button/Button.test.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _react2 = require("@testing-library/react");
+
+var _Button = require("./Button");
+
+it("should render as <button> with type=\"button\" by default", function () {
+  var _render = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, null)),
+      container = _render.container;
+
+  var button = container.querySelector('button');
+  expect(button.getAttribute('type')).toEqual('button');
+});
+it("should render as <button> with type=\"submit\"", function () {
+  var _render2 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    type: "submit"
+  })),
+      container = _render2.container;
+
+  var button = container.querySelector('button');
+  expect(button.getAttribute('type')).toEqual('submit');
+});
+it("if \"disabled\" prop is provided, set \"aria-disabled\" attribute", function () {
+  var _render3 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    disabled: true
+  })),
+      container = _render3.container;
+
+  var button = container.querySelector('button');
+  expect(button.getAttribute("aria-disabled")).toEqual("true");
+  expect(button.disabled).toBe(false);
+});
+it("if \"disabled\" prop is provided, prevent \"Click\" event from firing", function () {
+  var _render4 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    disabled: true
+  })),
+      container = _render4.container;
+
+  var button = container.querySelector('button');
+
+  var clickEvent = _react2.createEvent.click(button);
+
+  (0, _react2.fireEvent)(button, clickEvent);
+  expect(clickEvent.defaultPrevented).toBe(true);
+});
+it("if \"disabled\" prop is provided, prevent keyDown \"Enter\" event from firing", function () {
+  var _render5 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    disabled: true
+  })),
+      container = _render5.container;
+
+  var button = container.querySelector('button');
+
+  var keyDownEvent = _react2.createEvent.keyDown(button, {
+    key: 'Enter'
+  });
+
+  (0, _react2.fireEvent)(button, keyDownEvent);
+  expect(keyDownEvent.defaultPrevented).toBe(true);
+});
+it("if \"disabled\" prop is provided, prevent keyDown \"Space\" event from firing", function () {
+  var _render6 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    disabled: true
+  })),
+      container = _render6.container;
+
+  var button = container.querySelector('button');
+
+  var keyDownEvent = _react2.createEvent.keyDown(button, {
+    key: ' '
+  });
+
+  (0, _react2.fireEvent)(button, keyDownEvent);
+  expect(keyDownEvent.defaultPrevented).toBe(true);
+});
+it("should render title", function () {
+  var title = 'Hello';
+
+  var _render7 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    title: title
+  })),
+      getByText = _render7.getByText;
+
+  getByText(title);
+});
+it("should render <a> without a type if \"to\" is provided", function () {
+  var _render8 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    to: "#"
+  })),
+      container = _render8.container;
+
+  var button = container.querySelector('a');
+  expect(button.getAttribute('type')).toBeNull();
+});
+it("should render <a> without a type if \"href\" is provided", function () {
+  var _render9 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    href: "#"
+  })),
+      container = _render9.container;
+
+  var button = container.querySelector('a');
+  expect(button.getAttribute('type')).toBeNull();
+});
+it("should render <a> with \"href\" if \"to\" is specifed", function () {
+  var _render10 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    to: "#"
+  })),
+      container = _render10.container;
+
+  var button = container.querySelector('a');
+  expect(button.getAttribute('href')).toEqual('#');
+});
+it("should render href and external link values", function () {
+  var title = 'Hello';
+
+  var _render11 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    external: true,
+    title: title,
+    to: "https://www.planningcenter.com"
+  })),
+      getByText = _render11.getByText;
+
+  var button = getByText(title);
+  expect(button.getAttribute('href')).toEqual('https://www.planningcenter.com');
+  expect(button.getAttribute('rel')).toEqual('noopener noreferrer');
+  expect(button.getAttribute('target')).toEqual('_blank');
+});
+it("should call onClick when clicked or Enter or Space key is pressed", function () {
+  var onClick = jest.fn();
+
+  var _render12 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, {
+    onClick: onClick
+  })),
+      container = _render12.container;
+
+  _react2.fireEvent.click(container.firstChild);
+
+  expect(onClick).toHaveBeenCalledTimes(1);
+});
+it("should not call onClick when Enter or Space key is pressed and onClick isn't present", function () {
+  var _render13 = (0, _react2.render)( /*#__PURE__*/_react["default"].createElement(_Button.Button, null)),
+      container = _render13.container;
+
+  _react2.fireEvent.keyDown(container.firstChild, {
+    key: 'Enter'
+  });
+
+  _react2.fireEvent.keyDown(container.firstChild, {
+    key: 'Space'
+  });
+});

package/dist/cjs/Button/Input.js

@@ -0,0 +1,180 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _tabbable2 = require("tabbable");
+
+var _resizeObserverPolyfill = _interopRequireDefault(require("resize-observer-polyfill"));
+
+var _Box = require("../Box");
+
+var _system = require("../system");
+
+var _utils = require("../utils");
+
+var _Button = require("./Button");
+
+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) { (0, _defineProperty2["default"])(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 getFixedValue(value) {
+  // Safari doesn't like sub pixels
+  return parseInt(value.toFixed(0), 10) + 1;
+}
+
+var ButtonInput = /*#__PURE__*/(0, _react.forwardRef)(function (_ref, ref) {
+  var children = _ref.children,
+      style = _ref.style,
+      size = _ref.size,
+      onOpen = _ref.onOpen,
+      onClose = _ref.onClose,
+      restProps = (0, _objectWithoutPropertiesLoose2["default"])(_ref, ["children", "style", "size", "onOpen", "onClose"]);
+  var containerRef = (0, _react.useRef)();
+  var inputRef = (0, _react.useRef)();
+  var buttonRef = (0, _react.useRef)();
+
+  var _useState = (0, _react.useState)(false),
+      isOpen = _useState[0],
+      setOpen = _useState[1];
+
+  var _useBoxSize = (0, _system.useBoxSize)(size),
+      boxSize = _useBoxSize.boxSize;
+
+  var containerProps = {
+    innerRef: containerRef,
+    height: boxSize,
+    position: 'relative',
+    overflow: 'hidden',
+    transition: 'width 200ms cubic-bezier(.02,.8,.38,1)'
+  };
+  var inputContainerProps = {
+    innerRef: inputRef,
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    left: 0,
+    opacity: isOpen ? 1 : 0,
+    transition: 'opacity 180ms ease'
+  };
+  var inputProps = {
+    size: size,
+    secondaryStroke: false,
+    disabled: !isOpen,
+    onBlur: function onBlur() {
+      var input = inputRef.current.querySelector('input');
+
+      if (input.value.length === 0) {
+        close();
+      }
+    },
+    onKeyDown: function onKeyDown(event) {
+      if (event.key === 'Escape') {
+        close();
+      }
+    }
+  };
+  var buttonContainerProps = {
+    innerRef: buttonRef,
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    left: 0,
+    opacity: isOpen ? 0 : 1,
+    transition: 'opacity 180ms ease'
+  };
+
+  var buttonProps = _objectSpread(_objectSpread({}, restProps), {}, {
+    size: size,
+    disabled: isOpen,
+    onClick: open
+  });
+
+  function open() {
+    setOpen(true);
+    var input = inputRef.current.querySelector('input');
+
+    if (input && input.focus) {
+      setTimeout(function () {
+        return input.focus();
+      });
+    }
+
+    if (onOpen) {
+      onOpen();
+    }
+  }
+
+  function close() {
+    setOpen(false);
+
+    var _tabbable = (0, _tabbable2.tabbable)(buttonRef.current),
+        button = _tabbable[0];
+
+    if (button && button.focus) {
+      setTimeout(function () {
+        return button.focus();
+      });
+    }
+
+    if (onClose) {
+      onClose();
+    }
+  }
+
+  function transition() {
+    var container = containerRef.current;
+    var inputChild = inputRef.current.firstChild;
+    var buttonChild = buttonRef.current.firstChild;
+    inputChild.style.width = '';
+    buttonChild.style.width = '';
+    var inputRect = (0, _utils.getRect)(inputChild, {
+      clone: true
+    });
+    var buttonRect = (0, _utils.getRect)(buttonChild, {
+      clone: true
+    });
+    var containerWidth = getFixedValue(isOpen ? inputRect.width : buttonRect.width);
+    container.style.width = containerWidth + 'px';
+    inputChild.style.width = '100%';
+    buttonChild.style.width = '100%';
+  }
+
+  (0, _react.useLayoutEffect)(function () {
+    transition();
+    var ro = new _resizeObserverPolyfill["default"](transition);
+    ro.observe(isOpen ? inputRef.current : buttonRef.current);
+    return function () {
+      ro.disconnect();
+    };
+  }, [isOpen]);
+  (0, _react.useImperativeHandle)(ref, function () {
+    return {
+      open: open,
+      close: close
+    };
+  }, []); // @ts-ignore
+
+  var button = /*#__PURE__*/_react["default"].createElement(_Button.Button, buttonProps);
+
+  return /*#__PURE__*/_react["default"].createElement(_Box.Box, containerProps, /*#__PURE__*/_react["default"].createElement(_Box.Box, inputContainerProps, typeof children === 'function' ? children({
+    inputProps: inputProps,
+    isOpen: isOpen,
+    open: open,
+    close: close
+  }) : /*#__PURE__*/(0, _react.cloneElement)(_react.Children.only(children), inputProps)), /*#__PURE__*/_react["default"].createElement(_Box.Box, buttonContainerProps, button));
+});
+ButtonInput.displayName = 'Button.Input';
+var _default = ButtonInput;
+exports["default"] = _default;

package/dist/cjs/Button/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+var _exportNames = {};
+exports["default"] = void 0;
+
+var _Button = require("./Button");
+
+exports["default"] = _Button.Button;
+Object.keys(_Button).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Button[key]) return;
+  exports[key] = _Button[key];
+});