glance-selector/lib/guides/filter.js

Glance selector library

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

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

var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _extensions = require("../utils/extensions");

var _extensions2 = _interopRequireDefault(_extensions);

var _arrayUtils = require("../utils/array-utils");

var _log = require("../log");

var _log2 = _interopRequireDefault(_log);

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

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

var Filter = function () {
    function Filter() {
        _classCallCheck(this, Filter);
    }

    _createClass(Filter, null, [{
        key: "filter",
        value: function filter(data, callback) {
            var target = data.target,
                unfilteredElements = data.elements,
                extensions = data.extensions,
                config = data.config;

            var filters = Filter.getFilters(target, extensions, config.defaultProperties) || Filter.getDefaultFilters(extensions, config.defaultProperties);

            var beforeFilterElements = Filter.beforeFilters(unfilteredElements, extensions, data);
            var afterFilters = Filter.afterFilters(callback, extensions, data);

            return (0, _arrayUtils.reduce)(filters, beforeFilterElements, function (filteredElements, filter, executeCallback) {
                return filter(_extends({}, data, { elements: filteredElements }), function (err, results) {
                    if (typeof results == 'undefined') results = [];

                    _log2.default.debug("Filtered count:", results.length);

                    return executeCallback(err, results);
                });
            }, afterFilters);
        }
    }, {
        key: "beforeFilters",
        value: function beforeFilters(elements, extensions, data) {
            return extensions.filter(function (e) {
                return e.beforeFilters;
            }).reduce(function (elements, e) {
                return e.beforeFilters(Object.assign(data, { elements: elements }));
            }, elements);
        }
    }, {
        key: "afterFilters",
        value: function afterFilters(callback, extensions, data) {
            return function (err, filteredElements) {
                return callback(err, extensions.filter(function (e) {
                    return e.afterFilters;
                }).reduce(function (elements, e) {
                    return e.afterFilters(Object.assign(data, { elements: elements }));
                }, filteredElements));
            };
        }
    }, {
        key: "getFilters",
        value: function getFilters(target, extensions, defaultProperties) {
            var filters = [];
            var labels = _extensions2.default.labels(extensions);
            var properties = _extensions2.default.properties(extensions);

            if (labels[target.label] && Object.prototype.toString.call(labels[target.label]) !== '[object Array]' && labels[target.label].filter) {
                filters = filters.concat(labels[target.label].filter);
            }

            target.properties.forEach(function (name) {
                if (properties[name] && (properties[name].filter || typeof properties[name] == "function")) {
                    filters = filters.concat(typeof properties[name] == "function" ? properties[name] : properties[name].filter);
                } else {
                    var catchAlls = extensions.filter(function (e) {
                        return e.filter;
                    });
                    if (catchAlls.length > 0) {
                        if (filters.length == 0 && catchAlls[0].filter.useDefaultFiltersIfFirst) {
                            filters = filters.concat(Filter.getDefaultFilters(extensions, defaultProperties));
                        }

                        filters = filters.concat(catchAlls.map(function (e) {
                            return e.filter.apply;
                        }));
                    }
                }
            });

            return filters.length > 0 ? filters : null;
        }
    }, {
        key: "getDefaultFilters",
        value: function getDefaultFilters(extensions, defaultProperties) {
            var properties = _extensions2.default.properties(extensions);

            if (defaultProperties.length > 0) {
                var filters = extensions.filter(function (e) {
                    return e.filter;
                }).map(function (e) {
                    return function (data, callback) {
                        var target = data.target;
                        return e.filter.apply(_extends({}, data, { target: _extends({}, target, { properties: defaultProperties }) }), callback);
                    };
                });

                var propertiesWithFilters = defaultProperties.filter(function (name) {
                    return properties[name] && (properties[name].filter || typeof properties[name] == "function");
                });

                if (propertiesWithFilters.length != 0) {
                    filters = filters.concat(propertiesWithFilters.map(function (name) {
                        return typeof properties[name] == "function" ? properties[name] : properties[name].filter;
                    }));
                }

                return filters;
            }

            return [];
        }
    }]);

    return Filter;
}();

exports.default = Filter;