instantjob-recruiter-client/dist/common/utilities.es6.js

a set of tools for creating an instantjob recruiter react client

'use strict';

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

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _extends5 = require('babel-runtime/helpers/extends');

var _extends6 = _interopRequireDefault(_extends5);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

exports.range = range;
exports.array_from_hash = array_from_hash;
exports.human_join = human_join;
exports.set_from_array = set_from_array;
exports.hash_with_key = hash_with_key;
exports.array_contains = array_contains;
exports.map_hash = map_hash;
exports.capitalize_first_letter = capitalize_first_letter;
exports.make_one_memoized = make_one_memoized;
exports.make_curryfied = make_curryfied;
exports.make_decurryfied = make_decurryfied;
exports.make_memoized = make_memoized;
exports.make_persistent = make_persistent;
exports.group_consecutive = group_consecutive;
exports.find_duplicates = find_duplicates;
exports.filter_hash = filter_hash;
exports.array_from_set = array_from_set;
exports.human_plural = human_plural;
exports.deep_merge = deep_merge;
exports.for_all = for_all;
exports.create_hash = create_hash;
exports.hash_key_with_value = hash_key_with_value;
exports.set_difference = set_difference;
exports.distance = distance;
exports.download_file = download_file;
exports.empty_hash = empty_hash;
exports.empty_set = empty_set;
exports.empty_array = empty_array;
exports.preview = preview;
exports.split_array = split_array;
exports.array_minimum = array_minimum;
exports.array_maximum = array_maximum;
exports.split_hash = split_hash;
exports.flatten_array = flatten_array;
exports.find_in_array = find_in_array;
exports.find_optimum_in_sorted_array = find_optimum_in_sorted_array;
exports.group_by_batch = group_by_batch;
exports.group_hash_by_value = group_hash_by_value;
exports.set_union = set_union;
exports.exist = exist;
exports.empty_object = empty_object;
exports.hash_size = hash_size;
exports.array_sum = array_sum;
exports.array_mean = array_mean;
exports.format_duration = format_duration;
exports.property_getter = property_getter;
exports.property_toggler = property_toggler;
exports.set_count = set_count;
exports.property_is = property_is;
exports.get_url_parameter = get_url_parameter;
exports.debounce = debounce;
exports.set_intersection = set_intersection;
exports.set_from_hash = set_from_hash;
exports.compare = compare;
exports.scope = scope;
exports.filter_set = filter_set;
exports.hash_each = hash_each;

var _geolib = require('geolib');

var _geolib2 = _interopRequireDefault(_geolib);

var _fileSaver = require('file-saver');

var _fileSaver2 = _interopRequireDefault(_fileSaver);

require('whatwg-fetch');

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

function range(arg1, arg2) {
  var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;

  var start = void 0,
      end = void 0;
  if (arg2) {
    start = arg1;
    end = arg2;
  } else {
    start = 0;
    end = arg1;
  }
  var range = [];
  for (var i = start; i < end; i += step) {
    range.push(i);
  }
  return range;
}

function array_from_hash() {
  var hash = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  return (0, _keys2.default)(hash).map(function (key) {
    return hash[key];
  });
}

function human_join() {
  var strings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var ellipsis = arguments[1];

  var join = function join(strings) {
    return strings.reduce(function (human_join, string) {
      return string + ', ' + human_join;
    }, "");
  };
  if (ellipsis && strings.length > ellipsis) {
    return join(strings.slice(0, ellipsis)) + '...';
  } else {
    if (strings.length > 1) {
      return '' + join(strings.slice(2)) + strings[1] + ' et ' + strings[0];
    } else {
      return strings[0];
    }
  }
}

function set_from_array() {
  var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

  var hash = {};
  array.forEach(function (item) {
    hash[item] = true;
  });
  return hash;
}

function hash_with_key() {
  var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "id";

  var hash = {};
  array.forEach(function (item) {
    hash[item[key]] = item;
  });
  return hash;
}

function array_contains(array, element) {
  var strict = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  var compare = void 0;
  if (strict) {
    compare = function compare(a, b) {
      return a === b;
    };
  } else {
    compare = function compare(a, b) {
      return a == b;
    };
  }
  return array && array.reduce(function (contains, e) {
    return contains || compare(e, element);
  }, false);
}

