object-translate/dist/objectTranslate.js

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

var Op = require('object-path');
var Traverse = require('traverse');

module.exports = function (mapDefinition, defaults) {

  defaults = defaults || {};

  return function (originalObj) {
    return Traverse(mapDefinition).map(
    /*eslint-disable prefer-arrow-callback */
    function (item) {

      var getMethod = 'get';
      var path = item;
      var process = function process(x) {
        return x;
      };

      if (!this.isLeaf) {
        var isObject = Object.prototype.toString.apply(item) === '[object Object]';
        var hasAlternatives = isObject && Array.isArray(item.alternatives);
        var hasProcessor = isObject && typeof item.processor === 'function';
        // not leaf, not alternatives, no processor, this means a regular object so skip
        // it
        if (!hasAlternatives && !hasProcessor) {
          return;
        }
        if (hasAlternatives) {
          path = item.alternatives;
          getMethod = 'coalesce';
        }
        if (hasProcessor) {
          if (!hasAlternatives && !item.path) {
            console.warn('You have provided a processor func. without path or alternatives. Null will be returned');
            return null;
          }
          path = hasAlternatives ? path : item.path;
          process = item.processor;
        }
      }

      var originalValue = Op[getMethod](originalObj, path);
      // try to use a default value  ONLY if the original value is undefined. Values like false, 0, '', null, will pass as they are
      originalValue = originalValue === undefined ? Op[getMethod](defaults, path) : originalValue;

      var newValue = process(originalValue, originalObj);

      this.update(newValue, true);
    });
  };
};

})));