f-utility/lib/object.js

functional utilities

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.merge = exports.__merge = exports.mapKeys = exports.__mapKeys = exports.mapTuple = exports.mapTuples = exports.pairwiseObject = exports.__pairwiseObject = exports.pairwise = exports.__pairwise = exports.fromPairs = exports.toPairs = exports.entries = exports.assign = exports.freeze = exports.values = exports.keys = undefined;

var _assign2 = require("object-assign");

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _katsuCurry = require("katsu-curry");

var _reduce = require("./reduce");

var _map = require("./map");

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

// import {alterFirstIndex, alterLastIndex} from './array'
var _keys = Object.keys,
    _freeze = Object.freeze,
    _assign = _assign2;

/**
 * Object.keys
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
 * @method keys
 * @param {Object} a - an object
 * @returns {Array} - an array of keys
 * @public
 * @example
 * import {keys} from 'f-utility'
 * keys({a: 1, b: 2}) // [`a`, `b`]
 */

var keys = exports.keys = _keys;

/**
 * @method values
 * @param {Object} x - input
 * @returns {Strings[]} values - an array of properties
 * @public
 * @example
 * import {values} from 'f-utility'
 * values({a:1, b: 2, c: 3}) // [1, 2, 3]
 */
var values = exports.values = function values(x) {
  return keys(x).map(function (y) {
    return x[y];
  });
};

/**
 * Object.freeze
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
 * @method freeze
 * @param {Object} a - an object
 * @returns {Object} - a frozen object
 * @public
 * @example
 * import {freeze} from 'f-utility'
 * const immutable = freeze({a: 1, b: 2})
 * immutable.a = 5 // throws error
 */
var freeze = exports.freeze = _freeze;

/**
 * Object.assign
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
 * @method assign
 * @param {Object} a - any number of objects
 * @returns {Object} - a merged object
 * @public
 * @example
 * import {assign} from 'f-utility'
 * assign({c: 3}, {a: 1, b: 2}) // {a: 1, b: 2, c: 3}
 */
var assign = exports.assign = _assign;

/**
 * Object.entries shim
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
 * @method entries
 * @param {Object} o - an object
 * @returns {Array} - an array of tuples [key, value] pairs
 * @public
 * @example
 * import {entries} from 'f-utility'
 * entries({a: 1, b: 2}) // [[`a`, 1], [`b`, 2]]
 */
var entries = exports.entries = function entries(o) {
  return (0, _katsuCurry.pipe)(keys, (0, _map.map)(function (k) {
    return [k, o[k]];
  }))(o);
};

/**
 * An alias of `entries`
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
 * @method toPairs
 * @param {Object} o - an object
 * @returns {Array} - an array of tuples [key, value] pairs
 * @public
 * @example
 * import {toPairs} from 'f-utility'
 * toPairs({a: 1, b: 2}) // [[`a`, 1], [`b`, 2]]
 */
var toPairs = exports.toPairs = entries;

/**
 * convert a list of key value pairs into an object
 * @method fromPairs
 * @param {Array} - a list of [key, value] pairs
 * @returns {Object} merged results
 * @public
 * @example
 * import {fromPairs} from 'f-utility'
 * fromPairs([[`a`, 1], [`b`, 2]]) // {a: 1, b: 2}
 */
var fromPairs = exports.fromPairs = (0, _reduce.reduce)(function (agg, _ref) {
  var _ref2 = _slicedToArray(_ref, 2),
      k = _ref2[0],
      v = _ref2[1];

  return merge(agg, _defineProperty({}, k, v));
}, {});

/**
 * modify a toPairs / fromPairs pipeline with a higher-order function
 * @method pairwise
 * @param {Function} hoc - a function which wraps a given function, like map or filter
 * @param {Function} fn - a function which iterates over [key, value] tuples
 * @param {Object} o - object
 * @returns {Object} a mapped object
 * @public
 * @example
 * import {filter, mapTuples, pairwiseObject} from 'f-utility'
 * const input = {
 *   a: 1,
 *   b: 2,
 *   c: 3
 * }
 * const fn = ([k, v]) => ([k.toUpperCase(), v * 2])
 * // we could map it
 * mapTuples(fn, input) // {A: 2, B: 4, C: 6}
 * // or we can use pairwiseObject
 * pairwiseObject(filter, ([k, v]) => v % 2 !== 0, input) // {a: 1, c: 3}
 */
var __pairwise = exports.__pairwise = function __pairwise(hoc, fn, o) {
  return (0, _katsuCurry.pipe)(toPairs, hoc(fn))(o);
};
var pairwise = exports.pairwise = (0, _katsuCurry.curry)(__pairwise);
var __pairwiseObject = exports.__pairwiseObject = function __pairwiseObject(hoc, fn, o) {
  return (0, _katsuCurry.pipe)(pairwise(hoc, fn), fromPairs)(o);
};
var pairwiseObject = exports.pairwiseObject = (0, _katsuCurry.curry)(__pairwiseObject);

/**
 * a simple object tuple-mapper
 * @method mapTuples
 * @param {Function} fn - a function which maps over [key, value] tuples
 * @param {Object} o - object
 * @returns {Object} a mapped object
 * @public
 * @example
 * import {mapTuples} from 'f-utility'
 * const input = {
 *   a: 1,
 *   b: 2,
 *   c: 3
 * }
 * const fn = ([k, v]) => ([k.toUpperCase(), v * 2])
 * mapTuples(fn, input) // {A: 2, B: 4, C: 6}
 */
var mapTuples = exports.mapTuples = pairwiseObject(_map.map);
var mapTuple = exports.mapTuple = mapTuples;

/**
 * a simple object key-only tuple-mapper
 * @method mapKeys
 * @param {Function} fn - a function which maps over values only
 * @param {Object} o - object
 * @returns {Object} a mapped object
 * @public
 * @example
 * import {mapKeys} from 'f-utility'
 * const input = {
 *   a: 1,
 *   b: 2,
 *   c: 3
 * }
 * const fn = (v) => `__${v}`
 * mapKeys(fn, input) // {__a: 1, __b: 2, __c: 3}
 */
var __mapKeys = exports.__mapKeys = function __mapKeys(fn, o) {
  return mapTuples(function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 2),
        k = _ref4[0],
        v = _ref4[1];

    return [fn(k), v];
  }, o);
};
var mapKeys = exports.mapKeys = (0, _katsuCurry.curry)(__mapKeys);

/**
 * object.assign but enforced as a binary function
 * @method merge
 * @param {Object} a - object a
 * @param {Object} b - object b
 * @returns {Object} c - the results of merging a and b
 * @public
 * @example
 * import {merge} from 'f-utility'
 * merge({c: 3}, {a: 1, b: 2}) // {a: 1, b: 2, c: 3}
 *
 */
var __merge = exports.__merge = function __merge(a, b) {
  return assign({}, a, b);
};
var merge = exports.merge = (0, _katsuCurry.curry)(__merge);