ruddy/cjs/duck/schema.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.noDucks = exports.isDux = exports.duckMiddlewareRules = exports.duxRules = exports.duxDefaults = exports.metadataEvolvers = undefined;

var _none = require('ramda/src/none');

var _none2 = _interopRequireDefault(_none);

var _complement = require('ramda/src/complement');

var _complement2 = _interopRequireDefault(_complement);

var _difference = require('ramda/src/difference');

var _difference2 = _interopRequireDefault(_difference);

var _keys = require('ramda/src/keys');

var _keys2 = _interopRequireDefault(_keys);

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

var _isEmpty2 = _interopRequireDefault(_isEmpty);

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

var _allPass2 = _interopRequireDefault(_allPass);

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

var _filter2 = _interopRequireDefault(_filter);

var _split = require('ramda/src/split');

var _split2 = _interopRequireDefault(_split);

var _last = require('ramda/src/last');

var _last2 = _interopRequireDefault(_last);

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

var _map2 = _interopRequireDefault(_map);

var _equals = require('ramda/src/equals');

var _equals2 = _interopRequireDefault(_equals);

var _uniq = require('ramda/src/uniq');

var _uniq2 = _interopRequireDefault(_uniq);

var _length = require('ramda/src/length');

var _length2 = _interopRequireDefault(_length);

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

var _toPairs2 = _interopRequireDefault(_toPairs);

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

var _values2 = _interopRequireDefault(_values);

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

var _compose2 = _interopRequireDefault(_compose);

var _anyPass = require('ramda/src/anyPass');

var _anyPass2 = _interopRequireDefault(_anyPass);

var _all = require('ramda/src/all');

var _all2 = _interopRequireDefault(_all);

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

var _is2 = _interopRequireDefault(_is);

var _both = require('ramda/src/both');

var _both2 = _interopRequireDefault(_both);

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

var _either2 = _interopRequireDefault(_either);

var _identity = require('ramda/src/identity');

var _identity2 = _interopRequireDefault(_identity);

var _machines = require('../machines');

var _types = require('../types');

var _is3 = require('../util/is');

var _validators = require('../validators');

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

/**
 * This object of functions is meant to be applied to an object which has
 * some or all of its keys sharing the same name as these evolver functions.
 *
 * Using [evolve()](http://ramdajs.docs/#evolve) on an object with this set of evolver functions
 * will create a clone of the original object with the result of each evolver in place of the original value.
 */
