vue-hoc/dist/createRenderFn.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createRenderFnc = exports.createRenderFn = undefined;

var _courier = require('./courier');

var _courier2 = _interopRequireDefault(_courier);

var _normalizeSlots = require('./normalizeSlots');

var _normalizeSlots2 = _interopRequireDefault(_normalizeSlots);

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

var isObject = function isObject(test) {
  return Object.prototype.toString.call(test) === '[object Object]';
};
var isFn = function isFn(test) {
  return Object.prototype.toString.call(test) === '[object Function]';
};

var justBindOptions = ['listeners', 'nativeOn', 'scopedSlots'];

var justBindFn = function justBindFn(key) {
  return justBindOptions.indexOf(key) > -1;
};

var getOptionsKeys = function getOptionsKeys(options) {
  return Object.keys(options).concat(['listeners', 'props', 'attrs']).filter(function (k, i, a) {
    return a.indexOf(k) === i;
  });
};

var createOptionHandlers = function createOptionHandlers(originalOptions, keys) {
  var options = {};

  keys.forEach(function (key) {
    var option = originalOptions[key];

    if (!option) {
      options[key] = function (owner) {
        return owner;
      };
      return;
    }

    if (isFn(option)) {
      // $FlowFixMe
      options[key] = option;
      return;
    }

    if (isObject(option)) {
      var optionKeys = Object.keys(option);

      if (!optionKeys.some(function (k) {
        return isFn(option[k]);
      })) {
        options[key] = function (owner) {
          return Object.assign({}, owner, option);
        };
        return;
      }

      options[key] = function (owner) {
        var _this = this;

        var result = Object.assign({}, owner);
        var justBind = justBindFn(key);

        optionKeys.forEach(function (k) {
          var value = option && option[k];

          if (isFn(value)) {
            if (justBind) {
              value = value.bind(_this);
            } else {
              value = value.call(_this, owner);
            }
          }
          result[k] = value;
        });
        return result;
      };
      return;
    }

    options[key] = function () {
      return option;
    };
  });

  return options;
};

var preprocessOptions = function preprocessOptions(originalOptions) {
  var keys = getOptionsKeys(originalOptions);
  var options = createOptionHandlers(originalOptions, keys);

  return function (context, isFunctional) {
    var result = {
      on: {},
      props: {},
      attrs: {}
    };

    keys.forEach(function (key) {
      var owner = isFunctional ? context[key] || context.data[key] : context['$' + key];

      var value = options[key].call(context, owner);

      if (key === 'listeners') {
        key = 'on';
      }

      result[key] = value;
    });

    return result;
  };
};

var createRenderFn = exports.createRenderFn = function createRenderFn(Component, options) {
  var getData = preprocessOptions(options || {});

  return function renderHoc(h, context) {
    //const data = processOptions(this || context || {}, options || {});
    var data = getData(context || this, !!context);
    var scopedSlots = context && context.data && context.data.scopedSlots || this && this.$scopedSlots;
    var slots = context && context.children || this && this.$slots && (0, _normalizeSlots2.default)(this.$slots) || [];

    data.scopedSlots = data.scopedSlots || scopedSlots;

    return h(Component, data, slots);
  };
};

var createRenderFnc = exports.createRenderFnc = (0, _courier2.default)(2, function (options, Component) {
  return createRenderFn(Component, options);
});
//# sourceMappingURL=createRenderFn.js.map