baseui 12.1.3 → 13.0.0

package/snackbar/snackbar-context.js

@@ -67,7 +67,8 @@ function fallbackHandler() {
   if (process.env.NODE_ENV !== "production") {
     console.warn('Snackbar context not found.');
   }
-}
+} // @ts-ignore
+
 
 var SnackbarContext = /*#__PURE__*/React.createContext({
   enqueue: fallbackHandler,
@@ -81,7 +82,8 @@ function useSnackbar() {
     enqueue: context.enqueue,
     dequeue: context.dequeue
   };
-}
+} // @ts-ignore
+
 
 function usePrevious(value) {
   var ref = React.useRef();
@@ -120,21 +122,24 @@ function SnackbarProvider(_ref) {
       containerHeight = _React$useState6[0],
       setContainerHeight = _React$useState6[1];
 
-  var containerRef = React.useRef(null);
+  var containerRef = React.useRef(null); // @ts-ignore
 
   function enqueue(elementProps) {
     var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDuration;
+    // @ts-ignore
     setSnackbars(function (prev) {
       return [].concat(_toConsumableArray(prev), [{
         elementProps: elementProps,
         duration: duration
       }]);
     });
-  }
+  } // @ts-ignore
+
 
   var prevSnackbars = usePrevious(snackbars) || [];
   React.useEffect(function () {
     if (prevSnackbars.length === 0 && snackbars.length >= 1) {
+      // @ts-ignore
       enter(snackbars[0].duration);
     }
   }, [snackbars, prevSnackbars]);
@@ -145,12 +150,14 @@ function SnackbarProvider(_ref) {
       var next = prev.slice(1);
 
       if (next.length > 0) {
+        // @ts-ignore
         enter(next[0].duration);
       }
 
       return next;
     });
-  }
+  } // @ts-ignore
+
 
   function enter(duration) {
     setAnimating(true);
@@ -166,12 +173,14 @@ function SnackbarProvider(_ref) {
       setAnimating(false);
       dequeue();
     }, 1000);
-  }
+  } // @ts-ignore
+
 
   function display(duration) {
     if (duration === _constants.DURATION.infinite) {
       return;
-    }
+    } // @ts-ignore
+
 
     timeoutRef.current = setTimeout(function () {
       exit();
@@ -179,14 +188,17 @@ function SnackbarProvider(_ref) {
   }
 
   function handleMouseEnter() {
+    // @ts-ignore
     clearTimeout(timeoutRef.current);
-  }
+  } // @ts-ignore
+
 
   function handleMouseLeave(duration) {
     display(duration);
   }
 
   function handleActionClick() {
+    // @ts-ignore
     clearTimeout(timeoutRef.current);
     exit();
   }
@@ -242,7 +254,8 @@ function SnackbarProvider(_ref) {
       left: '-10000px'
     }),
     ref: containerRef
