ruddy/cjs/types/index.js

Modularized state-management tools for modern front-end applications. Manage dispatched messages in a clean and predictable way for either small or large scale projects

'use strict';

exports.__esModule = true;
exports.createTypes = exports.createConstants = exports.concatOrReplace = exports.getTypes = undefined;

var _curry = require('ramda/src/curry');

var _curry2 = _interopRequireDefault(_curry);

var _filter = require('ramda/src/filter');

var _filter2 = _interopRequireDefault(_filter);

var _always = require('ramda/src/always');

var _always2 = _interopRequireDefault(_always);

var _zipObj = require('ramda/src/zipObj');

var _zipObj2 = _interopRequireDefault(_zipObj);

var _map = require('ramda/src/map');

var _map2 = _interopRequireDefault(_map);

var _isEmpty = require('ramda/src/isEmpty');

var _isEmpty2 = _interopRequireDefault(_isEmpty);

var _isNil = require('ramda/src/isNil');

var _isNil2 = _interopRequireDefault(_isNil);

var _either = require('ramda/src/either');

var _either2 = _interopRequireDefault(_either);

var _any = require('ramda/src/any');

var _any2 = _interopRequireDefault(_any);

var _reject = require('ramda/src/reject');

var _reject2 = _interopRequireDefault(_reject);

var _reduce = require('ramda/src/reduce');

var _reduce2 = _interopRequireDefault(_reduce);

var _toPairs = require('ramda/src/toPairs');

var _toPairs2 = _interopRequireDefault(_toPairs);

var _not = require('ramda/src/not');

var _not2 = _interopRequireDefault(_not);

var _allPass = require('ramda/src/allPass');

var _allPass2 = _interopRequireDefault(_allPass);

var _ifElse = require('ramda/src/ifElse');

var _ifElse2 = _interopRequireDefault(_ifElse);

var _is = require('ramda/src/is');

var _is2 = _interopRequireDefault(_is);

var _prop = require('ramda/src/prop');

var _prop2 = _interopRequireDefault(_prop);

var _values = require('ramda/src/values');

var _values2 = _interopRequireDefault(_values);

var _compose = require('ramda/src/compose');

var _compose2 = _interopRequireDefault(_compose);

var _util = require('../util');

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

/**
 * Retrieves all a duck's namespaced types
 *
 * @func
 * @sig {k: v} -> [String]
 * @param {Object} duck An object containing an object of action types, whose values are namespaced
 * @returns {String[]} A list of all the namespaced types for a given duck
 */
var getTypes = exports.getTypes = (0, _compose2.default)(_values2.default, (0, _prop2.default)('types'));

/**
 * Merges together either two lists or appends a non-list type into another list
 *
 * @func
 * @sig ([a], b) -> [a, b]
 * @param {Array} left A list of any type of values
 * @param {Array|*} right Either a list of values or any kind of non-list value
 * to append to the 'left' list
 * @returns {Array|*} a merged list (if 'left' was an array, otherwise 'right')
 */
var concatOrReplace = exports.concatOrReplace = function concatOrReplace(left, right) {
  return (0, _is2.default)(Array, left) ? [].concat(left, (0, _util.coerceToArray)(right)) : right;
};

/**
 * A function which validates and then deep freezes an object of constants
 *
 * @func
 * @sig {k: v} -> {k: v}
 * @param {Object} constants An Object which should contain only primitive values or arrays of primitives values
 * @returns {Object} A frozen Object with only the values which have been validated
 */
var createConstants = exports.createConstants = (0, _ifElse2.default)(
/* no nested functions or objects, just primitives or conversion of arrays
   * of primitives into simple objects whose keys and vals are the same */
(0, _allPass2.default)([(0, _compose2.default)(_not2.default, _util.isPrimitiveish), (0, _compose2.default)(_not2.default, (0, _is2.default)(Array)), (0, _is2.default)(Object)]), (0, _compose2.default)(Object.freeze, (0, _reduce2.default)(_util.listOfPairsToOneObject, {}), (0, _reject2.default)((0, _any2.default)((0, _either2.default)(_isNil2.default, _isEmpty2.default))), (0, _map2.default)(function (_ref) {
  var name = _ref[0],
      value = _ref[1];

  if ((0, _is2.default)(Array, value)) {
    /* Creates an object whose keys and values are identical */
    return [name, Object.freeze((0, _zipObj2.default)(value.filter(_util.isPrimitiveish), value.filter(_util.isPrimitiveish)))];
  } else if ((0, _util.isPlainObj)(value)) {
    return [name, (0, _compose2.default)((0, _ifElse2.default)(_isEmpty2.default, (0, _always2.default)(null), Object.freeze), (0, _filter2.default)(_util.isPrimitiveish))(value)];
  }
  return (0, _util.isPrimitiveish)(value) ? [name, value] : null;
}), _toPairs2.default, (0, _reject2.default)(_isEmpty2.default)), (0, _always2.default)({}));

/**
 * A function which takes an Object containing namespace and store values and returns
 * a function that will formats an array of strings to have the namespace and
 * store as prefixes.
 *
 * @func
 * @sig {k: v} -> ([String] -> {k: v})
 * @param {Object} p An Object with both a 'namespace' and 'store' string value,
 * from which to format each action type
 * @returns {Function} A function which takes an array of Strings (action types)
 * and creates an Object formatted such that the each key and value matches the string,
 * but formatted as 'namespace/store/type'
 */
var createTypes = exports.createTypes = (0, _curry2.default)(function (_ref2, types) {
  var namespace = _ref2.namespace,
      store = _ref2.store;
  return (0, _zipObj2.default)(types, types.map(function (type) {
    return (namespace || '') + '/' + (store || '') + '/' + type;
  }));
});