function map_hash(hash, mapping) {
  var mapped_hash = {};
  (0, _keys2.default)(hash).forEach(function (key) {
    return mapped_hash[key] = mapping(hash[key]);
  });
  return mapped_hash;
}

function capitalize_first_letter(string) {
  return string.charAt(0).toUpperCase() + string.slice(1);
}

function make_one_memoized(fun) {
  var results = {};
  return function (arg) {
    var result = results[arg];
    if (typeof result == 'undefined') {
      result = fun(arg);
      results[arg] = result;
    }
    return result;
  };
}

function make_curryfied(fun) {
  function make_curryfied_fun_of_arity(fun, arity) {
    if (arity > 1) {
      return function (arg) {
        return make_curryfied_fun_of_arity(function () {
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          return fun.apply(undefined, [arg].concat(args));
        }, arity - 1);
      };
    } else {
      return fun;
    }
  }
  return make_curryfied_fun_of_arity(fun, fun.length);
}

function make_decurryfied(fun) {
  return function () {
    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    return args.reduce(function (partial, arg) {
      return partial(arg);
    }, fun);
  };
}

function make_memoized(fun) {
  function make_memoized_fun_of_arity(fun, arity) {
    if (arity > 0) {
      return make_one_memoized(function (arg) {
        return make_memoized_fun_of_arity(fun(arg), arity - 1);
      });
    } else {
      return fun;
    }
  }
  return make_decurryfied(make_memoized_fun_of_arity(make_curryfied(fun), fun.length));
}

function make_persistent(fun) {
  var previous_result = void 0;
  var previous_arguments = [];
  return function () {
    for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      args[_key3] = arguments[_key3];
    }

    if (args.length == previous_arguments.length && args.reduce(function (identical, argument, index) {
      return identical && argument === previous_arguments[index];
    }, true)) {
      return previous_result;
    } else {
      previous_result = fun.apply(undefined, args);
      previous_arguments = args;
      return previous_result;
    }
  };
}

function group_consecutive(array, group) {
  if (array.length == 0) {
    return [];
  } else {
    var current_group = [];
    var groups = [];

    var add_to_current_group = function add_to_current_group(element) {
      current_group.push(element);
    };

    var flush_current_group = function flush_current_group() {
      groups.push(current_group);
      current_group = [];
    };
    add_to_current_group(array[0]);
    for (var index = 1; index < array.length; index++) {
      if (!group(current_group[current_group.length - 1], array[index])) {
        flush_current_group();
      }
      add_to_current_group(array[index]);
    }
    if (current_group.length > 0) {
      flush_current_group();
    }
    return groups;
  }
}

function find_duplicates(array) {
  var found = {};
  var duplicates = {};
  array.forEach(function (element) {
    if (found[element]) {
      duplicates[element] = true;
    } else {
      found[element] = true;
    }
  });
  return (0, _keys2.default)(duplicates);
}

function filter_hash(hash, filter) {
  var result = {};
  (0, _keys2.default)(hash).forEach(function (key) {
    var value = hash[key];
    if (filter(value)) {
      result[key] = value;
    }
  });
  return result;
}

function array_from_set() {
  var set = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  var array = [];
  (0, _keys2.default)(set).forEach(function (key) {
    if (set[key]) {
      array.push(key);
    }
  });
  return array;
}

function human_plural(quantity, singular, plural) {
  if (quantity > 1) {
    return plural.replace("%%", quantity);
  } else {
    return singular.replace("%%", quantity);
  }
}

function deep_merge(hash1, hash2) {
  if ((typeof hash1 === 'undefined' ? 'undefined' : (0, _typeof3.default)(hash1)) === 'object' && (typeof hash2 === 'undefined' ? 'undefined' : (0, _typeof3.default)(hash2)) === 'object') {
    if (hash1 === null) {
      hash1 = {};
    }
    if (hash2 === null) {
      hash2 = {};
    }
    return (0, _keys2.default)(hash2).reduce(function (result, key) {
      return (0, _extends6.default)({}, result, (0, _defineProperty3.default)({}, key, deep_merge(hash1[key], hash2[key])));
    }, hash1);
  } else {
    return hash2;
  }
}

function for_all(array, condition) {
  var i = 0;
  while (i < array.length) {
    if (!condition(array[i])) {
      return false;
    }
    i++;
  }
  return true;
}

