@aibsweb/faceted-search/es/classes/state-store.js

A generalized faceted search application.

"use strict";

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

var _castArray = _interopRequireDefault(require("lodash/castArray"));

var _hasIn = _interopRequireDefault(require("lodash/hasIn"));

var _get = _interopRequireDefault(require("lodash/get"));

var _assign = _interopRequireDefault(require("lodash/assign"));

var _enums = require("../enums");

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

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

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var StateStore =
/*#__PURE__*/
function () {
  _createClass(StateStore, null, [{
    key: "getDefaultStore",

    /**
     * Initial state of the store.
     * @param {object} config Contains properties from config json
     * @param {number} defaultLimit The default row limit when fetching data
     */
    value: function getDefaultStore(config, defaultLimit) {
      return {
        scrollTop: 0,
        filter: [],
        dataTable: {
          sort: (0, _get["default"])(config, 'default-sort', []),
          offset: 0,
          limit: defaultLimit
        },
        pivotTable: (0, _get["default"])(config, 'defaultPivotTableSettings')
      };
    }
    /**
     * @param {function} storeUpdateCB - An update function passed from faceted search.
     * @param {object} config - Contains properties from config json.
     */

  }]);

  function StateStore(storeUpdateCB) {
    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    _classCallCheck(this, StateStore);

    this.storeUpdateCB = storeUpdateCB;
    this.defaultLimit = (0, _get["default"])(config, 'rowCountLimit', 1000);
    this.store = StateStore.getDefaultStore(config, this.defaultLimit);
    this.registerListeners();
  }
  /**
   * Add the appropriate event listeners.
   */


  _createClass(StateStore, [{
    key: "registerListeners",
    value: function registerListeners() {
      document.addEventListener(_enums.EVENT_KEYS.DT_SORT, this.handleDataTableSort.bind(this));
      document.addEventListener(_enums.EVENT_KEYS.FILTER, this.handleFilter.bind(this));
      document.addEventListener(_enums.EVENT_KEYS.DT_PAGING, this.handleDataTablePaging.bind(this));
      document.addEventListener(_enums.EVENT_KEYS.SCROLL, this.handleScrollEvent.bind(this));
    } // State Change Event Handlers //

    /**
     * An event handler for the application scroll events.
     *
     * @param {object} e The custom scroll event
     * @param {number} e.detail.scrollTop the current scroll top value for the application
     */

  }, {
    key: "handleScrollEvent",
    value: function handleScrollEvent(e) {
      if ((0, _hasIn["default"])(e, ['detail', 'scrollTop'])) {
        var newScrollValue = (0, _get["default"])(e, ['detail', 'scrollTop']);
        this.store = (0, _assign["default"])({}, this.store, {
          scrollTop: newScrollValue
        });
        this.storeUpdateCB(this.store);
      }
    }
    /**
     * Event handler for the paging event. Sets new offset.
     *
     * @param {event} e - Paging event.
     * @param {object} e.detail - Contains the offset value.
     */

  }, {
    key: "handleDataTablePaging",
    value: function handleDataTablePaging(e) {
      if ((0, _hasIn["default"])(e, ['detail', 'offset'])) {
        var dataTable = this.store.dataTable; // update DataTable in store

        var updatedDataTable = (0, _assign["default"])({}, dataTable, {
          offset: Math.max(e.detail.offset, 0)
        });
        this.store = (0, _assign["default"])({}, this.store, {
          dataTable: updatedDataTable
        }); // update faceted search

        this.storeUpdateCB(this.store);
      }
    }
    /***
     * Event handler for the filter event.
     * @param {object} e - Filter change event.
     * @param {object | object[]} e.detail - Filter info, each element has key-value pairs for 'category', 'value', 'checked'.
     */

  }, {
    key: "handleFilter",
    value: function handleFilter(e) {
      if ((0, _hasIn["default"])(e, 'detail')) {
        var dataTable = this.store.dataTable;
        var nextFilterList = (0, _castArray["default"])(e.detail);
        var nextStoreFilter = nextFilterList.reduce(function (filterStore, nextFilter) {
          if ((0, _hasIn["default"])(nextFilter, 'category') && (0, _hasIn["default"])(nextFilter, 'checked') && (0, _hasIn["default"])(nextFilter, 'value')) {
            if (nextFilter.checked) {
              // if checked, add to filter store
              return [].concat(_toConsumableArray(filterStore), [nextFilter]);
            } else {
              // if not checked, remove from filter store
              return filterStore.filter(function (_ref) {
                var value = _ref.value;
                return value !== nextFilter.value;
              });
            }
          }

          return filterStore;
        }, this.store.filter); // update store, reset page offset value

        this.store = (0, _assign["default"])({}, this.store, {
          filter: nextStoreFilter,
          dataTable: (0, _assign["default"])({}, dataTable, {
            offset: 0
          })
        }); // update faceted search

        this.storeUpdateCB(this.store);
      }
    }
    /***
     * Event handler for sort changes.
     *
     * @param {event} e The sort event, sort data is in e.detail
     * @param {object} e.detail Sort event details { category: string, ascending: bool}
     */

  }, {
    key: "handleDataTableSort",
    value: function handleDataTableSort(e) {
      if ((0, _hasIn["default"])(e, ['detail', 'category']) && (0, _hasIn["default"])(e, ['detail', 'ascending'])) {
        var updatedDataTable = (0, _assign["default"])({}, this.store.dataTable, {
          sort: [e.detail]
        });
        this.store = (0, _assign["default"])({}, this.store, {
          dataTable: updatedDataTable
        }); // update faceted search

        this.storeUpdateCB(this.store);
      }
    }
  }]);

  return StateStore;
}();

exports["default"] = StateStore;