glance-selector/lib/extensions/shortest-scope-and-container-path.js

Glance selector library

"use strict";

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

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

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

var _log2 = _interopRequireDefault(_log);

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

exports.default = {
    properties: {
        "shortestscopeandcontainerpath": {
            filter: function closestdom(_ref, resultHandler) {
                var elements = _ref.elements,
                    scopeElements = _ref.scopeElements,
                    target = _ref.target;

                _log2.default.debug("Filtering for shortest scope and target");

                return browserExecute(function (elements, scopeElements, scopeIndex, handler) {
                    try {
                        var elementsForDistance;
                        var distanceToScopeLookup;
                        var closestLevel;
                        var closestElements;

                        var _ret = function () {
                            var addToLookup = function addToLookup(element, distance) {
                                elementsForDistance.push(element);
                                var i = elementsForDistance.indexOf(element);
                                distanceToScopeLookup[i] = distance;
                            };

                            var lookup = function lookup(element) {
                                var i = elementsForDistance.indexOf(element);
                                if (i == -1) return null;

                                return distanceToScopeLookup[i];
                            };

                            elementsForDistance = [];
                            distanceToScopeLookup = {};


                            if (scopeIndex == 0) return {
                                    v: handler(null, elements)
                                };

                            scopeElements.forEach(function (v) {
                                var p = v;
                                var i = 0;

                                while (p != null && p.outerHTML != null) {
                                    var distanceToScope = lookup(p);

                                    if (!distanceToScope || i < distanceToScope) {
                                        addToLookup(p, i);
                                    }

                                    ++i;

                                    p = p.parentNode;
                                }
                            });

                            closestLevel = -1;
                            closestElements = [];


                            elements.forEach(function (element) {
                                var parent = element;

                                var distanceToScope = lookup(parent);

                                while ((closestLevel == -1 || !distanceToScope || distanceToScope <= closestLevel) && parent != null && parent.outerHTML != null) {
                                    if (distanceToScope || distanceToScope === 0) {
                                        if (distanceToScope < closestLevel) {
                                            closestElements = [];
                                        }

                                        closestLevel = distanceToScope;
                                        closestElements.push(element);
                                        break;
                                    }

                                    parent = parent.parentNode;
                                    distanceToScope = lookup(parent);
                                }
                            });

                            return {
                                v: handler(null, closestElements)
                            };
                        }();

                        if ((typeof _ret === "undefined" ? "undefined" : _typeof(_ret)) === "object") return _ret.v;
                    } catch (err) {
                        return handler(err, []);
                    }
                }, elements, scopeElements, target.scopeIndex, resultHandler);
            }
        }
    }
};