-  }, snackbars[0] && /*#__PURE__*/React.createElement(_snackbarElement.default, _extends({}, snackbars[0].elementProps, {
+  }, snackbars[0] && /*#__PURE__*/React.createElement(_snackbarElement.default // @ts-ignore
+  , _extends({}, snackbars[0].elementProps, {
     overrides: _objectSpread(_objectSpread({}, snackbarOverrides), snackbars[0].elementProps.overrides),
     focus: false
   }))), snackbars.length > 0 && containerHeight !== 0 && /*#__PURE__*/React.createElement(_layer.Layer, null, /*#__PURE__*/React.createElement(PlacementContainer, _extends({
@@ -251,7 +264,8 @@ function SnackbarProvider(_ref) {
     $translateHeight: translateHeight
   }, placementContainerProps), /*#__PURE__*/React.createElement("div", {
     role: "alert",
-    onMouseEnter: handleMouseEnter,
+    onMouseEnter: handleMouseEnter // @ts-ignore
+    ,
     onMouseLeave: function onMouseLeave() {
       return handleMouseLeave(snackbars[0].duration);
     },
@@ -259,9 +273,12 @@ function SnackbarProvider(_ref) {
       display: 'inline',
       pointerEvents: 'all'
     })
-  }, /*#__PURE__*/React.createElement(_snackbarElement.default, _extends({}, snackbars[0].elementProps, {
+  }, /*#__PURE__*/React.createElement(_snackbarElement.default // @ts-ignore
+  , _extends({}, snackbars[0].elementProps, {
     actionOnClick: function actionOnClick(event) {
+      // @ts-ignore
       if (snackbars[0].elementProps.actionOnClick) {
+        // @ts-ignore
         snackbars[0].elementProps.actionOnClick(event);
       }
 

package/snackbar/snackbar-element.js

@@ -184,12 +184,15 @@ function SnackbarElement(_ref2) {
   React.useEffect(function () {
     if (typeof document !== 'undefined') {
       if (focus && actionButtonRef.current) {
-        prevFocusRef.current = document.activeElement;
+        // @ts-ignore
+        prevFocusRef.current = document.activeElement; // @ts-ignore
+
         actionButtonRef.current.focus();
       }
 
       return function () {
         if (prevFocusRef.current) {
+          // @ts-ignore
           prevFocusRef.current.focus();
         }
       };

package/snackbar/styled-components.js

@@ -100,7 +100,7 @@ var StyledActionButtonContainer = (0, _styles.styled)('div', function (_ref6) {
 });
 exports.StyledActionButtonContainer = StyledActionButtonContainer;
 StyledActionButtonContainer.displayName = "StyledActionButtonContainer";
-StyledActionButtonContainer.displayName = 'StyledActionButtonContainer';
+StyledActionButtonContainer.displayName = 'StyledActionButtonContainer'; // @ts-ignore
 
 function placementRules(placement) {
   switch (placement) {

package/snackbar/types.d.ts

@@ -1,9 +1,9 @@
 import type * as React from 'react';
 import type { Override } from '../helpers/overrides';
 import type { DURATION, PLACEMENT } from './constants';
-export declare type Duration = typeof DURATION.infinite | typeof DURATION.short | typeof DURATION.medium | typeof DURATION.long;
-export declare type Placement = typeof PLACEMENT.topLeft | typeof PLACEMENT.top | typeof PLACEMENT.topRight | typeof PLACEMENT.bottomLeft | typeof PLACEMENT.bottom | typeof PLACEMENT.bottomRight;
-export declare type SnackbarElementOverrides = {
+export type Duration = typeof DURATION.infinite | typeof DURATION.short | typeof DURATION.medium | typeof DURATION.long;
+export type Placement = typeof PLACEMENT.topLeft | typeof PLACEMENT.top | typeof PLACEMENT.topRight | typeof PLACEMENT.bottomLeft | typeof PLACEMENT.bottom | typeof PLACEMENT.bottomRight;
+export type SnackbarElementOverrides = {
     Root?: Override;
     Content?: Override;
     StartEnhancerContainer?: Override;
@@ -12,7 +12,7 @@ export declare type SnackbarElementOverrides = {
     WrapActionButtonContainer?: Override;
     ActionButtonContainer?: Override;
 };
-export declare type SnackbarElementProps = {
+export type SnackbarElementProps = {
     actionMessage?: string;
     actionOnClick?: (a: React.SyntheticEvent<HTMLButtonElement>) => unknown;
     focus?: boolean;
@@ -23,7 +23,7 @@ export declare type SnackbarElementProps = {
         size: number;
     }>;
 };
-export declare type SnackbarProviderProps = {
+export type SnackbarProviderProps = {
     children?: React.ReactNode;
     overrides?: {
         PlacementContainer?: Override;

package/spinner/styled-components.js

@@ -42,6 +42,7 @@ var StyledSpinner = (0, _styles.styled)('i', function (_ref) {
   }[$size];
 
   if (!borderSize) {
+    // @ts-ignore
     borderSize = $theme.sizing[$borderWidth];
 
     if (!borderSize) {
@@ -51,6 +52,7 @@ var StyledSpinner = (0, _styles.styled)('i', function (_ref) {
   }
 
   if (!boxSize) {
+    // @ts-ignore
     boxSize = $theme.sizing[$size];
 
     if (!boxSize) {

package/spinner/types.d.ts

@@ -1,7 +1,7 @@
 import type { SIZE } from './constants';
 import type { Sizing } from '../themes/types';
-export declare type Size = keyof typeof SIZE;
-export declare type SpinnerProps = {
+export type Size = keyof typeof SIZE;
+export type SpinnerProps = {
     /** Color of progress indicator */
     $color?: string;
     /** Width of the progress indicator "stroke".  */

package/stepper/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Stepper } from './stepper';
+export * from './styled-components';
+export * from './types';

package/stepper/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Stepper: true
+};
+Object.defineProperty(exports, "Stepper", {
+  enumerable: true,
+  get: function get() {
+    return _stepper.default;
+  }
+});
+
+var _stepper = _interopRequireDefault(require("./stepper"));
+
+var _styledComponents = require("./styled-components");
+
+Object.keys(_styledComponents).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _styledComponents[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _styledComponents[key];
+    }
+  });
+});
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/stepper/index.js.flow

@@ -0,0 +1,36 @@
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+// @flow
+import * as React from 'react';
+import type { OverrideT } from '../helpers/overrides.js';
+import { type StyletronComponent } from 'styletron-react';
+
+export type StepperOverridesT = {
+  Root?: OverrideT,
+  Input?: OverrideT,
+  DecrementButton?: OverrideT,
+  DecrementButtonIcon?: OverrideT,
+  IncrementButton?: OverrideT,
+  IncrementButtonIcon?: OverrideT,
+};
+
+export type StepperProps = {
+  value: number,
+  setValue: (newValue: number) => void,
+  minValue?: number,
+  maxValue?: number,
+  disabled?: boolean,
+  overrides?: StepperOverridesT,
+};
+
+declare export var StyledRoot: StyletronComponent<'div', {}>;
+
+declare export var Stepper: React.ComponentType<StepperProps>;
+
+declare var __DEV__: boolean;
+declare var __NODE__: boolean;
+declare var __BROWSER__: boolean;

package/stepper/package.json

@@ -0,0 +1,4 @@
+{
+  "sideEffects": false,
+  "module": "../esm/stepper/index.js"
+}

package/stepper/stepper.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { StepperProps } from './types';
+export declare function Stepper({ value, disabled, overrides, setValue, minValue, maxValue, }: StepperProps): JSX.Element;
+export default Stepper;

package/stepper/stepper.js

@@ -0,0 +1,162 @@
+"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.Stepper = Stepper;
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _overrides = require("../helpers/overrides");
+
+var _button = require("../button");
+
+var _input = require("../input");
+
+var _icon = require("../icon");
+
+var _styledComponents = require("./styled-components");
+
+var _styles = require("../styles");
+
+var _excluded = ["children"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+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 _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; }
+
+var DefaultButton = function DefaultButton(_ref) {
+  var children = _ref.children,
+      restProps = _objectWithoutProperties(_ref, _excluded);
+
+  return /*#__PURE__*/React.createElement(_button.Button, _extends({
+    shape: _button.SHAPE.circle,
+    kind: _button.KIND.secondary,
+    size: _button.SIZE.compact
+  }, restProps), children);
+};
+
+function Stepper(_ref2) {
+  var value = _ref2.value,
+      _ref2$disabled = _ref2.disabled,
+      disabled = _ref2$disabled === void 0 ? false : _ref2$disabled,
+      _ref2$overrides = _ref2.overrides,
+      overrides = _ref2$overrides === void 0 ? {} : _ref2$overrides,
+      setValue = _ref2.setValue,
+      _ref2$minValue = _ref2.minValue,
+      minValue = _ref2$minValue === void 0 ? 0 : _ref2$minValue,
+      maxValue = _ref2.maxValue;
+
+  var _getOverrides = (0, _overrides.getOverrides)(overrides.Root, _styledComponents.StyledRoot),
+      _getOverrides2 = _slicedToArray(_getOverrides, 2),
+      Root = _getOverrides2[0],
+      rootProps = _getOverrides2[1];
+
+  var _getOverrides3 = (0, _overrides.getOverrides)(overrides.Input, _input.Input),
+      _getOverrides4 = _slicedToArray(_getOverrides3, 2),
+      Input = _getOverrides4[0],
+      inputProps = _getOverrides4[1];
+
+  var _getOverrides5 = (0, _overrides.getOverrides)(overrides.DecrementButton, DefaultButton),
+      _getOverrides6 = _slicedToArray(_getOverrides5, 2),
+      DecrementButton = _getOverrides6[0],
+      decrementButtonProps = _getOverrides6[1];
+
+  var _getOverrides7 = (0, _overrides.getOverrides)(overrides.DecrementButtonIcon, _icon.CheckIndeterminate),
+      _getOverrides8 = _slicedToArray(_getOverrides7, 2),
+      DecrementButtonIcon = _getOverrides8[0],
+      decrementButtonIconProps = _getOverrides8[1];
+
+  var _getOverrides9 = (0, _overrides.getOverrides)(overrides.DecrementButton, DefaultButton),
+      _getOverrides10 = _slicedToArray(_getOverrides9, 2),
+      IncrementButton = _getOverrides10[0],
+      incrementButtonProps = _getOverrides10[1];
+
+  var _getOverrides11 = (0, _overrides.getOverrides)(overrides.DecrementButtonIcon, _icon.Plus),
+      _getOverrides12 = _slicedToArray(_getOverrides11, 2),
+      IncrementButtonIcon = _getOverrides12[0],
+      incrementButtonIconProps = _getOverrides12[1];
+
+  var handleInputChange = function handleInputChange(e) {
+    var newValue = Number(e.target.value);
+
+    if (!isNaN(newValue) && (!maxValue || newValue <= maxValue) && newValue >= minValue) {
+      setValue(newValue);
+    }
+  };
+
+  var _useStyletron = (0, _styles.useStyletron)(),
+      _useStyletron2 = _slicedToArray(_useStyletron, 2),
+      theme = _useStyletron2[1];
+
+  return /*#__PURE__*/React.createElement(Root, rootProps, /*#__PURE__*/React.createElement(DecrementButton, _extends({
+    onClick: function onClick() {
+      return setValue(value - 1);
+    },
+    disabled: disabled || value <= minValue,
+    "aria-label": "decrement value"
+  }, decrementButtonProps), /*#__PURE__*/React.createElement(DecrementButtonIcon, decrementButtonIconProps)), /*#__PURE__*/React.createElement(Input, _extends({
+    value: value,
+    onChange: handleInputChange,
+    disabled: disabled,
+    "aria-label": "value",
+    overrides: {
+      Root: {
+        style: {
+          maxWidth: '36px',
+          height: '36px',
+          borderLeftStyle: 'none',
+          borderRightStyle: 'none',
+          borderTopStyle: 'none',
+          borderBottomStyle: 'none'
+        }
+      },
+      Input: {
+        style: _objectSpread({
+          paddingTop: 0,
+          paddingBottom: 0,
+          paddingLeft: 0,
+          paddingRight: 0,
+          textAlign: 'center',
+          backgroundColor: theme.colors.backgroundPrimary
+        }, theme.typography.LabelLarge)
+      }
+    }
+  }, inputProps)), /*#__PURE__*/React.createElement(IncrementButton, _extends({
+    onClick: function onClick() {
+      return setValue(value + 1);
+    },
+    disabled: disabled || value >= maxValue,
+    "aria-label": "increment value"
+  }, incrementButtonProps), /*#__PURE__*/React.createElement(IncrementButtonIcon, incrementButtonIconProps)));
+}
+
+var _default = Stepper;
+exports.default = _default;

package/stepper/styled-components.d.ts

@@ -0,0 +1 @@
+export declare const StyledRoot: import("styletron-react").StyletronComponent<"div", {}>;

package/stepper/styled-components.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StyledRoot = void 0;
+
+var _styles = require("../styles");
+
+/*
+Copyright (c) Uber Technologies, Inc.
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+var StyledRoot = (0, _styles.styled)('div', function (_ref) {
+  var $theme = _ref.$theme;
+  return {
+    display: 'flex',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    boxSizing: 'border-box',
+    maxWidth: '139px',
+    height: '48px',
+    padding: $theme.sizing.scale550
+  };
+});
+exports.StyledRoot = StyledRoot;
+StyledRoot.displayName = "StyledRoot";
+StyledRoot.displayName = 'StyledRoot';

package/stepper/types.d.ts

@@ -0,0 +1,17 @@
+import type { Override } from '../helpers/overrides';
+export type MobileHeaderOverrides = {
+    Root?: Override;
+    Input?: Override;
+    DecrementButton?: Override;
+    DecrementButtonIcon?: Override;
+    IncrementButton?: Override;
+    IncrementButtonIcon?: Override;
+};
+export type StepperProps = {
+    value: number;
+    setValue: (newValue: number) => void;
+    minValue?: number;
+    maxValue?: number;
+    disabled?: boolean;
+    overrides?: MobileHeaderOverrides;
+};

package/stepper/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/styles/__mocks__/styled.js

@@ -58,7 +58,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-var MOCK_THEME = (0, _createMockTheme.default)(_themes.LightTheme);
+var MOCK_THEME = (0, _createMockTheme.default)(_themes.LightTheme); // @ts-ignore
 
 var IDENTITY = function IDENTITY(x) {
   return x;
@@ -110,6 +110,7 @@ function styled(ElementName) {
 
         return Object.keys(restProps).reduce(function (acc, key) {
           if (key[0] !== '$') {
+            // @ts-ignore
             acc[key] = restProps[key];
           }
 
@@ -163,9 +164,13 @@ function styled(ElementName) {
     base: ElementName
   };
   return /*#__PURE__*/React.forwardRef(function (props, ref) {
-    return /*#__PURE__*/React.createElement(MockStyledComponent, _extends({
-      forwardedRef: ref
-    }, props));
+    return (
+      /*#__PURE__*/
+      // @ts-ignore
+      React.createElement(MockStyledComponent, _extends({
+        forwardedRef: ref
+      }, props))
+    );
   });
 }
 

package/styles/as-primary-export-hoc.js

@@ -24,8 +24,10 @@ function asPrimaryExport(StyledComponent, propsTransformNames) {
   return function withStyledPropsHOC(props) {
     var styledProps = Object.keys(props).reduce(function (acc, key) {
       if (key[0] === '$' || propsTransformNames.indexOf(key) < 0) {
+        // @ts-ignore
         acc[key] = props[key];
       } else if (propsTransformNames.indexOf(key) >= 0) {
+        // @ts-ignore
         acc['$' + key] = props[key];
       }
 

package/styles/styled.d.ts

@@ -3,13 +3,13 @@ import type { StyletronComponent } from 'styletron-react';
 import type { StyleObject } from 'styletron-standard';
 import type { Theme } from './types';
 export type { StyletronComponent };
-declare type StyleFn<DefaultTheme> = {
+type StyleFn<DefaultTheme> = {
     <C extends keyof JSX.IntrinsicElements | React.ComponentType<any>, P extends {}, Theme = DefaultTheme>(component: C, style: StyleObject | ((props: Omit<P, '$theme'> & {
         $theme: Theme;
     }) => StyleObject)): StyletronComponent<C, P>;
     <C extends keyof JSX.IntrinsicElements | React.ComponentType<any>>(component: C, style: StyleObject): StyletronComponent<C, {}>;
 };
-declare type WithStyleFn<DefaultTheme> = {
+type WithStyleFn<DefaultTheme> = {
     <C extends StyletronComponent<any, any>, P extends {}, Theme = DefaultTheme>(component: C, style: ((props: Omit<P, '$theme'> & {
         $theme: Theme;
     } & (C extends StyletronComponent<infer CC, infer PP> ? PP : never)) => StyleObject) | StyleObject): C extends StyletronComponent<infer CC, infer PP> ? StyletronComponent<CC, P & PP> : never;
@@ -19,13 +19,13 @@ export declare function createThemedStyled<Theme>(): StyleFn<Theme>;
 export declare const styled: StyleFn<Theme>;
 export declare function createThemedWithStyle<Theme>(): WithStyleFn<Theme>;
 export declare const withStyle: WithStyleFn<Theme>;
-declare type UseStyletronFn<Theme> = () => [(a: StyleObject) => string, Theme];
+type UseStyletronFn<Theme> = () => [(a: StyleObject) => string, Theme];
 export declare function createThemedUseStyletron<Theme>(): UseStyletronFn<Theme>;
 export declare const useStyletron: UseStyletronFn<Theme>;
 export declare function withWrapper<C extends StyletronComponent<any, any>, Props>(StyledElement: C, wrapperFn: (component: C) => (props: Props & (C extends StyletronComponent<any, infer CP> ? CP : never)) => React.ReactElement): C extends StyletronComponent<infer D, infer P> ? StyletronComponent<D, P & Props> : never;
 /** @deprecated use StyleFn instead. To be removed in future versions.*/
-export declare type StyletronStyledFn<T> = StyleFn<T>;
+export type StyletronStyledFn<T> = StyleFn<T>;
 /** @deprecated use WithStyleFn instead. To be removed in future versions.*/
-export declare type StyletronWithStyleFn<T> = WithStyleFn<T>;
+export type StyletronWithStyleFn<T> = WithStyleFn<T>;
 /** @deprecated use StyleFn instead. To be removed in future versions.*/
-export declare type StyledFn<T> = StyleFn<T>;
+export type StyledFn<T> = StyleFn<T>;

package/styles/styled.js

@@ -43,6 +43,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 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); }
 
+// @ts-ignore
 var wrapper = function wrapper(StyledComponent) {
   // eslint-disable-next-line react/display-name
   return /*#__PURE__*/React.forwardRef(function (props, ref) {
@@ -94,6 +95,7 @@ var useStyletron = createThemedUseStyletron(); // eslint-disable-next-line @type
 exports.useStyletron = useStyletron;
 
 function withWrapper(StyledElement, wrapperFn) {
+  // @ts-ignore
   return (0, _styletronReact.withWrapper)(StyledElement, function (Styled) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any,react/display-name
     return /*#__PURE__*/React.forwardRef(function (props, ref) {

package/styles/theme-provider.d.ts

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import type { Theme } from './types';
 export declare const ThemeContext: React.Context<Theme>;
-export declare type ThemeProviderProps = {
+export type ThemeProviderProps = {
     theme: Theme;
 };
-declare const ThemeProvider: React.FC<ThemeProviderProps>;
+declare const ThemeProvider: React.FC<React.PropsWithChildren<ThemeProviderProps>>;
 export default ThemeProvider;