1480 lines
133 KiB
JavaScript
1480 lines
133 KiB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["OptimalSelect"] = factory();
|
|
else
|
|
root["OptimalSelect"] = factory();
|
|
})(this, function() {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId])
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // identity function for calling harmony imports with the correct context
|
|
/******/ __webpack_require__.i = function(value) { return value; };
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
/******/ configurable: false,
|
|
/******/ enumerable: true,
|
|
/******/ get: getter
|
|
/******/ });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 6);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.convertNodeList = convertNodeList;
|
|
exports.escapeValue = escapeValue;
|
|
/**
|
|
* # Utilities
|
|
*
|
|
* Convenience helpers.
|
|
*/
|
|
|
|
/**
|
|
* Create an array with the DOM nodes of the list
|
|
*
|
|
* @param {NodeList} nodes - [description]
|
|
* @return {Array.<HTMLElement>} - [description]
|
|
*/
|
|
function convertNodeList(nodes) {
|
|
var length = nodes.length;
|
|
|
|
var arr = new Array(length);
|
|
for (var i = 0; i < length; i++) {
|
|
arr[i] = nodes[i];
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
/**
|
|
* Escape special characters and line breaks as a simplified version of 'CSS.escape()'
|
|
*
|
|
* Description of valid characters: https://mathiasbynens.be/notes/css-escapes
|
|
*
|
|
* @param {String?} value - [description]
|
|
* @return {String} - [description]
|
|
*/
|
|
function escapeValue(value) {
|
|
return value && value.replace(/['"`\\/:\?&!#$%^()[\]{|}*+;,.<=>@~]/g, '\\$&').replace(/\n/g, '\A');
|
|
}
|
|
|
|
/***/ },
|
|
/* 1 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.getCommonAncestor = getCommonAncestor;
|
|
exports.getCommonProperties = getCommonProperties;
|
|
/**
|
|
* # Common
|
|
*
|
|
* Process collections for similarities.
|
|
*/
|
|
|
|
/**
|
|
* Find the last common ancestor of elements
|
|
*
|
|
* @param {Array.<HTMLElements>} elements - [description]
|
|
* @return {HTMLElement} - [description]
|
|
*/
|
|
function getCommonAncestor(elements) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var _options$root = options.root,
|
|
root = _options$root === undefined ? document : _options$root;
|
|
|
|
|
|
var ancestors = [];
|
|
|
|
elements.forEach(function (element, index) {
|
|
var parents = [];
|
|
while (element !== root) {
|
|
element = element.parentNode;
|
|
parents.unshift(element);
|
|
}
|
|
ancestors[index] = parents;
|
|
});
|
|
|
|
ancestors.sort(function (curr, next) {
|
|
return curr.length - next.length;
|
|
});
|
|
|
|
var shallowAncestor = ancestors.shift();
|
|
|
|
var ancestor = null;
|
|
|
|
var _loop = function _loop() {
|
|
var parent = shallowAncestor[i];
|
|
var missing = ancestors.some(function (otherParents) {
|
|
return !otherParents.some(function (otherParent) {
|
|
return otherParent === parent;
|
|
});
|
|
});
|
|
|
|
if (missing) {
|
|
// TODO: find similar sub-parents, not the top root, e.g. sharing a class selector
|
|
return 'break';
|
|
}
|
|
|
|
ancestor = parent;
|
|
};
|
|
|
|
for (var i = 0, l = shallowAncestor.length; i < l; i++) {
|
|
var _ret = _loop();
|
|
|
|
if (_ret === 'break') break;
|
|
}
|
|
|
|
return ancestor;
|
|
}
|
|
|
|
/**
|
|
* Get a set of common properties of elements
|
|
*
|
|
* @param {Array.<HTMLElement>} elements - [description]
|
|
* @return {Object} - [description]
|
|
*/
|
|
function getCommonProperties(elements) {
|
|
|
|
var commonProperties = {
|
|
classes: [],
|
|
attributes: {},
|
|
tag: null
|
|
};
|
|
|
|
elements.forEach(function (element) {
|
|
var commonClasses = commonProperties.classes,
|
|
commonAttributes = commonProperties.attributes,
|
|
commonTag = commonProperties.tag;
|
|
|
|
// ~ classes
|
|
|
|
if (commonClasses !== undefined) {
|
|
var classes = element.getAttribute('class');
|
|
if (classes) {
|
|
classes = classes.trim().split(' ');
|
|
if (!commonClasses.length) {
|
|
commonProperties.classes = classes;
|
|
} else {
|
|
commonClasses = commonClasses.filter(function (entry) {
|
|
return classes.some(function (name) {
|
|
return name === entry;
|
|
});
|
|
});
|
|
if (commonClasses.length) {
|
|
commonProperties.classes = commonClasses;
|
|
} else {
|
|
delete commonProperties.classes;
|
|
}
|
|
}
|
|
} else {
|
|
// TODO: restructure removal as 2x set / 2x delete, instead of modify always replacing with new collection
|
|
delete commonProperties.classes;
|
|
}
|
|
}
|
|
|
|
// ~ attributes
|
|
if (commonAttributes !== undefined) {
|
|
(function () {
|
|
var elementAttributes = element.attributes;
|
|
var attributes = Object.keys(elementAttributes).reduce(function (attributes, key) {
|
|
var attribute = elementAttributes[key];
|
|
var attributeName = attribute.name;
|
|
// NOTE: workaround detection for non-standard phantomjs NamedNodeMap behaviour
|
|
// (issue: https://github.com/ariya/phantomjs/issues/14634)
|
|
if (attribute && attributeName !== 'class') {
|
|
attributes[attributeName] = attribute.value;
|
|
}
|
|
return attributes;
|
|
}, {});
|
|
|
|
var attributesNames = Object.keys(attributes);
|
|
var commonAttributesNames = Object.keys(commonAttributes);
|
|
|
|
if (attributesNames.length) {
|
|
if (!commonAttributesNames.length) {
|
|
commonProperties.attributes = attributes;
|
|
} else {
|
|
commonAttributes = commonAttributesNames.reduce(function (nextCommonAttributes, name) {
|
|
var value = commonAttributes[name];
|
|
if (value === attributes[name]) {
|
|
nextCommonAttributes[name] = value;
|
|
}
|
|
return nextCommonAttributes;
|
|
}, {});
|
|
if (Object.keys(commonAttributes).length) {
|
|
commonProperties.attributes = commonAttributes;
|
|
} else {
|
|
delete commonProperties.attributes;
|
|
}
|
|
}
|
|
} else {
|
|
delete commonProperties.attributes;
|
|
}
|
|
})();
|
|
}
|
|
|
|
// ~ tag
|
|
if (commonTag !== undefined) {
|
|
var tag = element.tagName.toLowerCase();
|
|
if (!commonTag) {
|
|
commonProperties.tag = tag;
|
|
} else if (tag !== commonTag) {
|
|
delete commonProperties.tag;
|
|
}
|
|
}
|
|
});
|
|
|
|
return commonProperties;
|
|
}
|
|
|
|
/***/ },
|
|
/* 2 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = optimize;
|
|
|
|
var _adapt = __webpack_require__(3);
|
|
|
|
var _adapt2 = _interopRequireDefault(_adapt);
|
|
|
|
var _utilities = __webpack_require__(0);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/**
|
|
* Apply different optimization techniques
|
|
*
|
|
* @param {string} selector - [description]
|
|
* @param {HTMLElement|Array.<HTMLElement>} element - [description]
|
|
* @param {Object} options - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
/**
|
|
* # Optimize
|
|
*
|
|
* 1.) Improve efficiency through shorter selectors by removing redundancy
|
|
* 2.) Improve robustness through selector transformation
|
|
*/
|
|
|
|
function optimize(selector, elements) {
|
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
|
|
|
|
// convert single entry and NodeList
|
|
if (!Array.isArray(elements)) {
|
|
elements = !elements.length ? [elements] : (0, _utilities.convertNodeList)(elements);
|
|
}
|
|
|
|
if (!elements.length || elements.some(function (element) {
|
|
return element.nodeType !== 1;
|
|
})) {
|
|
throw new Error('Invalid input - to compare HTMLElements its necessary to provide a reference of the selected node(s)! (missing "elements")');
|
|
}
|
|
|
|
var globalModified = (0, _adapt2.default)(elements[0], options);
|
|
|
|
// chunk parts outside of quotes (http://stackoverflow.com/a/25663729)
|
|
var path = selector.replace(/> /g, '>').split(/\s+(?=(?:(?:[^"]*"){2})*[^"]*$)/);
|
|
|
|
if (path.length < 2) {
|
|
return optimizePart('', selector, '', elements);
|
|
}
|
|
|
|
var shortened = [path.pop()];
|
|
while (path.length > 1) {
|
|
var current = path.pop();
|
|
var prePart = path.join(' ');
|
|
var postPart = shortened.join(' ');
|
|
|
|
var pattern = prePart + ' ' + postPart;
|
|
var matches = document.querySelectorAll(pattern);
|
|
if (matches.length !== elements.length) {
|
|
shortened.unshift(optimizePart(prePart, current, postPart, elements));
|
|
}
|
|
}
|
|
shortened.unshift(path[0]);
|
|
path = shortened;
|
|
|
|
// optimize start + end
|
|
path[0] = optimizePart('', path[0], path.slice(1).join(' '), elements);
|
|
path[path.length - 1] = optimizePart(path.slice(0, -1).join(' '), path[path.length - 1], '', elements);
|
|
|
|
if (globalModified) {
|
|
delete true;
|
|
}
|
|
|
|
return path.join(' ').replace(/>/g, '> ').trim();
|
|
}
|
|
|
|
/**
|
|
* Improve a chunk of the selector
|
|
*
|
|
* @param {string} prePart - [description]
|
|
* @param {string} current - [description]
|
|
* @param {string} postPart - [description]
|
|
* @param {Array.<HTMLElement>} elements - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
function optimizePart(prePart, current, postPart, elements) {
|
|
if (prePart.length) prePart = prePart + ' ';
|
|
if (postPart.length) postPart = ' ' + postPart;
|
|
|
|
// robustness: attribute without value (generalization)
|
|
if (/\[*\]/.test(current)) {
|
|
var key = current.replace(/=.*$/, ']');
|
|
var pattern = '' + prePart + key + postPart;
|
|
var matches = document.querySelectorAll(pattern);
|
|
if (compareResults(matches, elements)) {
|
|
current = key;
|
|
} else {
|
|
// robustness: replace specific key-value with base tag (heuristic)
|
|
var references = document.querySelectorAll('' + prePart + key);
|
|
|
|
var _loop = function _loop() {
|
|
var reference = references[i];
|
|
if (elements.some(function (element) {
|
|
return reference.contains(element);
|
|
})) {
|
|
var description = reference.tagName.toLowerCase();
|
|
pattern = '' + prePart + description + postPart;
|
|
matches = document.querySelectorAll(pattern);
|
|
|
|
if (compareResults(matches, elements)) {
|
|
current = description;
|
|
}
|
|
return 'break';
|
|
}
|
|
};
|
|
|
|
for (var i = 0, l = references.length; i < l; i++) {
|
|
var pattern;
|
|
var matches;
|
|
|
|
var _ret = _loop();
|
|
|
|
if (_ret === 'break') break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// robustness: descendant instead child (heuristic)
|
|
if (/>/.test(current)) {
|
|
var descendant = current.replace(/>/, '');
|
|
var pattern = '' + prePart + descendant + postPart;
|
|
var matches = document.querySelectorAll(pattern);
|
|
if (compareResults(matches, elements)) {
|
|
current = descendant;
|
|
}
|
|
}
|
|
|
|
// robustness: 'nth-of-type' instead 'nth-child' (heuristic)
|
|
if (/:nth-child/.test(current)) {
|
|
// TODO: consider complete coverage of 'nth-of-type' replacement
|
|
var type = current.replace(/nth-child/g, 'nth-of-type');
|
|
var pattern = '' + prePart + type + postPart;
|
|
var matches = document.querySelectorAll(pattern);
|
|
if (compareResults(matches, elements)) {
|
|
current = type;
|
|
}
|
|
}
|
|
|
|
// efficiency: combinations of classname (partial permutations)
|
|
if (/\.\S+\.\S+/.test(current)) {
|
|
var names = current.trim().split('.').slice(1).map(function (name) {
|
|
return '.' + name;
|
|
}).sort(function (curr, next) {
|
|
return curr.length - next.length;
|
|
});
|
|
while (names.length) {
|
|
var partial = current.replace(names.shift(), '').trim();
|
|
var pattern = ('' + prePart + partial + postPart).trim();
|
|
if (!pattern.length || pattern.charAt(0) === '>' || pattern.charAt(pattern.length - 1) === '>') {
|
|
break;
|
|
}
|
|
var matches = document.querySelectorAll(pattern);
|
|
if (compareResults(matches, elements)) {
|
|
current = partial;
|
|
}
|
|
}
|
|
|
|
// robustness: degrade complex classname (heuristic)
|
|
names = current && current.match(/\./g);
|
|
if (names && names.length > 2) {
|
|
var _references = document.querySelectorAll('' + prePart + current);
|
|
|
|
var _loop2 = function _loop2() {
|
|
var reference = _references[i];
|
|
if (elements.some(function (element) {
|
|
return reference.contains(element);
|
|
})) {
|
|
// TODO:
|
|
// - check using attributes + regard excludes
|
|
var description = reference.tagName.toLowerCase();
|
|
pattern = '' + prePart + description + postPart;
|
|
matches = document.querySelectorAll(pattern);
|
|
|
|
if (compareResults(matches, elements)) {
|
|
current = description;
|
|
}
|
|
return 'break';
|
|
}
|
|
};
|
|
|
|
for (var i = 0, l = _references.length; i < l; i++) {
|
|
var pattern;
|
|
var matches;
|
|
|
|
var _ret2 = _loop2();
|
|
|
|
if (_ret2 === 'break') break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
/**
|
|
* Evaluate matches with expected elements
|
|
*
|
|
* @param {Array.<HTMLElement>} matches - [description]
|
|
* @param {Array.<HTMLElement>} elements - [description]
|
|
* @return {Boolean} - [description]
|
|
*/
|
|
function compareResults(matches, elements) {
|
|
var length = matches.length;
|
|
|
|
return length === elements.length && elements.every(function (element) {
|
|
for (var i = 0; i < length; i++) {
|
|
if (matches[i] === element) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
module.exports = exports['default'];
|
|
|
|
/***/ },
|
|
/* 3 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"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 _slicedToArray = function () { function sliceIterator(arr, i) { 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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
exports.default = adapt;
|
|
/**
|
|
* # Adapt
|
|
*
|
|
* Check and extend the environment for universal usage.
|
|
*/
|
|
|
|
/**
|
|
* Modify the context based on the environment
|
|
*
|
|
* @param {HTMLELement} element - [description]
|
|
* @param {Object} options - [description]
|
|
* @return {boolean} - [description]
|
|
*/
|
|
function adapt(element, options) {
|
|
|
|
// detect environment setup
|
|
if (true) {
|
|
return false;
|
|
} else {
|
|
global.document = options.context || function () {
|
|
var root = element;
|
|
while (root.parent) {
|
|
root = root.parent;
|
|
}
|
|
return root;
|
|
}();
|
|
}
|
|
|
|
// https://github.com/fb55/domhandler/blob/master/index.js#L75
|
|
var ElementPrototype = Object.getPrototypeOf(true);
|
|
|
|
// alternative descriptor to access elements with filtering invalid elements (e.g. textnodes)
|
|
if (!Object.getOwnPropertyDescriptor(ElementPrototype, 'childTags')) {
|
|
Object.defineProperty(ElementPrototype, 'childTags', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return this.children.filter(function (node) {
|
|
// https://github.com/fb55/domelementtype/blob/master/index.js#L12
|
|
return node.type === 'tag' || node.type === 'script' || node.type === 'style';
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
if (!Object.getOwnPropertyDescriptor(ElementPrototype, 'attributes')) {
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element/attributes
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap
|
|
Object.defineProperty(ElementPrototype, 'attributes', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
var attribs = this.attribs;
|
|
|
|
var attributesNames = Object.keys(attribs);
|
|
var NamedNodeMap = attributesNames.reduce(function (attributes, attributeName, index) {
|
|
attributes[index] = {
|
|
name: attributeName,
|
|
value: attribs[attributeName]
|
|
};
|
|
return attributes;
|
|
}, {});
|
|
Object.defineProperty(NamedNodeMap, 'length', {
|
|
enumerable: false,
|
|
configurable: false,
|
|
value: attributesNames.length
|
|
});
|
|
return NamedNodeMap;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (!ElementPrototype.getAttribute) {
|
|
// https://docs.webplatform.org/wiki/dom/Element/getAttribute
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttribute
|
|
ElementPrototype.getAttribute = function (name) {
|
|
return this.attribs[name] || null;
|
|
};
|
|
}
|
|
|
|
if (!ElementPrototype.getElementsByTagName) {
|
|
// https://docs.webplatform.org/wiki/dom/Document/getElementsByTagName
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByTagName
|
|
ElementPrototype.getElementsByTagName = function (tagName) {
|
|
var HTMLCollection = [];
|
|
traverseDescendants(this.childTags, function (descendant) {
|
|
if (descendant.name === tagName || tagName === '*') {
|
|
HTMLCollection.push(descendant);
|
|
}
|
|
});
|
|
return HTMLCollection;
|
|
};
|
|
}
|
|
|
|
if (!ElementPrototype.getElementsByClassName) {
|
|
// https://docs.webplatform.org/wiki/dom/Document/getElementsByClassName
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByClassName
|
|
ElementPrototype.getElementsByClassName = function (className) {
|
|
var names = className.trim().replace(/\s+/g, ' ').split(' ');
|
|
var HTMLCollection = [];
|
|
traverseDescendants([this], function (descendant) {
|
|
var descendantClassName = descendant.attribs.class;
|
|
if (descendantClassName && names.every(function (name) {
|
|
return descendantClassName.indexOf(name) > -1;
|
|
})) {
|
|
HTMLCollection.push(descendant);
|
|
}
|
|
});
|
|
return HTMLCollection;
|
|
};
|
|
}
|
|
|
|
if (!ElementPrototype.querySelectorAll) {
|
|
// https://docs.webplatform.org/wiki/css/selectors_api/querySelectorAll
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element/querySelectorAll
|
|
ElementPrototype.querySelectorAll = function (selectors) {
|
|
var _this = this;
|
|
|
|
selectors = selectors.replace(/(>)(\S)/g, '$1 $2').trim(); // add space for '>' selector
|
|
|
|
// using right to left execution => https://github.com/fb55/css-select#how-does-it-work
|
|
var instructions = getInstructions(selectors);
|
|
var discover = instructions.shift();
|
|
|
|
var total = instructions.length;
|
|
return discover(this).filter(function (node) {
|
|
var step = 0;
|
|
while (step < total) {
|
|
node = instructions[step](node, _this);
|
|
if (!node) {
|
|
// hierarchy doesn't match
|
|
return false;
|
|
}
|
|
step += 1;
|
|
}
|
|
return true;
|
|
});
|
|
};
|
|
}
|
|
|
|
if (!ElementPrototype.contains) {
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Node/contains
|
|
ElementPrototype.contains = function (element) {
|
|
var inclusive = false;
|
|
traverseDescendants([this], function (descendant, done) {
|
|
if (descendant === element) {
|
|
inclusive = true;
|
|
done();
|
|
}
|
|
});
|
|
return inclusive;
|
|
};
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Retrieve transformation steps
|
|
*
|
|
* @param {Array.<string>} selectors - [description]
|
|
* @return {Array.<Function>} - [description]
|
|
*/
|
|
function getInstructions(selectors) {
|
|
return selectors.split(' ').reverse().map(function (selector, step) {
|
|
var discover = step === 0;
|
|
|
|
var _selector$split = selector.split(':'),
|
|
_selector$split2 = _slicedToArray(_selector$split, 2),
|
|
type = _selector$split2[0],
|
|
pseudo = _selector$split2[1];
|
|
|
|
var validate = null;
|
|
var instruction = null;
|
|
|
|
(function () {
|
|
switch (true) {
|
|
|
|
// child: '>'
|
|
case />/.test(type):
|
|
instruction = function checkParent(node) {
|
|
return function (validate) {
|
|
return validate(node.parent) && node.parent;
|
|
};
|
|
};
|
|
break;
|
|
|
|
// class: '.'
|
|
case /^\./.test(type):
|
|
var names = type.substr(1).split('.');
|
|
validate = function validate(node) {
|
|
var nodeClassName = node.attribs.class;
|
|
return nodeClassName && names.every(function (name) {
|
|
return nodeClassName.indexOf(name) > -1;
|
|
});
|
|
};
|
|
instruction = function checkClass(node, root) {
|
|
if (discover) {
|
|
return node.getElementsByClassName(names.join(' '));
|
|
}
|
|
return typeof node === 'function' ? node(validate) : getAncestor(node, root, validate);
|
|
};
|
|
break;
|
|
|
|
// attribute: '[key="value"]'
|
|
case /^\[/.test(type):
|
|
var _type$replace$split = type.replace(/\[|\]|"/g, '').split('='),
|
|
_type$replace$split2 = _slicedToArray(_type$replace$split, 2),
|
|
attributeKey = _type$replace$split2[0],
|
|
attributeValue = _type$replace$split2[1];
|
|
|
|
validate = function validate(node) {
|
|
var hasAttribute = Object.keys(node.attribs).indexOf(attributeKey) > -1;
|
|
if (hasAttribute) {
|
|
// regard optional attributeValue
|
|
if (!attributeValue || node.attribs[attributeKey] === attributeValue) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
instruction = function checkAttribute(node, root) {
|
|
if (discover) {
|
|
var _ret2 = function () {
|
|
var NodeList = [];
|
|
traverseDescendants([node], function (descendant) {
|
|
if (validate(descendant)) {
|
|
NodeList.push(descendant);
|
|
}
|
|
});
|
|
return {
|
|
v: NodeList
|
|
};
|
|
}();
|
|
|
|
if ((typeof _ret2 === 'undefined' ? 'undefined' : _typeof(_ret2)) === "object") return _ret2.v;
|
|
}
|
|
return typeof node === 'function' ? node(validate) : getAncestor(node, root, validate);
|
|
};
|
|
break;
|
|
|
|
// id: '#'
|
|
case /^#/.test(type):
|
|
var id = type.substr(1);
|
|
validate = function validate(node) {
|
|
return node.attribs.id === id;
|
|
};
|
|
instruction = function checkId(node, root) {
|
|
if (discover) {
|
|
var _ret3 = function () {
|
|
var NodeList = [];
|
|
traverseDescendants([node], function (descendant, done) {
|
|
if (validate(descendant)) {
|
|
NodeList.push(descendant);
|
|
done();
|
|
}
|
|
});
|
|
return {
|
|
v: NodeList
|
|
};
|
|
}();
|
|
|
|
if ((typeof _ret3 === 'undefined' ? 'undefined' : _typeof(_ret3)) === "object") return _ret3.v;
|
|
}
|
|
return typeof node === 'function' ? node(validate) : getAncestor(node, root, validate);
|
|
};
|
|
break;
|
|
|
|
// universal: '*'
|
|
case /\*/.test(type):
|
|
validate = function validate(node) {
|
|
return true;
|
|
};
|
|
instruction = function checkUniversal(node, root) {
|
|
if (discover) {
|
|
var _ret4 = function () {
|
|
var NodeList = [];
|
|
traverseDescendants([node], function (descendant) {
|
|
return NodeList.push(descendant);
|
|
});
|
|
return {
|
|
v: NodeList
|
|
};
|
|
}();
|
|
|
|
if ((typeof _ret4 === 'undefined' ? 'undefined' : _typeof(_ret4)) === "object") return _ret4.v;
|
|
}
|
|
return typeof node === 'function' ? node(validate) : getAncestor(node, root, validate);
|
|
};
|
|
break;
|
|
|
|
// tag: '...'
|
|
default:
|
|
validate = function validate(node) {
|
|
return node.name === type;
|
|
};
|
|
instruction = function checkTag(node, root) {
|
|
if (discover) {
|
|
var _ret5 = function () {
|
|
var NodeList = [];
|
|
traverseDescendants([node], function (descendant) {
|
|
if (validate(descendant)) {
|
|
NodeList.push(descendant);
|
|
}
|
|
});
|
|
return {
|
|
v: NodeList
|
|
};
|
|
}();
|
|
|
|
if ((typeof _ret5 === 'undefined' ? 'undefined' : _typeof(_ret5)) === "object") return _ret5.v;
|
|
}
|
|
return typeof node === 'function' ? node(validate) : getAncestor(node, root, validate);
|
|
};
|
|
}
|
|
})();
|
|
|
|
if (!pseudo) {
|
|
return instruction;
|
|
}
|
|
|
|
var rule = pseudo.match(/-(child|type)\((\d+)\)$/);
|
|
var kind = rule[1];
|
|
var index = parseInt(rule[2], 10) - 1;
|
|
|
|
var validatePseudo = function validatePseudo(node) {
|
|
if (node) {
|
|
var compareSet = node.parent.childTags;
|
|
if (kind === 'type') {
|
|
compareSet = compareSet.filter(validate);
|
|
}
|
|
var nodeIndex = compareSet.findIndex(function (child) {
|
|
return child === node;
|
|
});
|
|
if (nodeIndex === index) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
return function enhanceInstruction(node) {
|
|
var match = instruction(node);
|
|
if (discover) {
|
|
return match.reduce(function (NodeList, matchedNode) {
|
|
if (validatePseudo(matchedNode)) {
|
|
NodeList.push(matchedNode);
|
|
}
|
|
return NodeList;
|
|
}, []);
|
|
}
|
|
return validatePseudo(match) && match;
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Walking recursive to invoke callbacks
|
|
*
|
|
* @param {Array.<HTMLElement>} nodes - [description]
|
|
* @param {Function} handler - [description]
|
|
*/
|
|
function traverseDescendants(nodes, handler) {
|
|
nodes.forEach(function (node) {
|
|
var progress = true;
|
|
handler(node, function () {
|
|
return progress = false;
|
|
});
|
|
if (node.childTags && progress) {
|
|
traverseDescendants(node.childTags, handler);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Bubble up from bottom to top
|
|
*
|
|
* @param {HTMLELement} node - [description]
|
|
* @param {HTMLELement} root - [description]
|
|
* @param {Function} validate - [description]
|
|
* @return {HTMLELement} - [description]
|
|
*/
|
|
function getAncestor(node, root, validate) {
|
|
while (node.parent) {
|
|
node = node.parent;
|
|
if (validate(node)) {
|
|
return node;
|
|
}
|
|
if (node === root) {
|
|
break;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
module.exports = exports['default'];
|
|
|
|
/***/ },
|
|
/* 4 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"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; }; /**
|
|
* # Select
|
|
*
|
|
* Construct a unique CSS query selector to access the selected DOM element(s).
|
|
* For longevity it applies different matching and optimization strategies.
|
|
*/
|
|
|
|
exports.getSingleSelector = getSingleSelector;
|
|
exports.getMultiSelector = getMultiSelector;
|
|
exports.default = getQuerySelector;
|
|
|
|
var _adapt = __webpack_require__(3);
|
|
|
|
var _adapt2 = _interopRequireDefault(_adapt);
|
|
|
|
var _match = __webpack_require__(5);
|
|
|
|
var _match2 = _interopRequireDefault(_match);
|
|
|
|
var _optimize = __webpack_require__(2);
|
|
|
|
var _optimize2 = _interopRequireDefault(_optimize);
|
|
|
|
var _utilities = __webpack_require__(0);
|
|
|
|
var _common = __webpack_require__(1);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/**
|
|
* Get a selector for the provided element
|
|
*
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} options - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
function getSingleSelector(element) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
|
|
if (element.nodeType === 3) {
|
|
element = element.parentNode;
|
|
}
|
|
|
|
if (element.nodeType !== 1) {
|
|
throw new Error('Invalid input - only HTMLElements or representations of them are supported! (not "' + (typeof element === 'undefined' ? 'undefined' : _typeof(element)) + '")');
|
|
}
|
|
|
|
var globalModified = (0, _adapt2.default)(element, options);
|
|
|
|
var selector = (0, _match2.default)(element, options);
|
|
var optimized = (0, _optimize2.default)(selector, element, options);
|
|
|
|
// debug
|
|
// console.log(`
|
|
// selector: ${selector}
|
|
// optimized: ${optimized}
|
|
// `)
|
|
|
|
if (globalModified) {
|
|
delete true;
|
|
}
|
|
|
|
return optimized;
|
|
}
|
|
|
|
/**
|
|
* Get a selector to match multiple descendants from an ancestor
|
|
*
|
|
* @param {Array.<HTMLElement>|NodeList} elements - [description]
|
|
* @param {Object} options - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
function getMultiSelector(elements) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
|
|
if (!Array.isArray(elements)) {
|
|
elements = (0, _utilities.convertNodeList)(elements);
|
|
}
|
|
|
|
if (elements.some(function (element) {
|
|
return element.nodeType !== 1;
|
|
})) {
|
|
throw new Error('Invalid input - only an Array of HTMLElements or representations of them is supported!');
|
|
}
|
|
|
|
var globalModified = (0, _adapt2.default)(elements[0], options);
|
|
|
|
var ancestor = (0, _common.getCommonAncestor)(elements, options);
|
|
var ancestorSelector = getSingleSelector(ancestor, options);
|
|
|
|
// TODO: consider usage of multiple selectors + parent-child relation + check for part redundancy
|
|
var commonSelectors = getCommonSelectors(elements);
|
|
var descendantSelector = commonSelectors[0];
|
|
|
|
var selector = (0, _optimize2.default)(ancestorSelector + ' ' + descendantSelector, elements, options);
|
|
var selectorMatches = (0, _utilities.convertNodeList)(document.querySelectorAll(selector));
|
|
|
|
if (!elements.every(function (element) {
|
|
return selectorMatches.some(function (entry) {
|
|
return entry === element;
|
|
});
|
|
})) {
|
|
// TODO: cluster matches to split into similar groups for sub selections
|
|
return console.warn('\n The selected elements can\'t be efficiently mapped.\n Its probably best to use multiple single selectors instead!\n ', elements);
|
|
}
|
|
|
|
if (globalModified) {
|
|
delete true;
|
|
}
|
|
|
|
return selector;
|
|
}
|
|
|
|
/**
|
|
* Get selectors to describe a set of elements
|
|
*
|
|
* @param {Array.<HTMLElements>} elements - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
function getCommonSelectors(elements) {
|
|
var _getCommonProperties = (0, _common.getCommonProperties)(elements),
|
|
classes = _getCommonProperties.classes,
|
|
attributes = _getCommonProperties.attributes,
|
|
tag = _getCommonProperties.tag;
|
|
|
|
var selectorPath = [];
|
|
|
|
if (tag) {
|
|
selectorPath.push(tag);
|
|
}
|
|
|
|
if (classes) {
|
|
var classSelector = classes.map(function (name) {
|
|
return '.' + name;
|
|
}).join('');
|
|
selectorPath.push(classSelector);
|
|
}
|
|
|
|
if (attributes) {
|
|
var attributeSelector = Object.keys(attributes).reduce(function (parts, name) {
|
|
parts.push('[' + name + '="' + attributes[name] + '"]');
|
|
return parts;
|
|
}, []).join('');
|
|
selectorPath.push(attributeSelector);
|
|
}
|
|
|
|
if (selectorPath.length) {
|
|
// TODO: check for parent-child relation
|
|
}
|
|
|
|
return [selectorPath.join('')];
|
|
}
|
|
|
|
/**
|
|
* Choose action depending on the input (multiple/single)
|
|
*
|
|
* NOTE: extended detection is used for special cases like the <select> element with <options>
|
|
*
|
|
* @param {HTMLElement|NodeList|Array.<HTMLElement>} input - [description]
|
|
* @param {Object} options - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
function getQuerySelector(input) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
if (input.length && !input.name) {
|
|
return getMultiSelector(input, options);
|
|
}
|
|
return getSingleSelector(input, options);
|
|
}
|
|
|
|
/***/ },
|
|
/* 5 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = match;
|
|
|
|
var _utilities = __webpack_require__(0);
|
|
|
|
var defaultIgnore = {
|
|
attribute: function attribute(attributeName) {
|
|
return ['style', 'data-reactid', 'data-react-checksum'].indexOf(attributeName) > -1;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get the path of the element
|
|
*
|
|
* @param {HTMLElement} node - [description]
|
|
* @param {Object} options - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
/**
|
|
* # Match
|
|
*
|
|
* Retrieve selector for a node.
|
|
*/
|
|
|
|
function match(node, options) {
|
|
var _options$root = options.root,
|
|
root = _options$root === undefined ? document : _options$root,
|
|
_options$skip = options.skip,
|
|
skip = _options$skip === undefined ? null : _options$skip,
|
|
_options$priority = options.priority,
|
|
priority = _options$priority === undefined ? ['id', 'class', 'href', 'src'] : _options$priority,
|
|
_options$ignore = options.ignore,
|
|
ignore = _options$ignore === undefined ? {} : _options$ignore;
|
|
|
|
|
|
var path = [];
|
|
var element = node;
|
|
var length = path.length;
|
|
var ignoreClass = false;
|
|
|
|
var skipCompare = skip && (Array.isArray(skip) ? skip : [skip]).map(function (entry) {
|
|
if (typeof entry !== 'function') {
|
|
return function (element) {
|
|
return element === entry;
|
|
};
|
|
}
|
|
return entry;
|
|
});
|
|
|
|
var skipChecks = function skipChecks(element) {
|
|
return skip && skipCompare.some(function (compare) {
|
|
return compare(element);
|
|
});
|
|
};
|
|
|
|
Object.keys(ignore).forEach(function (type) {
|
|
if (type === 'class') {
|
|
ignoreClass = true;
|
|
}
|
|
var predicate = ignore[type];
|
|
if (typeof predicate === 'function') return;
|
|
if (typeof predicate === 'number') {
|
|
predicate = predicate.toString();
|
|
}
|
|
if (typeof predicate === 'string') {
|
|
predicate = new RegExp((0, _utilities.escapeValue)(predicate).replace(/\\/g, '\\\\'));
|
|
}
|
|
if (typeof predicate === 'boolean') {
|
|
predicate = predicate ? /(?:)/ : /.^/;
|
|
}
|
|
// check class-/attributename for regex
|
|
ignore[type] = function (name, value) {
|
|
return predicate.test(value);
|
|
};
|
|
});
|
|
|
|
if (ignoreClass) {
|
|
(function () {
|
|
var ignoreAttribute = ignore.attribute;
|
|
ignore.attribute = function (name, value, defaultPredicate) {
|
|
return ignore.class(value) || ignoreAttribute && ignoreAttribute(name, value, defaultPredicate);
|
|
};
|
|
})();
|
|
}
|
|
|
|
while (element !== root) {
|
|
if (skipChecks(element) !== true) {
|
|
// ~ global
|
|
if (checkAttributes(priority, element, ignore, path, root)) break;
|
|
if (checkTag(element, ignore, path, root)) break;
|
|
|
|
// ~ local
|
|
checkAttributes(priority, element, ignore, path);
|
|
if (path.length === length) {
|
|
checkTag(element, ignore, path);
|
|
}
|
|
|
|
// define only one part each iteration
|
|
if (path.length === length) {
|
|
checkChilds(priority, element, ignore, path);
|
|
}
|
|
}
|
|
|
|
element = element.parentNode;
|
|
length = path.length;
|
|
}
|
|
|
|
if (element === root) {
|
|
var pattern = findPattern(priority, element, ignore);
|
|
path.unshift(pattern);
|
|
}
|
|
|
|
return path.join(' ');
|
|
}
|
|
|
|
/**
|
|
* Extend path with attribute identifier
|
|
*
|
|
* @param {Array.<string>} priority - [description]
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} ignore - [description]
|
|
* @param {Array.<string>} path - [description]
|
|
* @param {HTMLElement} parent - [description]
|
|
* @return {boolean} - [description]
|
|
*/
|
|
function checkAttributes(priority, element, ignore, path) {
|
|
var parent = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : element.parentNode;
|
|
|
|
var pattern = findAttributesPattern(priority, element, ignore);
|
|
if (pattern) {
|
|
var matches = parent.querySelectorAll(pattern);
|
|
if (matches.length === 1) {
|
|
path.unshift(pattern);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Lookup attribute identifier
|
|
*
|
|
* @param {Array.<string>} priority - [description]
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} ignore - [description]
|
|
* @return {string?} - [description]
|
|
*/
|
|
function findAttributesPattern(priority, element, ignore) {
|
|
var attributes = element.attributes;
|
|
var sortedKeys = Object.keys(attributes).sort(function (curr, next) {
|
|
var currPos = priority.indexOf(attributes[curr].name);
|
|
var nextPos = priority.indexOf(attributes[next].name);
|
|
if (nextPos === -1) {
|
|
if (currPos === -1) {
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
return currPos - nextPos;
|
|
});
|
|
|
|
for (var i = 0, l = sortedKeys.length; i < l; i++) {
|
|
var key = sortedKeys[i];
|
|
var attribute = attributes[key];
|
|
var attributeName = attribute.name;
|
|
var attributeValue = (0, _utilities.escapeValue)(attribute.value);
|
|
|
|
var currentIgnore = ignore[attributeName] || ignore.attribute;
|
|
var currentDefaultIgnore = defaultIgnore[attributeName] || defaultIgnore.attribute;
|
|
if (checkIgnore(currentIgnore, attributeName, attributeValue, currentDefaultIgnore)) {
|
|
continue;
|
|
}
|
|
|
|
var pattern = '[' + attributeName + '="' + attributeValue + '"]';
|
|
|
|
if (/\b\d/.test(attributeValue) === false) {
|
|
if (attributeName === 'id') {
|
|
pattern = '#' + attributeValue;
|
|
}
|
|
|
|
if (attributeName === 'class') {
|
|
var className = attributeValue.trim().replace(/\s+/g, '.');
|
|
pattern = '.' + className;
|
|
}
|
|
}
|
|
|
|
return pattern;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extend path with tag identifier
|
|
*
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} ignore - [description]
|
|
* @param {Array.<string>} path - [description]
|
|
* @param {HTMLElement} parent - [description]
|
|
* @return {boolean} - [description]
|
|
*/
|
|
function checkTag(element, ignore, path) {
|
|
var parent = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : element.parentNode;
|
|
|
|
var pattern = findTagPattern(element, ignore);
|
|
if (pattern) {
|
|
var matches = parent.getElementsByTagName(pattern);
|
|
if (matches.length === 1) {
|
|
path.unshift(pattern);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Lookup tag identifier
|
|
*
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} ignore - [description]
|
|
* @return {boolean} - [description]
|
|
*/
|
|
function findTagPattern(element, ignore) {
|
|
var tagName = element.tagName.toLowerCase();
|
|
if (checkIgnore(ignore.tag, null, tagName)) {
|
|
return null;
|
|
}
|
|
return tagName;
|
|
}
|
|
|
|
/**
|
|
* Extend path with specific child identifier
|
|
*
|
|
* NOTE: 'childTags' is a custom property to use as a view filter for tags using 'adapter.js'
|
|
*
|
|
* @param {Array.<string>} priority - [description]
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} ignore - [description]
|
|
* @param {Array.<string>} path - [description]
|
|
* @return {boolean} - [description]
|
|
*/
|
|
function checkChilds(priority, element, ignore, path) {
|
|
var parent = element.parentNode;
|
|
var children = parent.childTags || parent.children;
|
|
for (var i = 0, l = children.length; i < l; i++) {
|
|
var child = children[i];
|
|
if (child === element) {
|
|
var childPattern = findPattern(priority, child, ignore);
|
|
if (!childPattern) {
|
|
return console.warn('\n Element couldn\'t be matched through strict ignore pattern!\n ', child, ignore, childPattern);
|
|
}
|
|
var pattern = '> ' + childPattern + ':nth-child(' + (i + 1) + ')';
|
|
path.unshift(pattern);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Lookup identifier
|
|
*
|
|
* @param {Array.<string>} priority - [description]
|
|
* @param {HTMLElement} element - [description]
|
|
* @param {Object} ignore - [description]
|
|
* @return {string} - [description]
|
|
*/
|
|
function findPattern(priority, element, ignore) {
|
|
var pattern = findAttributesPattern(priority, element, ignore);
|
|
if (!pattern) {
|
|
pattern = findTagPattern(element, ignore);
|
|
}
|
|
return pattern;
|
|
}
|
|
|
|
/**
|
|
* Validate with custom and default functions
|
|
*
|
|
* @param {Function} predicate - [description]
|
|
* @param {string?} name - [description]
|
|
* @param {string} value - [description]
|
|
* @param {Function} defaultPredicate - [description]
|
|
* @return {boolean} - [description]
|
|
*/
|
|
function checkIgnore(predicate, name, value, defaultPredicate) {
|
|
if (!value) {
|
|
return true;
|
|
}
|
|
var check = predicate || defaultPredicate;
|
|
if (!check) {
|
|
return false;
|
|
}
|
|
return check(name, value, defaultPredicate);
|
|
}
|
|
module.exports = exports['default'];
|
|
|
|
/***/ },
|
|
/* 6 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.common = exports.optimize = exports.getMultiSelector = exports.getSingleSelector = exports.select = undefined;
|
|
|
|
var _select2 = __webpack_require__(4);
|
|
|
|
Object.defineProperty(exports, 'getSingleSelector', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _select2.getSingleSelector;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'getMultiSelector', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _select2.getMultiSelector;
|
|
}
|
|
});
|
|
|
|
var _select3 = _interopRequireDefault(_select2);
|
|
|
|
var _optimize2 = __webpack_require__(2);
|
|
|
|
var _optimize3 = _interopRequireDefault(_optimize2);
|
|
|
|
var _common2 = __webpack_require__(1);
|
|
|
|
var _common = _interopRequireWildcard(_common2);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.select = _select3.default;
|
|
exports.optimize = _optimize3.default;
|
|
exports.common = _common;
|
|
exports.default = _select3.default;
|
|
|
|
/***/ }
|
|
/******/ ]);
|
|
});
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap a8e0297cdd416bc0f326","webpack:///./src/utilities.js","webpack:///./src/common.js","webpack:///./src/optimize.js","webpack:///./src/adapt.js","webpack:///./src/select.js","webpack:///./src/match.js","webpack:///./src/index.js"],"names":["convertNodeList","escapeValue","nodes","length","arr","Array","i","value","replace","getCommonAncestor","getCommonProperties","elements","options","root","document","ancestors","forEach","element","index","parents","parentNode","unshift","sort","curr","next","shallowAncestor","shift","ancestor","parent","missing","some","otherParents","otherParent","l","commonProperties","classes","attributes","tag","commonClasses","commonAttributes","commonTag","undefined","getAttribute","trim","split","filter","entry","name","elementAttributes","Object","keys","reduce","key","attribute","attributeName","attributesNames","commonAttributesNames","nextCommonAttributes","tagName","toLowerCase","optimize","selector","isArray","nodeType","Error","globalModified","path","optimizePart","shortened","pop","current","prePart","join","postPart","pattern","matches","querySelectorAll","slice","test","compareResults","references","reference","contains","description","descendant","type","names","map","partial","charAt","match","every","adapt","global","context","ElementPrototype","getPrototypeOf","getOwnPropertyDescriptor","defineProperty","enumerable","get","children","node","attribs","NamedNodeMap","configurable","getElementsByTagName","HTMLCollection","traverseDescendants","childTags","push","getElementsByClassName","className","descendantClassName","class","indexOf","selectors","instructions","getInstructions","discover","total","step","inclusive","done","reverse","pseudo","validate","instruction","checkParent","substr","nodeClassName","checkClass","getAncestor","attributeKey","attributeValue","hasAttribute","checkAttribute","NodeList","id","checkId","checkUniversal","checkTag","rule","kind","parseInt","validatePseudo","compareSet","nodeIndex","findIndex","child","enhanceInstruction","matchedNode","handler","progress","getSingleSelector","getMultiSelector","getQuerySelector","optimized","ancestorSelector","commonSelectors","getCommonSelectors","descendantSelector","selectorMatches","console","warn","selectorPath","classSelector","attributeSelector","parts","input","defaultIgnore","skip","priority","ignore","ignoreClass","skipCompare","skipChecks","compare","predicate","toString","RegExp","ignoreAttribute","defaultPredicate","checkAttributes","checkChilds","findPattern","findAttributesPattern","sortedKeys","currPos","nextPos","currentIgnore","currentDefaultIgnore","checkIgnore","findTagPattern","childPattern","check","select","common","default"],"mappings":"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","file":"optimal-select.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"OptimalSelect\"] = factory();\n\telse\n\t\troot[\"OptimalSelect\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 6);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap a8e0297cdd416bc0f326","/**\n * # Utilities\n *\n * Convenience helpers.\n */\n\n/**\n * Create an array with the DOM nodes of the list\n *\n * @param  {NodeList}             nodes - [description]\n * @return {Array.<HTMLElement>}        - [description]\n */\nexport function convertNodeList (nodes) {\n  const { length } = nodes\n  const arr = new Array(length)\n  for (var i = 0; i < length; i++) {\n    arr[i] = nodes[i]\n  }\n  return arr\n}\n\n/**\n * Escape special characters and line breaks as a simplified version of 'CSS.escape()'\n *\n * Description of valid characters: https://mathiasbynens.be/notes/css-escapes\n *\n * @param  {String?} value - [description]\n * @return {String}        - [description]\n */\nexport function escapeValue (value) {\n  return value && value.replace(/['\"`\\\\/:\\?&!#$%^()[\\]{|}*+;,.<=>@~]/g, '\\\\$&')\n                       .replace(/\\n/g, '\\A')\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/utilities.js","/**\n * # Common\n *\n * Process collections for similarities.\n */\n\n/**\n * Find the last common ancestor of elements\n *\n * @param  {Array.<HTMLElements>} elements - [description]\n * @return {HTMLElement}                   - [description]\n */\nexport function getCommonAncestor (elements, options = {}) {\n\n  const {\n    root = document\n  } = options\n\n  const ancestors = []\n\n  elements.forEach((element, index) => {\n    const parents = []\n    while (element !== root) {\n      element = element.parentNode\n      parents.unshift(element)\n    }\n    ancestors[index] = parents\n  })\n\n  ancestors.sort((curr, next) => curr.length - next.length)\n\n  const shallowAncestor = ancestors.shift()\n\n  var ancestor = null\n\n  for (var i = 0, l = shallowAncestor.length; i < l; i++) {\n    const parent = shallowAncestor[i]\n    const missing = ancestors.some((otherParents) => {\n      return !otherParents.some((otherParent) => otherParent === parent)\n    })\n\n    if (missing) {\n      // TODO: find similar sub-parents, not the top root, e.g. sharing a class selector\n      break\n    }\n\n    ancestor = parent\n  }\n\n  return ancestor\n}\n\n/**\n * Get a set of common properties of elements\n *\n * @param  {Array.<HTMLElement>} elements - [description]\n * @return {Object}                       - [description]\n */\nexport function getCommonProperties (elements) {\n\n  const commonProperties = {\n    classes: [],\n    attributes: {},\n    tag: null\n  }\n\n  elements.forEach((element) => {\n\n    var {\n      classes: commonClasses,\n      attributes: commonAttributes,\n      tag: commonTag\n    } = commonProperties\n\n    // ~ classes\n    if (commonClasses !== undefined) {\n      var classes = element.getAttribute('class')\n      if (classes) {\n        classes = classes.trim().split(' ')\n        if (!commonClasses.length) {\n          commonProperties.classes = classes\n        } else {\n          commonClasses = commonClasses.filter((entry) => classes.some((name) => name === entry))\n          if (commonClasses.length) {\n            commonProperties.classes = commonClasses\n          } else {\n            delete commonProperties.classes\n          }\n        }\n      } else {\n        // TODO: restructure removal as 2x set / 2x delete, instead of modify always replacing with new collection\n        delete commonProperties.classes\n      }\n    }\n\n    // ~ attributes\n    if (commonAttributes !== undefined) {\n      const elementAttributes = element.attributes\n      const attributes = Object.keys(elementAttributes).reduce((attributes, key) => {\n        const attribute = elementAttributes[key]\n        const attributeName = attribute.name\n        // NOTE: workaround detection for non-standard phantomjs NamedNodeMap behaviour\n        // (issue: https://github.com/ariya/phantomjs/issues/14634)\n        if (attribute && attributeName !== 'class') {\n          attributes[attributeName] = attribute.value\n        }\n        return attributes\n      }, {})\n\n      const attributesNames = Object.keys(attributes)\n      const commonAttributesNames = Object.keys(commonAttributes)\n\n      if (attributesNames.length) {\n        if (!commonAttributesNames.length) {\n          commonProperties.attributes = attributes\n        } else {\n          commonAttributes = commonAttributesNames.reduce((nextCommonAttributes, name) => {\n            const value = commonAttributes[name]\n            if (value === attributes[name]) {\n              nextCommonAttributes[name] = value\n            }\n            return nextCommonAttributes\n          }, {})\n          if (Object.keys(commonAttributes).length) {\n            commonProperties.attributes = commonAttributes\n          } else {\n            delete commonProperties.attributes\n          }\n        }\n      } else {\n        delete commonProperties.attributes\n      }\n    }\n\n    // ~ tag\n    if (commonTag !== undefined) {\n      const tag = element.tagName.toLowerCase()\n      if (!commonTag) {\n        commonProperties.tag = tag\n      } else if (tag !== commonTag) {\n        delete commonProperties.tag\n      }\n    }\n  })\n\n  return commonProperties\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/common.js","/**\n * # Optimize\n *\n * 1.) Improve efficiency through shorter selectors by removing redundancy\n * 2.) Improve robustness through selector transformation\n */\n\nimport adapt from './adapt'\nimport { convertNodeList } from './utilities'\n\n/**\n * Apply different optimization techniques\n *\n * @param  {string}                          selector - [description]\n * @param  {HTMLElement|Array.<HTMLElement>} element  - [description]\n * @param  {Object}                          options  - [description]\n * @return {string}                                   - [description]\n */\nexport default function optimize (selector, elements, options = {}) {\n\n  // convert single entry and NodeList\n  if (!Array.isArray(elements)) {\n    elements = !elements.length ? [elements] : convertNodeList(elements)\n  }\n\n  if (!elements.length || elements.some((element) => element.nodeType !== 1)) {\n    throw new Error(`Invalid input - to compare HTMLElements its necessary to provide a reference of the selected node(s)! (missing \"elements\")`)\n  }\n\n  const globalModified = adapt(elements[0], options)\n\n  // chunk parts outside of quotes (http://stackoverflow.com/a/25663729)\n  var path = selector.replace(/> /g, '>').split(/\\s+(?=(?:(?:[^\"]*\"){2})*[^\"]*$)/)\n\n  if (path.length < 2) {\n    return optimizePart('', selector, '', elements)\n  }\n\n  const shortened = [path.pop()]\n  while (path.length > 1)  {\n    const current = path.pop()\n    const prePart = path.join(' ')\n    const postPart = shortened.join(' ')\n\n    const pattern = `${prePart} ${postPart}`\n    const matches = document.querySelectorAll(pattern)\n    if (matches.length !== elements.length) {\n      shortened.unshift(optimizePart(prePart, current, postPart, elements))\n    }\n  }\n  shortened.unshift(path[0])\n  path = shortened\n\n  // optimize start + end\n  path[0] = optimizePart('', path[0], path.slice(1).join(' '), elements)\n  path[path.length-1] = optimizePart(path.slice(0, -1).join(' '), path[path.length-1], '', elements)\n\n  if (globalModified) {\n    delete global.document\n  }\n\n  return path.join(' ').replace(/>/g, '> ').trim()\n}\n\n/**\n * Improve a chunk of the selector\n *\n * @param  {string}              prePart  - [description]\n * @param  {string}              current  - [description]\n * @param  {string}              postPart - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @return {string}                       - [description]\n */\nfunction optimizePart (prePart, current, postPart, elements) {\n  if (prePart.length) prePart = `${prePart} `\n  if (postPart.length) postPart = ` ${postPart}`\n\n  // robustness: attribute without value (generalization)\n  if (/\\[*\\]/.test(current)) {\n    const key = current.replace(/=.*$/, ']')\n    var pattern = `${prePart}${key}${postPart}`\n    var matches = document.querySelectorAll(pattern)\n    if (compareResults(matches, elements)) {\n      current = key\n    } else {\n      // robustness: replace specific key-value with base tag (heuristic)\n      const references = document.querySelectorAll(`${prePart}${key}`)\n      for (var i = 0, l = references.length; i < l; i++) {\n        const reference = references[i]\n        if (elements.some((element) => reference.contains(element))) {\n          const description = reference.tagName.toLowerCase()\n          var pattern = `${prePart}${description}${postPart}`\n          var matches = document.querySelectorAll(pattern)\n          if (compareResults(matches, elements)) {\n            current = description\n          }\n          break\n        }\n      }\n    }\n  }\n\n  // robustness: descendant instead child (heuristic)\n  if (/>/.test(current)) {\n    const descendant = current.replace(/>/, '')\n    var pattern = `${prePart}${descendant}${postPart}`\n    var matches = document.querySelectorAll(pattern)\n    if (compareResults(matches, elements)) {\n      current = descendant\n    }\n  }\n\n  // robustness: 'nth-of-type' instead 'nth-child' (heuristic)\n  if (/:nth-child/.test(current)) {\n    // TODO: consider complete coverage of 'nth-of-type' replacement\n    const type = current.replace(/nth-child/g, 'nth-of-type')\n    var pattern = `${prePart}${type}${postPart}`\n    var matches = document.querySelectorAll(pattern)\n    if (compareResults(matches, elements)) {\n      current = type\n    }\n  }\n\n  // efficiency: combinations of classname (partial permutations)\n  if (/\\.\\S+\\.\\S+/.test(current)) {\n    var names = current.trim().split('.').slice(1)\n                                         .map((name) => `.${name}`)\n                                         .sort((curr, next) => curr.length - next.length)\n    while (names.length) {\n      const partial = current.replace(names.shift(), '').trim()\n      var pattern = `${prePart}${partial}${postPart}`.trim()\n      if (!pattern.length || pattern.charAt(0) === '>' || pattern.charAt(pattern.length-1) === '>') {\n        break\n      }\n      var matches = document.querySelectorAll(pattern)\n      if (compareResults(matches, elements)) {\n        current = partial\n      }\n    }\n\n    // robustness: degrade complex classname (heuristic)\n    names = current && current.match(/\\./g)\n    if (names && names.length > 2) {\n      const references = document.querySelectorAll(`${prePart}${current}`)\n      for (var i = 0, l = references.length; i < l; i++) {\n        const reference = references[i]\n        if (elements.some((element) => reference.contains(element) )) {\n          // TODO:\n          // - check using attributes + regard excludes\n          const description = reference.tagName.toLowerCase()\n          var pattern = `${prePart}${description}${postPart}`\n          var matches = document.querySelectorAll(pattern)\n          if (compareResults(matches, elements)) {\n            current = description\n          }\n          break\n        }\n      }\n    }\n  }\n\n  return current\n}\n\n/**\n * Evaluate matches with expected elements\n *\n * @param  {Array.<HTMLElement>} matches  - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @return {Boolean}                      - [description]\n */\nfunction compareResults (matches, elements) {\n  const { length } = matches\n  return length === elements.length && elements.every((element) => {\n    for (var i = 0; i < length; i++) {\n      if (matches[i] === element) {\n        return true\n      }\n    }\n    return false\n  })\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/optimize.js","/**\n * # Adapt\n *\n * Check and extend the environment for universal usage.\n */\n\n/**\n * Modify the context based on the environment\n *\n * @param  {HTMLELement} element - [description]\n * @param  {Object}      options - [description]\n * @return {boolean}             - [description]\n */\nexport default function adapt (element, options) {\n\n  // detect environment setup\n  if (global.document) {\n    return false\n  } else {\n    global.document = options.context || (() => {\n      var root = element\n      while (root.parent) {\n        root = root.parent\n      }\n      return root\n    })()\n  }\n\n  // https://github.com/fb55/domhandler/blob/master/index.js#L75\n  const ElementPrototype = Object.getPrototypeOf(global.document)\n\n  // alternative descriptor to access elements with filtering invalid elements (e.g. textnodes)\n  if (!Object.getOwnPropertyDescriptor(ElementPrototype, 'childTags')) {\n    Object.defineProperty(ElementPrototype, 'childTags', {\n      enumerable: true,\n      get () {\n        return this.children.filter((node) => {\n          // https://github.com/fb55/domelementtype/blob/master/index.js#L12\n          return node.type === 'tag' || node.type === 'script' || node.type === 'style'\n        })\n      }\n    })\n  }\n\n  if (!Object.getOwnPropertyDescriptor(ElementPrototype, 'attributes')) {\n    // https://developer.mozilla.org/en-US/docs/Web/API/Element/attributes\n    // https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap\n    Object.defineProperty(ElementPrototype, 'attributes', {\n      enumerable: true,\n      get () {\n        const { attribs } = this\n        const attributesNames = Object.keys(attribs)\n        const NamedNodeMap = attributesNames.reduce((attributes, attributeName, index) => {\n          attributes[index] = {\n            name: attributeName,\n            value: attribs[attributeName]\n          }\n          return attributes\n        }, { })\n        Object.defineProperty(NamedNodeMap, 'length', {\n          enumerable: false,\n          configurable: false,\n          value: attributesNames.length\n        })\n        return NamedNodeMap\n      }\n    })\n  }\n\n  if (!ElementPrototype.getAttribute) {\n    // https://docs.webplatform.org/wiki/dom/Element/getAttribute\n    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttribute\n    ElementPrototype.getAttribute = function (name) {\n      return this.attribs[name] || null\n    }\n  }\n\n  if (!ElementPrototype.getElementsByTagName) {\n    // https://docs.webplatform.org/wiki/dom/Document/getElementsByTagName\n    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByTagName\n    ElementPrototype.getElementsByTagName = function (tagName) {\n      const HTMLCollection = []\n      traverseDescendants(this.childTags, (descendant) => {\n        if (descendant.name === tagName || tagName === '*') {\n          HTMLCollection.push(descendant)\n        }\n      })\n      return HTMLCollection\n    }\n  }\n\n  if (!ElementPrototype.getElementsByClassName) {\n    // https://docs.webplatform.org/wiki/dom/Document/getElementsByClassName\n    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByClassName\n    ElementPrototype.getElementsByClassName = function (className) {\n      const names = className.trim().replace(/\\s+/g, ' ').split(' ')\n      const HTMLCollection = []\n      traverseDescendants([this], (descendant) => {\n        const descendantClassName = descendant.attribs.class\n        if (descendantClassName && names.every((name) => descendantClassName.indexOf(name) > -1)) {\n          HTMLCollection.push(descendant)\n        }\n      })\n      return HTMLCollection\n    }\n  }\n\n  if (!ElementPrototype.querySelectorAll) {\n    // https://docs.webplatform.org/wiki/css/selectors_api/querySelectorAll\n    // https://developer.mozilla.org/en-US/docs/Web/API/Element/querySelectorAll\n    ElementPrototype.querySelectorAll = function (selectors) {\n      selectors = selectors.replace(/(>)(\\S)/g, '$1 $2').trim() // add space for '>' selector\n\n      // using right to left execution => https://github.com/fb55/css-select#how-does-it-work\n      const instructions = getInstructions(selectors)\n      const discover = instructions.shift()\n\n      const total = instructions.length\n      return discover(this).filter((node) => {\n        var step = 0\n        while (step < total) {\n          node = instructions[step](node, this)\n          if (!node) { // hierarchy doesn't match\n            return false\n          }\n          step += 1\n        }\n        return true\n      })\n    }\n  }\n\n  if (!ElementPrototype.contains) {\n    // https://developer.mozilla.org/en-US/docs/Web/API/Node/contains\n    ElementPrototype.contains = function (element) {\n      var inclusive = false\n      traverseDescendants([this], (descendant, done) => {\n        if (descendant === element) {\n          inclusive = true\n          done()\n        }\n      })\n      return inclusive\n    }\n  }\n\n  return true\n}\n\n/**\n * Retrieve transformation steps\n *\n * @param  {Array.<string>}   selectors - [description]\n * @return {Array.<Function>}           - [description]\n */\nfunction getInstructions (selectors) {\n  return selectors.split(' ').reverse().map((selector, step) => {\n    const discover = step === 0\n    const [type, pseudo] = selector.split(':')\n\n    var validate = null\n    var instruction = null\n\n    switch (true) {\n\n      // child: '>'\n      case />/.test(type):\n        instruction = function checkParent (node) {\n          return (validate) => validate(node.parent) && node.parent\n        }\n        break\n\n      // class: '.'\n      case /^\\./.test(type):\n        const names = type.substr(1).split('.')\n        validate = (node) => {\n          const nodeClassName = node.attribs.class\n          return nodeClassName && names.every((name) => nodeClassName.indexOf(name) > -1)\n        }\n        instruction = function checkClass (node, root) {\n          if (discover) {\n            return node.getElementsByClassName(names.join(' '))\n          }\n          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)\n        }\n        break\n\n      // attribute: '[key=\"value\"]'\n      case /^\\[/.test(type):\n        const [attributeKey, attributeValue] = type.replace(/\\[|\\]|\"/g, '').split('=')\n        validate = (node) => {\n          const hasAttribute = Object.keys(node.attribs).indexOf(attributeKey) > -1\n          if (hasAttribute) { // regard optional attributeValue\n            if (!attributeValue || (node.attribs[attributeKey] === attributeValue)) {\n              return true\n            }\n          }\n          return false\n        }\n        instruction = function checkAttribute (node, root) {\n          if (discover) {\n            const NodeList = []\n            traverseDescendants([node], (descendant) => {\n              if (validate(descendant)) {\n                NodeList.push(descendant)\n              }\n            })\n            return NodeList\n          }\n          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)\n        }\n        break\n\n      // id: '#'\n      case /^#/.test(type):\n        const id = type.substr(1)\n        validate = (node) => {\n          return node.attribs.id === id\n        }\n        instruction = function checkId (node, root) {\n          if (discover) {\n            const NodeList = []\n            traverseDescendants([node], (descendant, done) => {\n              if (validate(descendant)) {\n                NodeList.push(descendant)\n                done()\n              }\n            })\n            return NodeList\n          }\n          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)\n        }\n        break\n\n      // universal: '*'\n      case /\\*/.test(type):\n        validate = (node) => true\n        instruction = function checkUniversal (node, root) {\n          if (discover) {\n            const NodeList = []\n            traverseDescendants([node], (descendant) => NodeList.push(descendant))\n            return NodeList\n          }\n          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)\n        }\n        break\n\n      // tag: '...'\n      default:\n        validate = (node) => {\n          return node.name === type\n        }\n        instruction = function checkTag (node, root) {\n          if (discover) {\n            const NodeList = []\n            traverseDescendants([node], (descendant) => {\n              if (validate(descendant)) {\n                NodeList.push(descendant)\n              }\n            })\n            return NodeList\n          }\n          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)\n        }\n    }\n\n    if (!pseudo) {\n      return instruction\n    }\n\n    const rule = pseudo.match(/-(child|type)\\((\\d+)\\)$/)\n    const kind = rule[1]\n    const index = parseInt(rule[2], 10) - 1\n\n    const validatePseudo = (node) => {\n      if (node) {\n        var compareSet = node.parent.childTags\n        if (kind === 'type') {\n          compareSet = compareSet.filter(validate)\n        }\n        const nodeIndex = compareSet.findIndex((child) => child === node)\n        if (nodeIndex === index) {\n          return true\n        }\n      }\n      return false\n    }\n\n    return function enhanceInstruction (node) {\n      const match = instruction(node)\n      if (discover) {\n        return match.reduce((NodeList, matchedNode) => {\n          if (validatePseudo(matchedNode)) {\n            NodeList.push(matchedNode)\n          }\n          return NodeList\n        }, [])\n      }\n      return validatePseudo(match) && match\n    }\n  })\n}\n\n/**\n * Walking recursive to invoke callbacks\n *\n * @param {Array.<HTMLElement>} nodes   - [description]\n * @param {Function}            handler - [description]\n */\nfunction traverseDescendants (nodes, handler) {\n  nodes.forEach((node) => {\n    var progress = true\n    handler(node, () => progress = false)\n    if (node.childTags && progress) {\n      traverseDescendants(node.childTags, handler)\n    }\n  })\n}\n\n/**\n * Bubble up from bottom to top\n *\n * @param  {HTMLELement} node     - [description]\n * @param  {HTMLELement} root     - [description]\n * @param  {Function}    validate - [description]\n * @return {HTMLELement}          - [description]\n */\nfunction getAncestor (node, root, validate) {\n  while (node.parent) {\n    node = node.parent\n    if (validate(node)) {\n      return node\n    }\n    if (node === root) {\n      break\n    }\n  }\n  return null\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/adapt.js","/**\n * # Select\n *\n * Construct a unique CSS query selector to access the selected DOM element(s).\n * For longevity it applies different matching and optimization strategies.\n */\n\nimport adapt from './adapt'\nimport match from './match'\nimport optimize from './optimize'\nimport { convertNodeList } from './utilities'\nimport { getCommonAncestor, getCommonProperties } from './common'\n\n/**\n * Get a selector for the provided element\n *\n * @param  {HTMLElement} element - [description]\n * @param  {Object}      options - [description]\n * @return {string}              - [description]\n */\nexport function getSingleSelector (element, options = {}) {\n\n  if (element.nodeType === 3) {\n    element = element.parentNode\n  }\n\n  if (element.nodeType !== 1) {\n    throw new Error(`Invalid input - only HTMLElements or representations of them are supported! (not \"${typeof element}\")`)\n  }\n\n  const globalModified = adapt(element, options)\n\n  const selector = match(element, options)\n  const optimized = optimize(selector, element, options)\n\n  // debug\n  // console.log(`\n  //   selector:  ${selector}\n  //   optimized: ${optimized}\n  // `)\n\n  if (globalModified) {\n    delete global.document\n  }\n\n  return optimized\n}\n\n/**\n * Get a selector to match multiple descendants from an ancestor\n *\n * @param  {Array.<HTMLElement>|NodeList} elements - [description]\n * @param  {Object}                       options  - [description]\n * @return {string}                                - [description]\n */\nexport function getMultiSelector (elements, options = {}) {\n\n  if (!Array.isArray(elements)) {\n    elements = convertNodeList(elements)\n  }\n\n  if (elements.some((element) => element.nodeType !== 1)) {\n    throw new Error(`Invalid input - only an Array of HTMLElements or representations of them is supported!`)\n  }\n\n  const globalModified = adapt(elements[0], options)\n\n  const ancestor = getCommonAncestor(elements, options)\n  const ancestorSelector = getSingleSelector(ancestor, options)\n\n  // TODO: consider usage of multiple selectors + parent-child relation + check for part redundancy\n  const commonSelectors = getCommonSelectors(elements)\n  const descendantSelector = commonSelectors[0]\n\n  const selector = optimize(`${ancestorSelector} ${descendantSelector}`, elements, options)\n  const selectorMatches = convertNodeList(document.querySelectorAll(selector))\n\n  if (!elements.every((element) => selectorMatches.some((entry) => entry === element) )) {\n    // TODO: cluster matches to split into similar groups for sub selections\n    return console.warn(`\n      The selected elements can\\'t be efficiently mapped.\n      Its probably best to use multiple single selectors instead!\n    `, elements)\n  }\n\n  if (globalModified) {\n    delete global.document\n  }\n\n  return selector\n}\n\n/**\n * Get selectors to describe a set of elements\n *\n * @param  {Array.<HTMLElements>} elements - [description]\n * @return {string}                        - [description]\n */\nfunction getCommonSelectors (elements) {\n\n  const { classes, attributes, tag } = getCommonProperties(elements)\n\n  const selectorPath = []\n\n  if (tag) {\n    selectorPath.push(tag)\n  }\n\n  if (classes) {\n    const classSelector = classes.map((name) => `.${name}`).join('')\n    selectorPath.push(classSelector)\n  }\n\n  if (attributes) {\n    const attributeSelector = Object.keys(attributes).reduce((parts, name) => {\n      parts.push(`[${name}=\"${attributes[name]}\"]`)\n      return parts\n    }, []).join('')\n    selectorPath.push(attributeSelector)\n  }\n\n  if (selectorPath.length) {\n    // TODO: check for parent-child relation\n  }\n\n  return [\n    selectorPath.join('')\n  ]\n}\n\n/**\n * Choose action depending on the input (multiple/single)\n *\n * NOTE: extended detection is used for special cases like the <select> element with <options>\n *\n * @param  {HTMLElement|NodeList|Array.<HTMLElement>} input   - [description]\n * @param  {Object}                                   options - [description]\n * @return {string}                                           - [description]\n */\nexport default function getQuerySelector (input, options = {}) {\n  if (input.length && !input.name) {\n    return getMultiSelector(input, options)\n  }\n  return getSingleSelector(input, options)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/select.js","/**\n * # Match\n *\n * Retrieve selector for a node.\n */\n\nimport { escapeValue } from './utilities'\n\nconst defaultIgnore = {\n  attribute (attributeName) {\n    return [\n      'style',\n      'data-reactid',\n      'data-react-checksum'\n    ].indexOf(attributeName) > -1\n  }\n}\n\n/**\n * Get the path of the element\n *\n * @param  {HTMLElement} node    - [description]\n * @param  {Object}      options - [description]\n * @return {string}              - [description]\n */\nexport default function match (node, options) {\n\n  const {\n    root = document,\n    skip = null,\n    priority = ['id', 'class', 'href', 'src'],\n    ignore = {}\n  } = options\n\n  const path = []\n  var element = node\n  var length = path.length\n  var ignoreClass = false\n\n  const skipCompare = skip && (Array.isArray(skip) ? skip : [skip]).map((entry) => {\n    if (typeof entry !== 'function') {\n      return (element) => element === entry\n    }\n    return entry\n  })\n\n  const skipChecks = (element) => {\n    return skip && skipCompare.some((compare) => compare(element))\n  }\n\n  Object.keys(ignore).forEach((type) => {\n    if (type === 'class') {\n      ignoreClass = true\n    }\n    var predicate = ignore[type]\n    if (typeof predicate === 'function') return\n    if (typeof predicate === 'number') {\n      predicate = predicate.toString()\n    }\n    if (typeof predicate === 'string') {\n      predicate = new RegExp(escapeValue(predicate).replace(/\\\\/g, '\\\\\\\\'))\n    }\n    if (typeof predicate === 'boolean') {\n      predicate = predicate ? /(?:)/ : /.^/\n    }\n    // check class-/attributename for regex\n    ignore[type] = (name, value) => predicate.test(value)\n  })\n\n  if (ignoreClass) {\n    const ignoreAttribute = ignore.attribute\n    ignore.attribute = (name, value, defaultPredicate) => {\n      return ignore.class(value) || ignoreAttribute && ignoreAttribute(name, value, defaultPredicate)\n    }\n  }\n\n  while (element !== root) {\n    if (skipChecks(element) !== true) {\n      // ~ global\n      if (checkAttributes(priority, element, ignore, path, root)) break\n      if (checkTag(element, ignore, path, root)) break\n\n      // ~ local\n      checkAttributes(priority, element, ignore, path)\n      if (path.length === length) {\n        checkTag(element, ignore, path)\n      }\n\n      // define only one part each iteration\n      if (path.length === length) {\n        checkChilds(priority, element, ignore, path)\n      }\n    }\n\n    element = element.parentNode\n    length = path.length\n  }\n\n  if (element === root) {\n    const pattern = findPattern(priority, element, ignore)\n    path.unshift(pattern)\n  }\n\n  return path.join(' ')\n}\n\n/**\n * Extend path with attribute identifier\n *\n * @param  {Array.<string>} priority - [description]\n * @param  {HTMLElement}    element  - [description]\n * @param  {Object}         ignore   - [description]\n * @param  {Array.<string>} path     - [description]\n * @param  {HTMLElement}    parent   - [description]\n * @return {boolean}                 - [description]\n */\nfunction checkAttributes (priority, element, ignore, path, parent = element.parentNode) {\n  const pattern = findAttributesPattern(priority, element, ignore)\n  if (pattern) {\n    const matches = parent.querySelectorAll(pattern)\n    if (matches.length === 1) {\n      path.unshift(pattern)\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Lookup attribute identifier\n *\n * @param  {Array.<string>} priority - [description]\n * @param  {HTMLElement}    element  - [description]\n * @param  {Object}         ignore   - [description]\n * @return {string?}                 - [description]\n */\nfunction findAttributesPattern (priority, element, ignore) {\n  const attributes = element.attributes\n  const sortedKeys = Object.keys(attributes).sort((curr, next) => {\n    const currPos = priority.indexOf(attributes[curr].name)\n    const nextPos = priority.indexOf(attributes[next].name)\n    if (nextPos === -1) {\n      if (currPos === -1) {\n        return 0\n      }\n      return -1\n    }\n    return currPos - nextPos\n  })\n\n  for (var i = 0, l = sortedKeys.length; i < l; i++) {\n    const key = sortedKeys[i]\n    const attribute = attributes[key]\n    const attributeName = attribute.name\n    const attributeValue = escapeValue(attribute.value)\n\n    const currentIgnore = ignore[attributeName] || ignore.attribute\n    const currentDefaultIgnore = defaultIgnore[attributeName] || defaultIgnore.attribute\n    if (checkIgnore(currentIgnore, attributeName, attributeValue, currentDefaultIgnore)) {\n      continue\n    }\n\n    var pattern = `[${attributeName}=\"${attributeValue}\"]`\n\n    if ((/\\b\\d/).test(attributeValue) === false) {\n      if (attributeName === 'id') {\n        pattern = `#${attributeValue}`\n      }\n\n      if (attributeName === 'class') {\n        const className = attributeValue.trim().replace(/\\s+/g, '.')\n        pattern = `.${className}`\n      }\n    }\n\n    return pattern\n  }\n  return null\n}\n\n/**\n * Extend path with tag identifier\n *\n * @param  {HTMLElement}    element - [description]\n * @param  {Object}         ignore  - [description]\n * @param  {Array.<string>} path    - [description]\n * @param  {HTMLElement}    parent  - [description]\n * @return {boolean}                - [description]\n */\nfunction checkTag (element, ignore, path, parent = element.parentNode) {\n  const pattern = findTagPattern(element, ignore)\n  if (pattern) {\n    const matches = parent.getElementsByTagName(pattern)\n    if (matches.length === 1) {\n      path.unshift(pattern)\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Lookup tag identifier\n *\n * @param  {HTMLElement} element - [description]\n * @param  {Object}      ignore  - [description]\n * @return {boolean}             - [description]\n */\nfunction findTagPattern (element, ignore) {\n  const tagName = element.tagName.toLowerCase()\n  if (checkIgnore(ignore.tag, null, tagName)) {\n    return null\n  }\n  return tagName\n}\n\n/**\n * Extend path with specific child identifier\n *\n * NOTE: 'childTags' is a custom property to use as a view filter for tags using 'adapter.js'\n *\n * @param  {Array.<string>} priority - [description]\n * @param  {HTMLElement}    element  - [description]\n * @param  {Object}         ignore   - [description]\n * @param  {Array.<string>} path     - [description]\n * @return {boolean}                 - [description]\n */\nfunction checkChilds (priority, element, ignore, path) {\n  const parent = element.parentNode\n  const children = parent.childTags || parent.children\n  for (var i = 0, l = children.length; i < l; i++) {\n    const child = children[i]\n    if (child === element) {\n      const childPattern = findPattern(priority, child, ignore)\n      if (!childPattern) {\n        return console.warn(`\n          Element couldn\\'t be matched through strict ignore pattern!\n        `, child, ignore, childPattern)\n      }\n      const pattern = `> ${childPattern}:nth-child(${i+1})`\n      path.unshift(pattern)\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Lookup identifier\n *\n * @param  {Array.<string>} priority - [description]\n * @param  {HTMLElement}    element  - [description]\n * @param  {Object}         ignore   - [description]\n * @return {string}                  - [description]\n */\nfunction findPattern (priority, element, ignore) {\n  var pattern = findAttributesPattern(priority, element, ignore)\n  if (!pattern) {\n    pattern = findTagPattern(element, ignore)\n  }\n  return pattern\n}\n\n/**\n * Validate with custom and default functions\n *\n * @param  {Function} predicate        - [description]\n * @param  {string?}  name             - [description]\n * @param  {string}   value            - [description]\n * @param  {Function} defaultPredicate - [description]\n * @return {boolean}                   - [description]\n */\nfunction checkIgnore (predicate, name, value, defaultPredicate) {\n  if (!value) {\n    return true\n  }\n  const check = predicate || defaultPredicate\n  if (!check) {\n    return false\n  }\n  return check(name, value, defaultPredicate)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/match.js","export select, { getSingleSelector, getMultiSelector } from './select'\nexport optimize from './optimize'\nexport * as common from './common'\n\nexport default from './select'\n\n\n\n// WEBPACK FOOTER //\n// ./src/index.js"],"sourceRoot":""}
|