angular2
Version:
Angular 2 - a web framework for modern web apps
360 lines • 15.7 kB
JavaScript
'use strict';var collection_1 = require('angular2/src/facade/collection');
var lang_1 = require('angular2/src/facade/lang');
var exceptions_1 = require('angular2/src/facade/exceptions');
var _EMPTY_ATTR_VALUE = '';
// TODO: Can't use `const` here as
// in Dart this is not transpiled into `final` yet...
var _SELECTOR_REGEXP = lang_1.RegExpWrapper.create('(\\:not\\()|' +
'([-\\w]+)|' +
'(?:\\.([-\\w]+))|' +
'(?:\\[([-\\w*]+)(?:=([^\\]]*))?\\])|' +
'(\\))|' +
'(\\s*,\\s*)'); // ","
/**
* A css selector contains an element name,
* css classes and attribute/value pairs with the purpose
* of selecting subsets out of them.
*/
var CssSelector = (function () {
function CssSelector() {
this.element = null;
this.classNames = [];
this.attrs = [];
this.notSelectors = [];
}
CssSelector.parse = function (selector) {
var results = [];
var _addResult = function (res, cssSel) {
if (cssSel.notSelectors.length > 0 && lang_1.isBlank(cssSel.element) &&
collection_1.ListWrapper.isEmpty(cssSel.classNames) && collection_1.ListWrapper.isEmpty(cssSel.attrs)) {
cssSel.element = "*";
}
res.push(cssSel);
};
var cssSelector = new CssSelector();
var matcher = lang_1.RegExpWrapper.matcher(_SELECTOR_REGEXP, selector);
var match;
var current = cssSelector;
var inNot = false;
while (lang_1.isPresent(match = lang_1.RegExpMatcherWrapper.next(matcher))) {
if (lang_1.isPresent(match[1])) {
if (inNot) {
throw new exceptions_1.BaseException('Nesting :not is not allowed in a selector');
}
inNot = true;
current = new CssSelector();
cssSelector.notSelectors.push(current);
}
if (lang_1.isPresent(match[2])) {
current.setElement(match[2]);
}
if (lang_1.isPresent(match[3])) {
current.addClassName(match[3]);
}
if (lang_1.isPresent(match[4])) {
current.addAttribute(match[4], match[5]);
}
if (lang_1.isPresent(match[6])) {
inNot = false;
current = cssSelector;
}
if (lang_1.isPresent(match[7])) {
if (inNot) {
throw new exceptions_1.BaseException('Multiple selectors in :not are not supported');
}
_addResult(results, cssSelector);
cssSelector = current = new CssSelector();
}
}
_addResult(results, cssSelector);
return results;
};
CssSelector.prototype.isElementSelector = function () {
return lang_1.isPresent(this.element) && collection_1.ListWrapper.isEmpty(this.classNames) &&
collection_1.ListWrapper.isEmpty(this.attrs) && this.notSelectors.length === 0;
};
CssSelector.prototype.setElement = function (element) {
if (element === void 0) { element = null; }
if (lang_1.isPresent(element)) {
element = element.toLowerCase();
}
this.element = element;
};
/** Gets a template string for an element that matches the selector. */
CssSelector.prototype.getMatchingElementTemplate = function () {
var tagName = lang_1.isPresent(this.element) ? this.element : 'div';
var classAttr = this.classNames.length > 0 ? " class=\"" + this.classNames.join(' ') + "\"" : '';
var attrs = '';
for (var i = 0; i < this.attrs.length; i += 2) {
var attrName = this.attrs[i];
var attrValue = this.attrs[i + 1] !== '' ? "=\"" + this.attrs[i + 1] + "\"" : '';
attrs += " " + attrName + attrValue;
}
return "<" + tagName + classAttr + attrs + "></" + tagName + ">";
};
CssSelector.prototype.addAttribute = function (name, value) {
if (value === void 0) { value = _EMPTY_ATTR_VALUE; }
this.attrs.push(name.toLowerCase());
if (lang_1.isPresent(value)) {
value = value.toLowerCase();
}
else {
value = _EMPTY_ATTR_VALUE;
}
this.attrs.push(value);
};
CssSelector.prototype.addClassName = function (name) { this.classNames.push(name.toLowerCase()); };
CssSelector.prototype.toString = function () {
var res = '';
if (lang_1.isPresent(this.element)) {
res += this.element;
}
if (lang_1.isPresent(this.classNames)) {
for (var i = 0; i < this.classNames.length; i++) {
res += '.' + this.classNames[i];
}
}
if (lang_1.isPresent(this.attrs)) {
for (var i = 0; i < this.attrs.length;) {
var attrName = this.attrs[i++];
var attrValue = this.attrs[i++];
res += '[' + attrName;
if (attrValue.length > 0) {
res += '=' + attrValue;
}
res += ']';
}
}
this.notSelectors.forEach(function (notSelector) { return res += ":not(" + notSelector + ")"; });
return res;
};
return CssSelector;
})();
exports.CssSelector = CssSelector;
/**
* Reads a list of CssSelectors and allows to calculate which ones
* are contained in a given CssSelector.
*/
var SelectorMatcher = (function () {
function SelectorMatcher() {
this._elementMap = new collection_1.Map();
this._elementPartialMap = new collection_1.Map();
this._classMap = new collection_1.Map();
this._classPartialMap = new collection_1.Map();
this._attrValueMap = new collection_1.Map();
this._attrValuePartialMap = new collection_1.Map();
this._listContexts = [];
}
SelectorMatcher.createNotMatcher = function (notSelectors) {
var notMatcher = new SelectorMatcher();
notMatcher.addSelectables(notSelectors, null);
return notMatcher;
};
SelectorMatcher.prototype.addSelectables = function (cssSelectors, callbackCtxt) {
var listContext = null;
if (cssSelectors.length > 1) {
listContext = new SelectorListContext(cssSelectors);
this._listContexts.push(listContext);
}
for (var i = 0; i < cssSelectors.length; i++) {
this._addSelectable(cssSelectors[i], callbackCtxt, listContext);
}
};
/**
* Add an object that can be found later on by calling `match`.
* @param cssSelector A css selector
* @param callbackCtxt An opaque object that will be given to the callback of the `match` function
*/
SelectorMatcher.prototype._addSelectable = function (cssSelector, callbackCtxt, listContext) {
var matcher = this;
var element = cssSelector.element;
var classNames = cssSelector.classNames;
var attrs = cssSelector.attrs;
var selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);
if (lang_1.isPresent(element)) {
var isTerminal = attrs.length === 0 && classNames.length === 0;
if (isTerminal) {
this._addTerminal(matcher._elementMap, element, selectable);
}
else {
matcher = this._addPartial(matcher._elementPartialMap, element);
}
}
if (lang_1.isPresent(classNames)) {
for (var index = 0; index < classNames.length; index++) {
var isTerminal = attrs.length === 0 && index === classNames.length - 1;
var className = classNames[index];
if (isTerminal) {
this._addTerminal(matcher._classMap, className, selectable);
}
else {
matcher = this._addPartial(matcher._classPartialMap, className);
}
}
}
if (lang_1.isPresent(attrs)) {
for (var index = 0; index < attrs.length;) {
var isTerminal = index === attrs.length - 2;
var attrName = attrs[index++];
var attrValue = attrs[index++];
if (isTerminal) {
var terminalMap = matcher._attrValueMap;
var terminalValuesMap = terminalMap.get(attrName);
if (lang_1.isBlank(terminalValuesMap)) {
terminalValuesMap = new collection_1.Map();
terminalMap.set(attrName, terminalValuesMap);
}
this._addTerminal(terminalValuesMap, attrValue, selectable);
}
else {
var parttialMap = matcher._attrValuePartialMap;
var partialValuesMap = parttialMap.get(attrName);
if (lang_1.isBlank(partialValuesMap)) {
partialValuesMap = new collection_1.Map();
parttialMap.set(attrName, partialValuesMap);
}
matcher = this._addPartial(partialValuesMap, attrValue);
}
}
}
};
SelectorMatcher.prototype._addTerminal = function (map, name, selectable) {
var terminalList = map.get(name);
if (lang_1.isBlank(terminalList)) {
terminalList = [];
map.set(name, terminalList);
}
terminalList.push(selectable);
};
SelectorMatcher.prototype._addPartial = function (map, name) {
var matcher = map.get(name);
if (lang_1.isBlank(matcher)) {
matcher = new SelectorMatcher();
map.set(name, matcher);
}
return matcher;
};
/**
* Find the objects that have been added via `addSelectable`
* whose css selector is contained in the given css selector.
* @param cssSelector A css selector
* @param matchedCallback This callback will be called with the object handed into `addSelectable`
* @return boolean true if a match was found
*/
SelectorMatcher.prototype.match = function (cssSelector, matchedCallback) {
var result = false;
var element = cssSelector.element;
var classNames = cssSelector.classNames;
var attrs = cssSelector.attrs;
for (var i = 0; i < this._listContexts.length; i++) {
this._listContexts[i].alreadyMatched = false;
}
result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result;
result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) ||
result;
if (lang_1.isPresent(classNames)) {
for (var index = 0; index < classNames.length; index++) {
var className = classNames[index];
result =
this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;
result =
this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) ||
result;
}
}
if (lang_1.isPresent(attrs)) {
for (var index = 0; index < attrs.length;) {
var attrName = attrs[index++];
var attrValue = attrs[index++];
var terminalValuesMap = this._attrValueMap.get(attrName);
if (!lang_1.StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) {
result = this._matchTerminal(terminalValuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) ||
result;
}
result = this._matchTerminal(terminalValuesMap, attrValue, cssSelector, matchedCallback) ||
result;
var partialValuesMap = this._attrValuePartialMap.get(attrName);
if (!lang_1.StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) {
result = this._matchPartial(partialValuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) ||
result;
}
result =
this._matchPartial(partialValuesMap, attrValue, cssSelector, matchedCallback) || result;
}
}
return result;
};
/** @internal */
SelectorMatcher.prototype._matchTerminal = function (map, name, cssSelector, matchedCallback) {
if (lang_1.isBlank(map) || lang_1.isBlank(name)) {
return false;
}
var selectables = map.get(name);
var starSelectables = map.get("*");
if (lang_1.isPresent(starSelectables)) {
selectables = selectables.concat(starSelectables);
}
if (lang_1.isBlank(selectables)) {
return false;
}
var selectable;
var result = false;
for (var index = 0; index < selectables.length; index++) {
selectable = selectables[index];
result = selectable.finalize(cssSelector, matchedCallback) || result;
}
return result;
};
/** @internal */
SelectorMatcher.prototype._matchPartial = function (map, name, cssSelector, matchedCallback /*: (c: CssSelector, a: any) => void*/) {
if (lang_1.isBlank(map) || lang_1.isBlank(name)) {
return false;
}
var nestedSelector = map.get(name);
if (lang_1.isBlank(nestedSelector)) {
return false;
}
// TODO(perf): get rid of recursion and measure again
// TODO(perf): don't pass the whole selector into the recursion,
// but only the not processed parts
return nestedSelector.match(cssSelector, matchedCallback);
};
return SelectorMatcher;
})();
exports.SelectorMatcher = SelectorMatcher;
var SelectorListContext = (function () {
function SelectorListContext(selectors) {
this.selectors = selectors;
this.alreadyMatched = false;
}
return SelectorListContext;
})();
exports.SelectorListContext = SelectorListContext;
// Store context to pass back selector and context when a selector is matched
var SelectorContext = (function () {
function SelectorContext(selector, cbContext, listContext) {
this.selector = selector;
this.cbContext = cbContext;
this.listContext = listContext;
this.notSelectors = selector.notSelectors;
}
SelectorContext.prototype.finalize = function (cssSelector, callback) {
var result = true;
if (this.notSelectors.length > 0 &&
(lang_1.isBlank(this.listContext) || !this.listContext.alreadyMatched)) {
var notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);
result = !notMatcher.match(cssSelector, null);
}
if (result && lang_1.isPresent(callback) &&
(lang_1.isBlank(this.listContext) || !this.listContext.alreadyMatched)) {
if (lang_1.isPresent(this.listContext)) {
this.listContext.alreadyMatched = true;
}
callback(this.selector, this.cbContext);
}
return result;
};
return SelectorContext;
})();
exports.SelectorContext = SelectorContext;
//# sourceMappingURL=selector.js.map