attadux/cjs/types/index.js

Implementation of the redux-modular-ducks, forked from the extensible-duck implementation and extended to include spected validators, state machines, helpers, web workers, effect handling, action multipliers, action enhancers, action throttling/debouncing

'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];
    var 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;
    var store = _ref2.store;
    return (0, _zipObj2['default'])(types, types.map(function (type) {
        return (namespace || '') + '/' + (store || '') + '/' + type;
    }));
});