@callstack/react-theme-provider/lib/createWithTheme.js

"use strict";

exports.__esModule = true;
exports.default = void 0;

var React = _interopRequireWildcard(require("react"));

var _deepmerge = _interopRequireDefault(require("deepmerge"));

var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));

var _utils = require("./utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _extends() { _extends = Object.assign || 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 _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

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 isClassComponent = function isClassComponent(Component) {
  return Boolean(Component.prototype && Component.prototype.isReactComponent);
};

var createWithTheme = function createWithTheme(ThemeProvider, ThemeContext) {
  return function withTheme(Comp) {
    var ThemedComponent =
    /*#__PURE__*/
    function (_React$Component) {
      _inheritsLoose(ThemedComponent, _React$Component);

      function ThemedComponent() {
        var _this;

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;

        _defineProperty(_assertThisInitialized(_this), "_previous", void 0);

        _defineProperty(_assertThisInitialized(_this), "_merge", function (a, b) {
          var previous = _this._previous;

          if (previous && previous.a === a && previous.b === b) {
            return previous.result;
          }

          var result = a && b ? (0, _deepmerge.default)(a, b) : a || b;
          _this._previous = {
            a: a,
            b: b,
            result: result
          };
          return result;
        });

        _defineProperty(_assertThisInitialized(_this), "_root", void 0);

        return _this;
      }

      var _proto = ThemedComponent.prototype;

      _proto.render = function render() {
        var _this2 = this;

        return React.createElement(ThemeContext.Consumer, null, function (theme) {
          var merged = _this2._merge(theme, _this2.props.theme);

          var element;

          if (isClassComponent(Comp)) {
            // Only add refs for class components as function components don't support them
            // It's needed to support use cases which need access to the underlying node
            element = React.createElement(Comp, _extends({}, _this2.props, {
              ref: function ref(c) {
                _this2._root = c;
              },
              theme: merged
            }));
          } else {
            element = React.createElement(Comp, _extends({}, _this2.props, {
              theme: merged
            }));
          }

          if (merged !== _this2.props.theme) {
            // If a theme prop was passed, expose it to the children
            return React.createElement(ThemeProvider, {
              theme: merged
            }, element);
          }

          return element;
        });
      };

      return ThemedComponent;
    }(React.Component);

    _defineProperty(ThemedComponent, "displayName", "withTheme(" + (Comp.displayName || Comp.name) + ")");

    if (isClassComponent(Comp)) {
      // getWrappedInstance is exposed by some HOCs like react-redux's connect
      // Use it to get the ref to the underlying element
      // Also expose it to access the underlying element after wrapping
      // $FlowFixMe
      ThemedComponent.prototype.getWrappedInstance = function getWrappedInstance() {
        return this._root && this._root.getWrappedInstance ? this._root.getWrappedInstance() : this._root;
      };

      ThemedComponent = (0, _utils.copyRefs)(ThemedComponent, Comp);
    }

    (0, _hoistNonReactStatics.default)(ThemedComponent, Comp);
    return ThemedComponent;
  };
};

var _default = createWithTheme;
exports.default = _default;
//# sourceMappingURL=createWithTheme.js.map