function create_hash(array, fun) {
  var hash = {},
      i = 0;
  while (i < array.length) {
    var key = array[i];
    hash[key] = fun(key, i);
    i++;
  }
  return hash;
}

function hash_key_with_value(hash, value) {
  var result = void 0;
  (0, _keys2.default)(hash).forEach(function (key) {
    if (hash[key] == value) {
      result = key;
    }
  });
  return result;
}

function set_difference(array, set) {
  var result = {};
  array.forEach(function (key) {
    if (!set[key]) {
      result[key] = true;
    }
  });
  return result;
}

var memoized_distance = make_memoized(function (origin_latitude, origin_longitude, destination_latitude, destination_longitude) {
  function not_set(mesure) {
    return mesure === null || mesure === undefined;
  }
  if (exist([origin_latitude, origin_longitude, destination_latitude, destination_longitude], not_set)) {
    return null;
  } else {
    return _geolib2.default.getDistance({ latitude: origin_latitude, longitude: origin_longitude }, { latitude: destination_latitude, longitude: destination_longitude });
  }
});

function distance(origin, destination) {
  if (!origin || !destination) {
    return null;
  } else {
    return memoized_distance(origin.latitude, origin.longitude, destination.latitude, destination.longitude);
  }
}

function download_file(url, name) {
  var matches = url.match(/(\.\w+)(\?.*)?$/);
  var extension = matches ? matches[1] : "";
  var xhr = new XMLHttpRequest();
  xhr.onreadystatechange = function () {
    if (this.readyState == 4 && this.status == 200) {
      _fileSaver2.default.saveAs(this.response, '' + name.split('.')[0] + extension);
    }
  };
  xhr.open('GET', url);
  xhr.responseType = 'blob';
  xhr.send();
}

function empty_hash(hash) {
  return (0, _keys2.default)(hash).length == 0;
}

function empty_set(set) {
  return for_all((0, _keys2.default)(set), function (key) {
    return !set[key];
  });
}

function empty_array(array) {
  return array.length == 0;
}

function preview(string, length) {
  if (string) {
    if (string.length < length) {
      return string;
    } else {
      return string.slice(0, length - 3) + "...";
    }
  } else {
    return string;
  }
}

function split_array(array, which_category) {
  var categories = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];

  var result = create_hash(categories, function () {
    return [];
  });
  array.forEach(function (element) {
    var category = which_category(element);
    if (result[category]) {
      result[category].push(element);
    } else {
      result[category] = [element];
    }
  });
  return result;
}

function array_minimum(array, is_smaller) {
  var minimum = array[0];
  array.slice(1).forEach(function (element) {
    if (is_smaller(element, minimum)) {
      minimum = element;
    }
  });
  return minimum;
}

function array_maximum(array, is_smaller) {
  return array_minimum(array, function (a, b) {
    return is_smaller(b, a);
  });
}

function split_hash(hash, which_category) {
  var categories = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];

  var result = create_hash(categories, function () {
    return {};
  });
  (0, _keys2.default)(hash).forEach(function (key) {
    var element = hash[key];
    var category = which_category(element);
    if (result[category]) {
      result[category][key] = element;
    } else {
      result[category] = (0, _defineProperty3.default)({}, key, element);
    }
  });
  return result;
}

function flatten_array(arrays) {
  var result = [];
  arrays.forEach(function (array) {
    result.push.apply(result, (0, _toConsumableArray3.default)(array));
  });
  return result;
}

function find_in_array(array, condition) {
  for (var i = 0; i < array.length; i++) {
    if (condition(array[i])) {
      return array[i];
    }
  }
  return null;
}

function find_optimum_in_sorted_array(array, is_too_big) {
  var n = array.length;
  if (n == 0) {
    return -1;
  } else if (n == 1) {
    if (is_too_big(array[0])) {
      return -1;
    } else {
      return 0;
    }
  } else {
    var half = Math.floor(n / 2);
    if (is_too_big(array[half])) {
      return find_optimum_in_sorted_array(array.slice(0, half), is_too_big);
    } else {
      return half + 1 + find_optimum_in_sorted_array(array.slice(half + 1), is_too_big);
    }
  }
}

function group_by_batch(array, batch_count) {
  if (batch_count > array.length) {
    return [array];
  } else {
    return [array.slice(0, batch_count)].concat((0, _toConsumableArray3.default)(group_by_batch(array.slice(batch_count), batch_count)));
  }
}

