redux-and-the-rest/cjs/reducers/helpers/applyListOperators.js

Declarative, flexible Redux integration with your RESTful API

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _DataStructures = require("../../constants/DataStructures");

var _contains = _interopRequireDefault(require("../../utils/list/contains"));

var _configuration = require("../../configuration");

var _without = _interopRequireDefault(require("../../utils/list/without"));

var _keysExplicitlyReferencedByListOperations = _interopRequireDefault(require("./keysExplicitlyReferencedByListOperations"));

var _assertInDevMode = _interopRequireDefault(require("../../utils/assertInDevMode"));

var _warn = _interopRequireDefault(require("../../utils/dev/warn"));

var _getList = _interopRequireDefault(require("../../utils/getList"));

var _hasDefinedStatus = _interopRequireDefault(require("../../public-helpers/hasDefinedStatus"));

var _EmptyKey = _interopRequireDefault(require("../../constants/EmptyKey"));

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

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

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; }

function applyListOperators(resources) {
  var listOperations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var itemKey = arguments.length > 2 ? arguments[2] : undefined;
  var updatedLists = {};

  var _getConfiguration = (0, _configuration.getConfiguration)(),
      listWildcard = _getConfiguration.listWildcard;

  var keysExplicitlyReferenced = (0, _keysExplicitlyReferencedByListOperations["default"])(listOperations);

  function pushPosition(listKey) {
    var existingList = (0, _getList["default"])(resources, listKey);

    if (!(0, _hasDefinedStatus["default"])(existingList) && listKey !== _EmptyKey["default"]) {
      return;
    }

    if ((0, _contains["default"])(existingList.positions, itemKey)) {
      updatedLists[listKey] = existingList;
    } else {
      updatedLists[listKey] = _objectSpread(_objectSpread({}, existingList), {}, {
        positions: [].concat(_toConsumableArray(existingList.positions), [itemKey])
      });
    }
  }

  function unshiftPosition(listKey) {
    var existingList = (0, _getList["default"])(resources, listKey);

    if (!(0, _hasDefinedStatus["default"])(existingList) && listKey !== _EmptyKey["default"]) {
      return;
    }

    if ((0, _contains["default"])(existingList.positions, itemKey)) {
      updatedLists[listKey] = existingList;
    } else {
      updatedLists[listKey] = _objectSpread(_objectSpread({}, existingList), {}, {
        positions: [itemKey].concat(_toConsumableArray(existingList.positions))
      });
    }
  }

  function invalidateList(listKey) {
    var existingList = (0, _getList["default"])(resources, listKey);

    if (!(0, _hasDefinedStatus["default"])(existingList) && listKey !== _EmptyKey["default"]) {
      return;
    }

    updatedLists[listKey] = _DataStructures.LIST;
  }

  function applyCustomMerger(listKey, customMerger) {
    var existingList = (0, _getList["default"])(resources, listKey);

    if (!(0, _hasDefinedStatus["default"])(existingList) && listKey !== _EmptyKey["default"]) {
      return;
    }

    var listWithItems = (0, _getList["default"])(resources, listKey);
    var positions = customMerger(listWithItems.items, resources.items[itemKey]);
    (0, _assertInDevMode["default"])(function () {
      if (!Array.isArray(positions)) {
        (0, _warn["default"])("Invalid value '".concat(positions, "' returned from custom merger function for list with key '").concat(listKey, "'.           Check the function you're passing to the merge option returns an array of position values."));
      }
    });
    updatedLists[listKey] = _objectSpread(_objectSpread({}, existingList), {}, {
      positions: positions
    });
  }

  function applyCustomSorter(listKey, customSorter) {
    var existingList = resources.lists[listKey];

    if (!existingList) {
      return;
    }

    var listWithItems = (0, _getList["default"])(resources, listKey);
    var positions = customSorter(listWithItems.items);
    updatedLists[listKey] = _objectSpread(_objectSpread({}, existingList), {}, {
      positions: positions
    });
  }

  function applyToAllListsNotExplicitlyReferenced(listOperation) {
    (0, _without["default"])(Object.keys(resources.lists), keysExplicitlyReferenced).forEach(function (listKey) {
      listOperation(listKey);
    });
  }

  listOperations.push.forEach(function (listKey) {
    if (listKey === listWildcard) {
      applyToAllListsNotExplicitlyReferenced(pushPosition);
    } else {
      pushPosition(listKey);
    }
  });
  listOperations.unshift.forEach(function (listKey) {
    if (listKey === listWildcard) {
      applyToAllListsNotExplicitlyReferenced(unshiftPosition);
    } else {
      unshiftPosition(listKey);
    }
  });
  listOperations.invalidate.forEach(function (listKey) {
    if (listKey === listWildcard) {
      applyToAllListsNotExplicitlyReferenced(invalidateList);
    } else {
      invalidateList(listKey);
    }
  });
  listOperations.merge.forEach(function (mergerKeyPair) {
    var _mergerKeyPair = _slicedToArray(mergerKeyPair, 2),
        keys = _mergerKeyPair[0],
        merger = _mergerKeyPair[1];

    keys.forEach(function (listKey) {
      var applyMerger = function applyMerger(_listKey) {
        return applyCustomMerger(_listKey, merger);
      };

      if (listKey === listWildcard) {
        applyToAllListsNotExplicitlyReferenced(applyMerger);
      } else {
        applyCustomMerger(listKey, merger);
      }
    });
  });
  listOperations.sort.forEach(function (sorterKeyPair) {
    var _sorterKeyPair = _slicedToArray(sorterKeyPair, 2),
        keys = _sorterKeyPair[0],
        sorter = _sorterKeyPair[1];

    keys.forEach(function (listKey) {
      var applySorter = function applySorter(_listKey) {
        return applyCustomSorter(_listKey, sorter);
      };

      if (listKey === listWildcard) {
        applyToAllListsNotExplicitlyReferenced(applySorter);
      } else {
        applyCustomMerger(listKey, sorter);
      }
    });
  });
  return _objectSpread(_objectSpread({}, resources.lists), updatedLists);
}

var _default = applyListOperators;
exports["default"] = _default;