lodash-decorators/Applicator.js

A collection of decorators using lodash at it's core.

'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

var _lodashObjectAssign = require('lodash/object/assign');

var _lodashObjectAssign2 = _interopRequireDefault(_lodashObjectAssign);

var _lodashLangIsFunction = require('lodash/lang/isFunction');

var _lodashLangIsFunction2 = _interopRequireDefault(_lodashLangIsFunction);

var _lodashObjectForOwn = require('lodash/object/forOwn');

var _lodashObjectForOwn2 = _interopRequireDefault(_lodashObjectForOwn);

var _lodashFunctionPartial = require('lodash/function/partial');

var _lodashFunctionPartial2 = _interopRequireDefault(_lodashFunctionPartial);

var applicators = {
  // Methods where the function is the last argument or the first
  // and all other arguments come before or after.
  post: function post(fn, target, value) {
    for (var _len = arguments.length, args = Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
      args[_key - 3] = arguments[_key];
    }

    return fn.apply(undefined, args.concat([value]));
  },
  pre: function pre(fn, target, value) {
    for (var _len2 = arguments.length, args = Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
      args[_key2 - 3] = arguments[_key2];
    }

    return fn.apply(undefined, [value].concat(args));
  },

  // Partials are slightly different. They partial an existing function
  // on the object referenced by string name.
  partial: function partial(fn, target, value) {
    for (var _len3 = arguments.length, args = Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
      args[_key3 - 3] = arguments[_key3];
    }

    return fn.apply(undefined, [Applicator.resolveFunction(args[0], target)].concat(_toConsumableArray(args.slice(1))));
  },

  // Wrap is a different case since the original function value
  // needs to be given to the wrap method.
  wrap: function wrap(fn, target, value) {
    return fn(Applicator.resolveFunction(arguments[3], target), value);
  },
  replace: function replace(fn, target, value) {
    for (var _len4 = arguments.length, args = Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) {
      args[_key4 - 3] = arguments[_key4];
    }

    return fn.apply(undefined, args);
  },

  // Calls the function with key functions and the value
  compose: function compose(fn, target, value) {
    for (var _len5 = arguments.length, args = Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) {
      args[_key5 - 3] = arguments[_key5];
    }

    return fn.apply(undefined, [value].concat(_toConsumableArray(args.map(function (method) {
      return Applicator.resolveFunction(method, target);
    }))));
  },
  partialed: function partialed(fn, target, value) {
    for (var _len6 = arguments.length, args = Array(_len6 > 3 ? _len6 - 3 : 0), _key6 = 3; _key6 < _len6; _key6++) {
      args[_key6 - 3] = arguments[_key6];
    }

    return _lodashFunctionPartial2['default'].apply(undefined, [fn, value].concat(args));
  },
  single: function single(fn, target, value) {
    for (var _len7 = arguments.length, args = Array(_len7 > 3 ? _len7 - 3 : 0), _key7 = 3; _key7 < _len7; _key7++) {
      args[_key7 - 3] = arguments[_key7];
    }

    return applicators.pre.apply(applicators, [fn, target, value].concat(args));
  }
};

var Applicator = {
  invoke: function invoke(applicator, method, target, value) {
    for (var _len8 = arguments.length, args = Array(_len8 > 4 ? _len8 - 4 : 0), _key8 = 4; _key8 < _len8; _key8++) {
      args[_key8 - 4] = arguments[_key8];
    }

    return applicator.apply(undefined, [method, target, value].concat(args));
  },

  resolveFunction: function resolveFunction(method, target) {
    return (0, _lodashLangIsFunction2['default'])(method) ? method : target[method];
  },

  /**
  * Used to copy over meta data from function to function.
  * If meta data is attached to a function. This can get lost
  * when wrapping functions. This tries to persist that.
  */
  copyMetaData: function copyMetaData(from, to) {
    (0, _lodashObjectForOwn2['default'])(from, function (value, key) {
      return to[key] = value;
    });
    return to;
  }
};

(0, _lodashObjectAssign2['default'])(Applicator, { applicators: applicators });

exports['default'] = Applicator;
module.exports = exports['default'];