ruddy/es/selectors/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

import _default10 from 'ramda/src/init';
import _default9 from 'ramda/src/last';
import _default8 from 'ramda/src/converge';
import _default7 from 'ramda/src/memoize';
import _default6 from 'ramda/src/pickBy';
import _default5 from 'ramda/src/reduce';
import _default4 from 'ramda/src/toPairs';
import _default3 from 'ramda/src/prop';
import _default2 from 'ramda/src/equals';
import _default from 'ramda/src/compose';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/**
 * A simple function that checks an Object for a prop called "needsExtraction"
 * and determines if it is set to `true`
 *
 * @func
 * @sig {k: v} -> Boolean
 * @param {Object}
 * @returns {Boolean}
 */
export var needsExtraction = _default(_default2(true), _default3('needsExtraction'));

/**
 * Helper utility to assist in composing the selectors.
 * Previously defined selectors can be used to derive future selectors.
 * Any selector which is a pre-extracted state is expected to have a
 * `needsExtraction: true` and an accompanying `justAddDuckSelectors` prop
 * which performs the extraction. This function creates a sort of running total
 * of all selectors and passes them into each `justAddDuckSelectors()`.
 *
 * @func
 * @sig {k: v} -> {k: v}
 * @param {Object} selectors An Object of selector functions, some of which may
 * need to be extracted (those which require access to fellow selectors)
 * @returns {Object} selectors, but now with access to fellow selectors
 */
export var deriveSelectors = function deriveSelectors() {
  var selectors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return _default(_default5(function (composedSelectors, _ref) {
    var _extends2;

    var key = _ref[0],
        selector = _ref[1];
    return _extends({}, composedSelectors, (_extends2 = {}, _extends2[key] = selector.justAddDuckSelectors(composedSelectors), _extends2));
  }, selectors), _default4, _default6(needsExtraction))(selectors);
};

/**
 * A simple, Ramda implementation of Reselect's `createSelector()` function,
 * taken from [this example](https://twitter.com/sharifsbeat/status/891001130632830976)
 * The cost of all the Ramda functions which make up this library has already been
 * paid, so may as well save on another dependency. You can still use Reselect
 * if you prefer; they both work the same.
 *
 * @func
 * @sig (*... -> a) -> (*... -> a)
 * @ param {...Function} selectors One or more selector functions to be "merged" into one
 * @returns {Function} A memoized "selector" function
 */
export var createSelector = function createSelector() {
  for (var _len = arguments.length, selectors = Array(_len), _key = 0; _key < _len; _key++) {
    selectors[_key] = arguments[_key];
  }

  return _default7(_default8(_default9(selectors), _default10(selectors)));
};

/**
 * Selectors that require one or more of the existing selectors are built using this helper,
 * and the extraction function is passed in as a param. The simplest type of
 * extractor function that this helper was initially built to handle would be:
 *
 * selectors => state => selectors.getSomethingFrom(state)
 *
 * Additionally, the return Object is in a ready-to-be-extracted state (which is
 * why it is flagged `needsExtraction: true`) and so invoking its
 * `justAddDuckSelectors()` will perform the final step of running the extractor
 * (ideally when the rest of the selectors are all being derived)
 *
 * @func
 * @sig Function -> {k: v}
 * @param {Function} extractFunction A helper that will extract all the existing selectors
 * @returns {Object}
 */
export var createDuckSelector = function createDuckSelector(extractFunction) {
  return {
    needsExtraction: true,
    justAddDuckSelectors: function justAddDuckSelectors() {
      var allSelectorsObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var extracted = extractFunction(allSelectorsObject);
      if (Array.isArray(extracted)) {
        return createSelector.apply(undefined, extracted);
      }
      return extracted;
    }
  };
};