react-render-callback/dist/react-render-callback.umd.js

render-prop helper to render anything (Functions, Components, Elements, ...)

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) :
  typeof define === 'function' && define.amd ? define(['react'], factory) :
  (global.ReactRenderCallback = factory(global.React));
}(this, (function (react) { 'use strict';

  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);
  }

  var constant = (function (value) {
    return function () {
      return value;
    };
  });

  var isIgnored = (function (value) {
    return value == null || value === false || value === true;
  });

  var ignoredValuesToNull = (function (value) {
    return isIgnored(value) ? null : value;
  });

  var context =
  /*#__PURE__*/
  typeof react.createContext === 'function' &&
  /*#__PURE__*/
  react.createContext();
  var REACT_PROVIDER_TYPE = context && context.Provider.$$typeof;
  var REACT_CONTEXT_TYPE = context && context.Consumer.$$typeof; // React.forwardRef is available since v16.3.0

  var REACT_FORWARD_REF_TYPE =
  /*#__PURE__*/
  typeof react.forwardRef === 'function' &&
  /*#__PURE__*/
  react.forwardRef( // need to access both params otherwise react warns
  // but as this is never used this is no-op

  /* istanbul ignore next line */
  function (props, ref) {
    return {
      props: props,
      ref: ref
    };
  }).$$typeof;

  var isReactComponent = (function (renderable) {
    if (renderable == null) return false;
    var type = typeof renderable;
    if (type === 'string') return false;

    if (type === 'function') {
      return !!(renderable.prototype && renderable.prototype.isReactComponent || // eslint-disable-next-line react/forbid-foreign-prop-types
      renderable.propTypes);
    }

    return type === 'object' && renderable.$$typeof && (renderable.$$typeof === REACT_PROVIDER_TYPE || renderable.$$typeof === REACT_CONTEXT_TYPE || renderable.$$typeof === REACT_FORWARD_REF_TYPE);
  });

  var createRender = (function (renderable, options) {
    if (isReactComponent(renderable)) {
      return function (props) {
        return react.createElement(renderable, props);
      };
    }

    if (typeof renderable === 'function') {
      return function () {
        return ignoredValuesToNull(renderable.defaultProps ? renderable(_extends({}, renderable.defaultProps, arguments.length <= 0 ? undefined : arguments[0])) : renderable.apply(void 0, arguments));
      };
    }

    if (options && options.cloneElement && react.isValidElement(renderable)) {
      return function (props) {
        return react.cloneElement(renderable, props);
      };
    } // must be something else


    return constant(ignoredValuesToNull(renderable));
  });

  var render = (function (renderable, props, options) {
    return createRender(renderable, options)(props);
  });

  render.createRender = createRender;

  return render;

})));
//# sourceMappingURL=react-render-callback.umd.js.map