var metadataEvolvers = exports.metadataEvolvers = {
  namespace: _identity2.default,
  store: _identity2.default,
  validationLevel: _validators.makeValidationLevel,
  stateMachinesPropName: _machines.getStateMachinesPropPath,
  consts: _types.createConstants

  /**
   * These are values which will always be set for a new duck,
   * even though the user may not explicitly supply a value for any of them.
   */
};var duxDefaults = exports.duxDefaults = {
  consts: {},
  creators: {},
  machines: {},
  queries: {},
  workers: {},
  selectors: {},
  stateMachinesPropName: 'states',
  types: [],
  validationLevel: 'CANCEL',
  validators: {}

  /**
   * This set of rules is expected to be supplied to the (curried) [spected](https://github.com/25th-floor/spected)
   * function, and is then invoked against the set of values supplied when creating a new duck.
   *
   * The spected validator function will then apply this collection of validator functions against
   * any matching keys on the input values passed in, and set either a value of 'true' if validation succeeded
   * or an array of error messages for any value(s) that failed validation.
   */
};var duxRules = exports.duxRules = {
  validationLevel: [[_validators.isValidationLevel, 'must be: STRICT, CANCEL, PRUNE, or LOG. CANCEL is the default.']],
  store: [[_is3.isGoodString, 'must be a (non-blank) string']],
  namespace: [[_is3.isGoodString, 'must be a (non-blank) string']],
  stateMachinesPropName: [[(0, _either2.default)(_is3.isGoodString, (0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)(_is3.isGoodString))), 'must be a string (or array of strings)']],
  consts: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  creators: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  machines: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  selectors: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  types: [[(0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)((0, _is2.default)(String))), 'must be an object (or a function returning an object)']],
  validators: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  multipliers: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  queries: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  workers: [[(0, _either2.default)(_is3.isPlainObj, (0, _is2.default)(Function)), 'must be an object (or a function returning an object)']],
  reducer: [[(0, _is2.default)(Function), 'must be a function']],
  enhancers: [[(0, _anyPass2.default)([(0, _is2.default)(Function), (0, _both2.default)(_is3.isPlainObj, (0, _compose2.default)((0, _all2.default)(_is3.isSpecOrFunction), _values2.default)), (0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)(_is3.isEnhancer))]), 'must be an array of key/value pairs, an object (or a function returning one of those options)']],
  effects: [[(0, _either2.default)((0, _is2.default)(Function), (0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)(_is3.isEffect))), 'must be an array of key/value pairs (or a function returning an one)']],
  throttling: [[(0, _either2.default)((0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)((0, _is2.default)(Array))), (0, _is2.default)(Function)), 'must be an array of key/value pairs (or a function returning an one)']],
  debouncing: [[(0, _either2.default)((0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)((0, _is2.default)(Array))), (0, _is2.default)(Function)), 'must be an array of key/value pairs (or a function returning an one)']],
  initialState: [[(0, _anyPass2.default)([_is3.isPrimitiveish, _is3.isPlainObj, (0, _is2.default)(Function)]), 'must be an object, a function returning an object, or a primitive value']]

  /**
   * This set of rules is expected to be supplied to the (curried) [spected](https://github.com/25th-floor/spected)
   * function, and is then invoked against one or more ducks supplied to the validator middleware.
   *
   * The spected validator function will then apply this collection of validator functions against
   * any matching keys on the input values passed in, and set either a value of 'true' if validation succeeded
   * or an array of error messages for any value(s) that failed validation.
   *
   * The validator middleware makes use of a small portion of a given duck, so the schema rules
   * for validating a usable duck in the middleware function is less strict than those used to create a duck.
   */
};var duckMiddlewareRules = exports.duckMiddlewareRules = {
  store: [[_is3.isGoodString, 'must be a (non-blank) string']],
  namespace: [[_is3.isGoodString, 'must be a (non-blank) string']],
  types: [[_is3.isPlainObj, 'must be an object'], [(0, _compose2.default)((0, _all2.default)((0, _compose2.default)((0, _equals2.default)(1), _length2.default, _uniq2.default)), (0, _map2.default)(function (_ref) {
    var key = _ref[0],
        val = _ref[1];
    return [key, (0, _compose2.default)(_last2.default, (0, _split2.default)('/'))(val)];
  }), (0, _filter2.default)((0, _all2.default)((0, _is2.default)(String))), _toPairs2.default), 'each key and value are identical']],
  machines: [[(0, _compose2.default)((0, _all2.default)(_is3.isPlainObj), _values2.default), 'must be an object'], [(0, _compose2.default)((0, _all2.default)(_is3.isNotEmpty), _values2.default), 'must not be empty'], [(0, _compose2.default)((0, _all2.default)((0, _allPass2.default)([_machines.areStateNamesStrings, _machines.areInputsAndTransitionsStrings])), _values2.default), 'each machine contains nested objects (states) whose inputs and transitions are strings'], [(0, _compose2.default)((0, _all2.default)(_machines.isEachTransitionAmongMachineStates), _values2.default), 'each transition value must also be a state']],
  stateMachinesPropName: [[(0, _both2.default)((0, _is2.default)(Array), (0, _all2.default)(_is3.isGoodString)), 'must be an array of strings (representing the path to the "current state" prop)']]

  /**
   * Checks to see if a given value is a Duck for middleware,
   * which means it is a namespaced unit that contains types and validators for one or more of those types.
   *
   * @func
   * @sig * -> Boolean
   * @param {*} val A value which may or may not be a Duck instance
   * @returns {Boolean} whether or not the object is an instance of a Duck
   */
};var isDux = exports.isDux = (0, _compose2.default)(_isEmpty2.default, (0, _difference2.default)(['store', 'namespace', 'validators', 'types']), _keys2.default);

/**
 * Checks whether or not a given Object contains ducks
 *
 * @func
 * @sig {k: v} -> Boolean
 * @param {Object} row An Object which may contain ducks among its props
 * @returns {Boolean} whether or not there are any ducks inside of a given Object
 */
var noDucks = exports.noDucks = (0, _anyPass2.default)([(0, _complement2.default)(_is3.isPlainObj), (0, _compose2.default)(_isEmpty2.default, _keys2.default), (0, _compose2.default)((0, _none2.default)(isDux), _values2.default)]);