"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "injectAndObserve", {
  enumerable: true,
  get: function get() {
    return _injectAndObserve.injectAndObserve;
  }
});
exports.default = exports.connectToData = exports.connectToDataFactory = void 0;

var _react = _interopRequireDefault(require("react"));

var _exotic = require("exotic");

var _mobxReact = require("xmobx/mobx-react");

var _propTypes = _interopRequireDefault(require("prop-types"));

var _identifier = require("../identifier");

var _injectAndObserve = require("./injectAndObserve");

var _jsxFileName = "/Users/michaelfrohberg/Training/mono/packages/modules/state-tree/connectToDataFactory.js";

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

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 _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;
}
/**
 * @NOTE could connect to data without datas
 * @param {*} datas
 * @param {Class.extends.React.Component} Component
 * @return {Wrapped.Class.extends.React.Component} auto-updating component
 */


const connectToDataFactory = (datas, name = 'datas') => Component => {
  const named = {
    [name]: datas // @NOTE IMPORTANT

  };
  const ConnectedComponent = (0, _mobxReact.observer)(Component); // @TODO could use class here instead

  function DataWrap(props) {
    const wrappedComponentRef = props.wrappedComponentRef,
          remainingProps = _objectWithoutProperties(props, ["wrappedComponentRef"]);

    if ((0, _exotic.isFunction)(datas.handleProps)) {
      datas.handleProps(props);
    }

    return _react.default.createElement(ConnectedComponent, _extends({}, remainingProps, {
      ref: wrappedComponentRef,
      data: datas
    }, named, datas, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 54
      },
      __self: this
    }));
  } // DataWrap.prototype.componentWillReact = function() {
  //   console.debug('reaction: ', this)
  // }


  DataWrap.displayName = (0, _identifier.toComponentName)(Component) + `@connectedToData`;
  DataWrap.WrappedComponent = Component; // why do we want a ref to this again?

  DataWrap.propTypes = {
    wrappedComponentRef: _propTypes.default.func // const provide = children =>
    //   <Provider {...named}>
    //     {children}
    //   </Provider>
    // let connected = DataWrap
    // connected = inject(datas)(DataWrap)
    // connected = observer(DataWrap)
    // return provide(connected)
    //
    // return observer(hoistStatics(DataWrap, Component))

  };
  return (0, _mobxReact.observer)(DataWrap);
};

exports.connectToData = exports.connectToDataFactory = connectToDataFactory;
var _default = connectToDataFactory;
exports.default = _default;