function group_hash_by_value(hash) {
  var categories = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

  var result = create_hash(categories, function () {
    return [];
  });
  (0, _keys2.default)(hash).forEach(function (key) {
    var value = hash[key];
    if (value) {
      if (!result[value]) {
        result[value] = [];
      }
      result[value].push(key);
    }
  });
  return result;
}

function set_union() {
  var set = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var array = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

  var result = (0, _extends6.default)({}, set);
  array.forEach(function (element) {
    result[element] = true;
  });
  return result;
}

function exist(array, condition) {
  return !for_all(array, function (element) {
    return !condition(element);
  });
}

function empty_object(object) {
  return (0, _keys2.default)(object).length === 0 && object.constructor === Object;
}

function hash_size(hash) {
  return (0, _keys2.default)(hash).length;
}

function array_sum(array) {
  var sum = 0;
  array.forEach(function (value) {
    return sum += value;
  });
  return sum;
}

function array_mean(array) {
  return array_sum(array) / array.length;
}

var unit_counts = [1000, 60, 60, 24, 1e120];
var unit_labels = ["ms", "s", "m", "h", " j"];
function format_duration(duration) {
  var last_unit_value = duration,
      before_last_unit_value = 0,
      unit = 0;
  function step_one_unit() {
    var count = unit_counts[unit];
    var next_unit_value = last_unit_value / count;
    if (unit == unit_counts.length - 1 || next_unit_value < 1) {
      return '' + Math.floor(last_unit_value) + unit_labels[unit] + (before_last_unit_value > 0 ? ' ' + before_last_unit_value + unit_labels[unit - 1] : "");
    } else {
      before_last_unit_value = last_unit_value % count;
      last_unit_value = Math.floor(next_unit_value);
      unit++;
      return step_one_unit();
    }
  }
  return isNaN(duration) ? " - " : step_one_unit();
}

function property_getter(property, default_value) {
  return function (object) {
    return object[property] || default_value;
  };
}

function property_toggler(property) {
  return function () {
    var object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return (0, _extends6.default)({}, object, (0, _defineProperty3.default)({}, property, !object[property]));
  };
}

function set_count(set) {
  return array_from_set(set).length;
}

function property_is(property, value) {
  return function (object) {
    return object[property] == value;
  };
}

function get_url_parameter(parameter) {
  var results = new RegExp('[\?&]' + parameter + '=([^&#]*)').exec(window.location.href);
  return results ? decodeURIComponent(results[1]) : null;
}

function debounce(fun) {
  var wait_for = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;

  var running = false,
      next = void 0;
  return function () {
    for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      args[_key4] = arguments[_key4];
    }

    if (running) {
      next = args;
    } else {
      running = true;
      setTimeout(function () {
        running = false;
        if (next) {
          fun.apply(undefined, (0, _toConsumableArray3.default)(next));
          next = null;
        }
      }, wait_for);
      fun.apply(undefined, args);
    }
  };
}

function set_intersection(set, array) {
  var result = {};
  if (Array.isArray(set)) {
    set = set_from_array(set);
  }
  if (!Array.isArray(array)) {
    array = array_from_set(array);
  }
  array.forEach(function (key) {
    if (set[key]) {
      result[key] = true;
    }
  });
  return result;
}

function set_from_hash(hash) {
  return set_from_array(array_from_hash(hash));
}

var opposite_function = function opposite_function(fun) {
  return function () {
    return -fun.apply(undefined, arguments);
  };
};

function compare(getter) {
  var ascending = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

  var compare = function compare(a, b) {
    var c = getter(a),
        d = getter(b);
    if (c < d) {
      return -1;
    } else if (c > d) {
      return 1;
    } else {
      return 0;
    }
  };
  if (ascending) {
    return compare;
  } else {
    return opposite_function(compare);
  }
}

function scope(scope_name) {
  return function (fun) {
    return function () {
      var object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return (0, _extends6.default)({}, object, (0, _defineProperty3.default)({}, scope_name, fun(object[scope_name])));
    };
  };
}

function filter_set(set, keep) {
  var result = {};
  (0, _keys2.default)(set).forEach(function (element) {
    if (set[element] && keep(element)) {
      result[element] = true;
    }
  });
  return result;
}

function hash_each(hash, each) {
  (0, _keys2.default)(hash || {}).forEach(function (key) {
    return each(key, hash[key]);
  });
}