repackaging: all the file moves
This commit is contained in:
Igor Minar
749
modules/@angular/platform-server/src/parse5_adapter.ts
Normal file
749
modules/@angular/platform-server/src/parse5_adapter.ts
Normal file
@ -0,0 +1,749 @@
|
||||
var parse5 = require('parse5/index');
|
||||
var parser = new parse5.Parser(parse5.TreeAdapters.htmlparser2);
|
||||
var serializer = new parse5.Serializer(parse5.TreeAdapters.htmlparser2);
|
||||
var treeAdapter = parser.treeAdapter;
|
||||
|
||||
import {MapWrapper, ListWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
|
||||
import {DomAdapter, setRootDomAdapter} from 'angular2/platform/common_dom';
|
||||
import {
|
||||
isPresent,
|
||||
isBlank,
|
||||
global,
|
||||
Type,
|
||||
setValueOnPath,
|
||||
DateWrapper
|
||||
} from 'angular2/src/facade/lang';
|
||||
import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
|
||||
import {SelectorMatcher, CssSelector} from 'angular2/src/compiler/selector';
|
||||
import {XHR} from 'angular2/src/compiler/xhr';
|
||||
|
||||
var _attrToPropMap: {[key: string]: string} = {
|
||||
'class': 'className',
|
||||
'innerHtml': 'innerHTML',
|
||||
'readonly': 'readOnly',
|
||||
'tabindex': 'tabIndex',
|
||||
};
|
||||
var defDoc = null;
|
||||
|
||||
var mapProps = ['attribs', 'x-attribsNamespace', 'x-attribsPrefix'];
|
||||
|
||||
function _notImplemented(methodName) {
|
||||
return new BaseException('This method is not implemented in Parse5DomAdapter: ' + methodName);
|
||||
}
|
||||
|
||||
/* tslint:disable:requireParameterType */
|
||||
export class Parse5DomAdapter extends DomAdapter {
|
||||
static makeCurrent() { setRootDomAdapter(new Parse5DomAdapter()); }
|
||||
|
||||
hasProperty(element, name: string): boolean {
|
||||
return _HTMLElementPropertyList.indexOf(name) > -1;
|
||||
}
|
||||
// TODO(tbosch): don't even call this method when we run the tests on server side
|
||||
// by not using the DomRenderer in tests. Keeping this for now to make tests happy...
|
||||
setProperty(el: /*element*/ any, name: string, value: any) {
|
||||
if (name === 'innerHTML') {
|
||||
this.setInnerHTML(el, value);
|
||||
} else if (name === 'className') {
|
||||
el.attribs["class"] = el.className = value;
|
||||
} else {
|
||||
el[name] = value;
|
||||
}
|
||||
}
|
||||
// TODO(tbosch): don't even call this method when we run the tests on server side
|
||||
// by not using the DomRenderer in tests. Keeping this for now to make tests happy...
|
||||
getProperty(el: /*element*/ any, name: string): any { return el[name]; }
|
||||
|
||||
logError(error) { console.error(error); }
|
||||
|
||||
log(error) { console.log(error); }
|
||||
|
||||
logGroup(error) { console.error(error); }
|
||||
|
||||
logGroupEnd() {}
|
||||
|
||||
getXHR(): Type { return XHR; }
|
||||
|
||||
get attrToPropMap() { return _attrToPropMap; }
|
||||
|
||||
query(selector) { throw _notImplemented('query'); }
|
||||
querySelector(el, selector: string): any { return this.querySelectorAll(el, selector)[0]; }
|
||||
querySelectorAll(el, selector: string): any[] {
|
||||
var res = [];
|
||||
var _recursive = (result, node, selector, matcher) => {
|
||||
var cNodes = node.childNodes;
|
||||
if (cNodes && cNodes.length > 0) {
|
||||
for (var i = 0; i < cNodes.length; i++) {
|
||||
var childNode = cNodes[i];
|
||||
if (this.elementMatches(childNode, selector, matcher)) {
|
||||
result.push(childNode);
|
||||
}
|
||||
_recursive(result, childNode, selector, matcher);
|
||||
}
|
||||
}
|
||||
};
|
||||
var matcher = new SelectorMatcher();
|
||||
matcher.addSelectables(CssSelector.parse(selector));
|
||||
_recursive(res, el, selector, matcher);
|
||||
return res;
|
||||
}
|
||||
elementMatches(node, selector: string, matcher = null): boolean {
|
||||
if (this.isElementNode(node) && selector === '*') {
|
||||
return true;
|
||||
}
|
||||
var result = false;
|
||||
if (selector && selector.charAt(0) == "#") {
|
||||
result = this.getAttribute(node, 'id') == selector.substring(1);
|
||||
} else if (selector) {
|
||||
var result = false;
|
||||
if (matcher == null) {
|
||||
matcher = new SelectorMatcher();
|
||||
matcher.addSelectables(CssSelector.parse(selector));
|
||||
}
|
||||
|
||||
var cssSelector = new CssSelector();
|
||||
cssSelector.setElement(this.tagName(node));
|
||||
if (node.attribs) {
|
||||
for (var attrName in node.attribs) {
|
||||
cssSelector.addAttribute(attrName, node.attribs[attrName]);
|
||||
}
|
||||
}
|
||||
var classList = this.classList(node);
|
||||
for (var i = 0; i < classList.length; i++) {
|
||||
cssSelector.addClassName(classList[i]);
|
||||
}
|
||||
|
||||
matcher.match(cssSelector, function(selector, cb) { result = true; });
|
||||
}
|
||||
return result;
|
||||
}
|
||||
on(el, evt, listener) {
|
||||
var listenersMap: {[k: /*any*/ string]: any} = el._eventListenersMap;
|
||||
if (isBlank(listenersMap)) {
|
||||
var listenersMap: {[k: /*any*/ string]: any} = StringMapWrapper.create();
|
||||
el._eventListenersMap = listenersMap;
|
||||
}
|
||||
var listeners = StringMapWrapper.get(listenersMap, evt);
|
||||
if (isBlank(listeners)) {
|
||||
listeners = [];
|
||||
}
|
||||
listeners.push(listener);
|
||||
StringMapWrapper.set(listenersMap, evt, listeners);
|
||||
}
|
||||
onAndCancel(el, evt, listener): Function {
|
||||
this.on(el, evt, listener);
|
||||
return () => {
|
||||
ListWrapper.remove(StringMapWrapper.get<any[]>(el._eventListenersMap, evt), listener);
|
||||
};
|
||||
}
|
||||
dispatchEvent(el, evt) {
|
||||
if (isBlank(evt.target)) {
|
||||
evt.target = el;
|
||||
}
|
||||
if (isPresent(el._eventListenersMap)) {
|
||||
var listeners: any = StringMapWrapper.get(el._eventListenersMap, evt.type);
|
||||
if (isPresent(listeners)) {
|
||||
for (var i = 0; i < listeners.length; i++) {
|
||||
listeners[i](evt);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isPresent(el.parent)) {
|
||||
this.dispatchEvent(el.parent, evt);
|
||||
}
|
||||
if (isPresent(el._window)) {
|
||||
this.dispatchEvent(el._window, evt);
|
||||
}
|
||||
}
|
||||
createMouseEvent(eventType): Event { return this.createEvent(eventType); }
|
||||
createEvent(eventType: string): Event {
|
||||
var evt = <Event>{
|
||||
type: eventType,
|
||||
defaultPrevented: false,
|
||||
preventDefault: () => { (<any>evt).defaultPrevented = true; }
|
||||
};
|
||||
return evt;
|
||||
}
|
||||
preventDefault(evt) { evt.returnValue = false; }
|
||||
isPrevented(evt): boolean { return isPresent(evt.returnValue) && !evt.returnValue; }
|
||||
getInnerHTML(el): string { return serializer.serialize(this.templateAwareRoot(el)); }
|
||||
getOuterHTML(el): string {
|
||||
serializer.html = '';
|
||||
serializer._serializeElement(el);
|
||||
return serializer.html;
|
||||
}
|
||||
nodeName(node): string { return node.tagName; }
|
||||
nodeValue(node): string { return node.nodeValue; }
|
||||
type(node: any): string { throw _notImplemented('type'); }
|
||||
content(node): string { return node.childNodes[0]; }
|
||||
firstChild(el): Node { return el.firstChild; }
|
||||
nextSibling(el): Node { return el.nextSibling; }
|
||||
parentElement(el): Node { return el.parent; }
|
||||
childNodes(el): Node[] { return el.childNodes; }
|
||||
childNodesAsList(el): any[] {
|
||||
var childNodes = el.childNodes;
|
||||
var res = ListWrapper.createFixedSize(childNodes.length);
|
||||
for (var i = 0; i < childNodes.length; i++) {
|
||||
res[i] = childNodes[i];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
clearNodes(el) {
|
||||
while (el.childNodes.length > 0) {
|
||||
this.remove(el.childNodes[0]);
|
||||
}
|
||||
}
|
||||
appendChild(el, node) {
|
||||
this.remove(node);
|
||||
treeAdapter.appendChild(this.templateAwareRoot(el), node);
|
||||
}
|
||||
removeChild(el, node) {
|
||||
if (ListWrapper.contains(el.childNodes, node)) {
|
||||
this.remove(node);
|
||||
}
|
||||
}
|
||||
remove(el): HTMLElement {
|
||||
var parent = el.parent;
|
||||
if (parent) {
|
||||
var index = parent.childNodes.indexOf(el);
|
||||
parent.childNodes.splice(index, 1);
|
||||
}
|
||||
var prev = el.previousSibling;
|
||||
var next = el.nextSibling;
|
||||
if (prev) {
|
||||
prev.next = next;
|
||||
}
|
||||
if (next) {
|
||||
next.prev = prev;
|
||||
}
|
||||
el.prev = null;
|
||||
el.next = null;
|
||||
el.parent = null;
|
||||
return el;
|
||||
}
|
||||
insertBefore(el, node) {
|
||||
this.remove(node);
|
||||
treeAdapter.insertBefore(el.parent, node, el);
|
||||
}
|
||||
insertAllBefore(el, nodes) { nodes.forEach(n => this.insertBefore(el, n)); }
|
||||
insertAfter(el, node) {
|
||||
if (el.nextSibling) {
|
||||
this.insertBefore(el.nextSibling, node);
|
||||
} else {
|
||||
this.appendChild(el.parent, node);
|
||||
}
|
||||
}
|
||||
setInnerHTML(el, value) {
|
||||
this.clearNodes(el);
|
||||
var content = parser.parseFragment(value);
|
||||
for (var i = 0; i < content.childNodes.length; i++) {
|
||||
treeAdapter.appendChild(el, content.childNodes[i]);
|
||||
}
|
||||
}
|
||||
getText(el, isRecursive?: boolean): string {
|
||||
if (this.isTextNode(el)) {
|
||||
return el.data;
|
||||
} else if (this.isCommentNode(el)) {
|
||||
// In the DOM, comments within an element return an empty string for textContent
|
||||
// However, comment node instances return the comment content for textContent getter
|
||||
return isRecursive ? '' : el.data;
|
||||
} else if (isBlank(el.childNodes) || el.childNodes.length == 0) {
|
||||
return "";
|
||||
} else {
|
||||
var textContent = "";
|
||||
for (var i = 0; i < el.childNodes.length; i++) {
|
||||
textContent += this.getText(el.childNodes[i], true);
|
||||
}
|
||||
return textContent;
|
||||
}
|
||||
}
|
||||
setText(el, value: string) {
|
||||
if (this.isTextNode(el) || this.isCommentNode(el)) {
|
||||
el.data = value;
|
||||
} else {
|
||||
this.clearNodes(el);
|
||||
if (value !== '') treeAdapter.insertText(el, value);
|
||||
}
|
||||
}
|
||||
getValue(el): string { return el.value; }
|
||||
setValue(el, value: string) { el.value = value; }
|
||||
getChecked(el): boolean { return el.checked; }
|
||||
setChecked(el, value: boolean) { el.checked = value; }
|
||||
createComment(text: string): Comment { return treeAdapter.createCommentNode(text); }
|
||||
createTemplate(html): HTMLElement {
|
||||
var template = treeAdapter.createElement("template", 'http://www.w3.org/1999/xhtml', []);
|
||||
var content = parser.parseFragment(html);
|
||||
treeAdapter.appendChild(template, content);
|
||||
return template;
|
||||
}
|
||||
createElement(tagName): HTMLElement {
|
||||
return treeAdapter.createElement(tagName, 'http://www.w3.org/1999/xhtml', []);
|
||||
}
|
||||
createElementNS(ns, tagName): HTMLElement { return treeAdapter.createElement(tagName, ns, []); }
|
||||
createTextNode(text: string): Text {
|
||||
var t = <any>this.createComment(text);
|
||||
t.type = 'text';
|
||||
return t;
|
||||
}
|
||||
createScriptTag(attrName: string, attrValue: string): HTMLElement {
|
||||
return treeAdapter.createElement("script", 'http://www.w3.org/1999/xhtml',
|
||||
[{name: attrName, value: attrValue}]);
|
||||
}
|
||||
createStyleElement(css: string): HTMLStyleElement {
|
||||
var style = this.createElement('style');
|
||||
this.setText(style, css);
|
||||
return <HTMLStyleElement>style;
|
||||
}
|
||||
createShadowRoot(el): HTMLElement {
|
||||
el.shadowRoot = treeAdapter.createDocumentFragment();
|
||||
el.shadowRoot.parent = el;
|
||||
return el.shadowRoot;
|
||||
}
|
||||
getShadowRoot(el): Element { return el.shadowRoot; }
|
||||
getHost(el): string { return el.host; }
|
||||
getDistributedNodes(el: any): Node[] { throw _notImplemented('getDistributedNodes'); }
|
||||
clone(node: Node): Node {
|
||||
var _recursive = (node) => {
|
||||
var nodeClone = Object.create(Object.getPrototypeOf(node));
|
||||
for (var prop in node) {
|
||||
var desc = Object.getOwnPropertyDescriptor(node, prop);
|
||||
if (desc && 'value' in desc && typeof desc.value !== 'object') {
|
||||
nodeClone[prop] = node[prop];
|
||||
}
|
||||
}
|
||||
nodeClone.parent = null;
|
||||
nodeClone.prev = null;
|
||||
nodeClone.next = null;
|
||||
nodeClone.children = null;
|
||||
|
||||
mapProps.forEach(mapName => {
|
||||
if (isPresent(node[mapName])) {
|
||||
nodeClone[mapName] = {};
|
||||
for (var prop in node[mapName]) {
|
||||
nodeClone[mapName][prop] = node[mapName][prop];
|
||||
}
|
||||
}
|
||||
});
|
||||
var cNodes = node.children;
|
||||
if (cNodes) {
|
||||
var cNodesClone = new Array(cNodes.length);
|
||||
for (var i = 0; i < cNodes.length; i++) {
|
||||
var childNode = cNodes[i];
|
||||
var childNodeClone = _recursive(childNode);
|
||||
cNodesClone[i] = childNodeClone;
|
||||
if (i > 0) {
|
||||
childNodeClone.prev = cNodesClone[i - 1];
|
||||
cNodesClone[i - 1].next = childNodeClone;
|
||||
}
|
||||
childNodeClone.parent = nodeClone;
|
||||
}
|
||||
nodeClone.children = cNodesClone;
|
||||
}
|
||||
return nodeClone;
|
||||
};
|
||||
return _recursive(node);
|
||||
}
|
||||
getElementsByClassName(element, name: string): HTMLElement[] {
|
||||
return this.querySelectorAll(element, "." + name);
|
||||
}
|
||||
getElementsByTagName(element: any, name: string): HTMLElement[] {
|
||||
throw _notImplemented('getElementsByTagName');
|
||||
}
|
||||
classList(element): string[] {
|
||||
var classAttrValue = null;
|
||||
var attributes = element.attribs;
|
||||
if (attributes && attributes.hasOwnProperty("class")) {
|
||||
classAttrValue = attributes["class"];
|
||||
}
|
||||
return classAttrValue ? classAttrValue.trim().split(/\s+/g) : [];
|
||||
}
|
||||
addClass(element, className: string) {
|
||||
var classList = this.classList(element);
|
||||
var index = classList.indexOf(className);
|
||||
if (index == -1) {
|
||||
classList.push(className);
|
||||
element.attribs["class"] = element.className = classList.join(" ");
|
||||
}
|
||||
}
|
||||
removeClass(element, className: string) {
|
||||
var classList = this.classList(element);
|
||||
var index = classList.indexOf(className);
|
||||
if (index > -1) {
|
||||
classList.splice(index, 1);
|
||||
element.attribs["class"] = element.className = classList.join(" ");
|
||||
}
|
||||
}
|
||||
hasClass(element, className: string): boolean {
|
||||
return ListWrapper.contains(this.classList(element), className);
|
||||
}
|
||||
hasStyle(element, styleName: string, styleValue: string = null): boolean {
|
||||
var value = this.getStyle(element, styleName) || '';
|
||||
return styleValue ? value == styleValue : value.length > 0;
|
||||
}
|
||||
/** @internal */
|
||||
_readStyleAttribute(element) {
|
||||
var styleMap = {};
|
||||
var attributes = element.attribs;
|
||||
if (attributes && attributes.hasOwnProperty("style")) {
|
||||
var styleAttrValue = attributes["style"];
|
||||
var styleList = styleAttrValue.split(/;+/g);
|
||||
for (var i = 0; i < styleList.length; i++) {
|
||||
if (styleList[i].length > 0) {
|
||||
var elems = styleList[i].split(/:+/g);
|
||||
styleMap[elems[0].trim()] = elems[1].trim();
|
||||
}
|
||||
}
|
||||
}
|
||||
return styleMap;
|
||||
}
|
||||
/** @internal */
|
||||
_writeStyleAttribute(element, styleMap) {
|
||||
var styleAttrValue = "";
|
||||
for (var key in styleMap) {
|
||||
var newValue = styleMap[key];
|
||||
if (newValue && newValue.length > 0) {
|
||||
styleAttrValue += key + ":" + styleMap[key] + ";";
|
||||
}
|
||||
}
|
||||
element.attribs["style"] = styleAttrValue;
|
||||
}
|
||||
setStyle(element, styleName: string, styleValue: string) {
|
||||
var styleMap = this._readStyleAttribute(element);
|
||||
styleMap[styleName] = styleValue;
|
||||
this._writeStyleAttribute(element, styleMap);
|
||||
}
|
||||
removeStyle(element, styleName: string) { this.setStyle(element, styleName, null); }
|
||||
getStyle(element, styleName: string): string {
|
||||
var styleMap = this._readStyleAttribute(element);
|
||||
return styleMap.hasOwnProperty(styleName) ? styleMap[styleName] : "";
|
||||
}
|
||||
tagName(element): string { return element.tagName == "style" ? "STYLE" : element.tagName; }
|
||||
attributeMap(element): Map<string, string> {
|
||||
var res = new Map<string, string>();
|
||||
var elAttrs = treeAdapter.getAttrList(element);
|
||||
for (var i = 0; i < elAttrs.length; i++) {
|
||||
var attrib = elAttrs[i];
|
||||
res.set(attrib.name, attrib.value);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
hasAttribute(element, attribute: string): boolean {
|
||||
return element.attribs && element.attribs.hasOwnProperty(attribute);
|
||||
}
|
||||
hasAttributeNS(element, ns: string, attribute: string): boolean { throw 'not implemented'; }
|
||||
getAttribute(element, attribute: string): string {
|
||||
return element.attribs && element.attribs.hasOwnProperty(attribute) ?
|
||||
element.attribs[attribute] :
|
||||
null;
|
||||
}
|
||||
getAttributeNS(element, ns: string, attribute: string): string { throw 'not implemented'; }
|
||||
setAttribute(element, attribute: string, value: string) {
|
||||
if (attribute) {
|
||||
element.attribs[attribute] = value;
|
||||
if (attribute === 'class') {
|
||||
element.className = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
setAttributeNS(element, ns: string, attribute: string, value: string) { throw 'not implemented'; }
|
||||
removeAttribute(element, attribute: string) {
|
||||
if (attribute) {
|
||||
StringMapWrapper.delete(element.attribs, attribute);
|
||||
}
|
||||
}
|
||||
removeAttributeNS(element, ns: string, name: string) { throw 'not implemented'; }
|
||||
templateAwareRoot(el): any { return this.isTemplateElement(el) ? this.content(el) : el; }
|
||||
createHtmlDocument(): Document {
|
||||
var newDoc = treeAdapter.createDocument();
|
||||
newDoc.title = "fake title";
|
||||
var head = treeAdapter.createElement("head", null, []);
|
||||
var body = treeAdapter.createElement("body", 'http://www.w3.org/1999/xhtml', []);
|
||||
this.appendChild(newDoc, head);
|
||||
this.appendChild(newDoc, body);
|
||||
StringMapWrapper.set(newDoc, "head", head);
|
||||
StringMapWrapper.set(newDoc, "body", body);
|
||||
StringMapWrapper.set(newDoc, "_window", StringMapWrapper.create());
|
||||
return newDoc;
|
||||
}
|
||||
defaultDoc(): Document {
|
||||
if (defDoc === null) {
|
||||
defDoc = this.createHtmlDocument();
|
||||
}
|
||||
return defDoc;
|
||||
}
|
||||
getBoundingClientRect(el): any { return {left: 0, top: 0, width: 0, height: 0}; }
|
||||
getTitle(): string { return this.defaultDoc().title || ""; }
|
||||
setTitle(newTitle: string) { this.defaultDoc().title = newTitle; }
|
||||
isTemplateElement(el: any): boolean {
|
||||
return this.isElementNode(el) && this.tagName(el) === "template";
|
||||
}
|
||||
isTextNode(node): boolean { return treeAdapter.isTextNode(node); }
|
||||
isCommentNode(node): boolean { return treeAdapter.isCommentNode(node); }
|
||||
isElementNode(node): boolean { return node ? treeAdapter.isElementNode(node) : false; }
|
||||
hasShadowRoot(node): boolean { return isPresent(node.shadowRoot); }
|
||||
isShadowRoot(node): boolean { return this.getShadowRoot(node) == node; }
|
||||
importIntoDoc(node): any { return this.clone(node); }
|
||||
adoptNode(node): any { return node; }
|
||||
getHref(el): string { return el.href; }
|
||||
resolveAndSetHref(el, baseUrl: string, href: string) {
|
||||
if (href == null) {
|
||||
el.href = baseUrl;
|
||||
} else {
|
||||
el.href = baseUrl + '/../' + href;
|
||||
}
|
||||
}
|
||||
/** @internal */
|
||||
_buildRules(parsedRules, css?) {
|
||||
var rules = [];
|
||||
for (var i = 0; i < parsedRules.length; i++) {
|
||||
var parsedRule = parsedRules[i];
|
||||
var rule: {[key: string]: any} = StringMapWrapper.create();
|
||||
StringMapWrapper.set(rule, "cssText", css);
|
||||
StringMapWrapper.set(rule, "style", {content: "", cssText: ""});
|
||||
if (parsedRule.type == "rule") {
|
||||
StringMapWrapper.set(rule, "type", 1);
|
||||
StringMapWrapper.set(rule, "selectorText", parsedRule.selectors.join(", ")
|
||||
.replace(/\s{2,}/g, " ")
|
||||
.replace(/\s*~\s*/g, " ~ ")
|
||||
.replace(/\s*\+\s*/g, " + ")
|
||||
.replace(/\s*>\s*/g, " > ")
|
||||
.replace(/\[(\w+)=(\w+)\]/g, '[$1="$2"]'));
|
||||
if (isBlank(parsedRule.declarations)) {
|
||||
continue;
|
||||
}
|
||||
for (var j = 0; j < parsedRule.declarations.length; j++) {
|
||||
var declaration = parsedRule.declarations[j];
|
||||
StringMapWrapper.set(StringMapWrapper.get(rule, "style"), declaration.property,
|
||||
declaration.value);
|
||||
StringMapWrapper.get(rule, "style").cssText +=
|
||||
declaration.property + ": " + declaration.value + ";";
|
||||
}
|
||||
} else if (parsedRule.type == "media") {
|
||||
StringMapWrapper.set(rule, "type", 4);
|
||||
StringMapWrapper.set(rule, "media", {mediaText: parsedRule.media});
|
||||
if (parsedRule.rules) {
|
||||
StringMapWrapper.set(rule, "cssRules", this._buildRules(parsedRule.rules));
|
||||
}
|
||||
}
|
||||
rules.push(rule);
|
||||
}
|
||||
return rules;
|
||||
}
|
||||
supportsDOMEvents(): boolean { return false; }
|
||||
supportsNativeShadowDOM(): boolean { return false; }
|
||||
getGlobalEventTarget(target: string): any {
|
||||
if (target == "window") {
|
||||
return (<any>this.defaultDoc())._window;
|
||||
} else if (target == "document") {
|
||||
return this.defaultDoc();
|
||||
} else if (target == "body") {
|
||||
return this.defaultDoc().body;
|
||||
}
|
||||
}
|
||||
getBaseHref(): string { throw 'not implemented'; }
|
||||
resetBaseElement(): void { throw 'not implemented'; }
|
||||
getHistory(): History { throw 'not implemented'; }
|
||||
getLocation(): Location { throw 'not implemented'; }
|
||||
getUserAgent(): string { return "Fake user agent"; }
|
||||
getData(el, name: string): string { return this.getAttribute(el, 'data-' + name); }
|
||||
getComputedStyle(el): any { throw 'not implemented'; }
|
||||
setData(el, name: string, value: string) { this.setAttribute(el, 'data-' + name, value); }
|
||||
// TODO(tbosch): move this into a separate environment class once we have it
|
||||
setGlobalVar(path: string, value: any) { setValueOnPath(global, path, value); }
|
||||
requestAnimationFrame(callback): number { return setTimeout(callback, 0); }
|
||||
cancelAnimationFrame(id: number) { clearTimeout(id); }
|
||||
performanceNow(): number { return DateWrapper.toMillis(DateWrapper.now()); }
|
||||
getAnimationPrefix(): string { return ''; }
|
||||
getTransitionEnd(): string { return 'transitionend'; }
|
||||
supportsAnimation(): boolean { return true; }
|
||||
|
||||
replaceChild(el, newNode, oldNode) { throw new Error('not implemented'); }
|
||||
parse(templateHtml: string) { throw new Error('not implemented'); }
|
||||
invoke(el: Element, methodName: string, args: any[]): any { throw new Error('not implemented'); }
|
||||
getEventKey(event): string { throw new Error('not implemented'); }
|
||||
}
|
||||
|
||||
// TODO: build a proper list, this one is all the keys of a HTMLInputElement
|
||||
var _HTMLElementPropertyList = [
|
||||
"webkitEntries",
|
||||
"incremental",
|
||||
"webkitdirectory",
|
||||
"selectionDirection",
|
||||
"selectionEnd",
|
||||
"selectionStart",
|
||||
"labels",
|
||||
"validationMessage",
|
||||
"validity",
|
||||
"willValidate",
|
||||
"width",
|
||||
"valueAsNumber",
|
||||
"valueAsDate",
|
||||
"value",
|
||||
"useMap",
|
||||
"defaultValue",
|
||||
"type",
|
||||
"step",
|
||||
"src",
|
||||
"size",
|
||||
"required",
|
||||
"readOnly",
|
||||
"placeholder",
|
||||
"pattern",
|
||||
"name",
|
||||
"multiple",
|
||||
"min",
|
||||
"minLength",
|
||||
"maxLength",
|
||||
"max",
|
||||
"list",
|
||||
"indeterminate",
|
||||
"height",
|
||||
"formTarget",
|
||||
"formNoValidate",
|
||||
"formMethod",
|
||||
"formEnctype",
|
||||
"formAction",
|
||||
"files",
|
||||
"form",
|
||||
"disabled",
|
||||
"dirName",
|
||||
"checked",
|
||||
"defaultChecked",
|
||||
"autofocus",
|
||||
"autocomplete",
|
||||
"alt",
|
||||
"align",
|
||||
"accept",
|
||||
"onautocompleteerror",
|
||||
"onautocomplete",
|
||||
"onwaiting",
|
||||
"onvolumechange",
|
||||
"ontoggle",
|
||||
"ontimeupdate",
|
||||
"onsuspend",
|
||||
"onsubmit",
|
||||
"onstalled",
|
||||
"onshow",
|
||||
"onselect",
|
||||
"onseeking",
|
||||
"onseeked",
|
||||
"onscroll",
|
||||
"onresize",
|
||||
"onreset",
|
||||
"onratechange",
|
||||
"onprogress",
|
||||
"onplaying",
|
||||
"onplay",
|
||||
"onpause",
|
||||
"onmousewheel",
|
||||
"onmouseup",
|
||||
"onmouseover",
|
||||
"onmouseout",
|
||||
"onmousemove",
|
||||
"onmouseleave",
|
||||
"onmouseenter",
|
||||
"onmousedown",
|
||||
"onloadstart",
|
||||
"onloadedmetadata",
|
||||
"onloadeddata",
|
||||
"onload",
|
||||
"onkeyup",
|
||||
"onkeypress",
|
||||
"onkeydown",
|
||||
"oninvalid",
|
||||
"oninput",
|
||||
"onfocus",
|
||||
"onerror",
|
||||
"onended",
|
||||
"onemptied",
|
||||
"ondurationchange",
|
||||
"ondrop",
|
||||
"ondragstart",
|
||||
"ondragover",
|
||||
"ondragleave",
|
||||
"ondragenter",
|
||||
"ondragend",
|
||||
"ondrag",
|
||||
"ondblclick",
|
||||
"oncuechange",
|
||||
"oncontextmenu",
|
||||
"onclose",
|
||||
"onclick",
|
||||
"onchange",
|
||||
"oncanplaythrough",
|
||||
"oncanplay",
|
||||
"oncancel",
|
||||
"onblur",
|
||||
"onabort",
|
||||
"spellcheck",
|
||||
"isContentEditable",
|
||||
"contentEditable",
|
||||
"outerText",
|
||||
"innerText",
|
||||
"accessKey",
|
||||
"hidden",
|
||||
"webkitdropzone",
|
||||
"draggable",
|
||||
"tabIndex",
|
||||
"dir",
|
||||
"translate",
|
||||
"lang",
|
||||
"title",
|
||||
"childElementCount",
|
||||
"lastElementChild",
|
||||
"firstElementChild",
|
||||
"children",
|
||||
"onwebkitfullscreenerror",
|
||||
"onwebkitfullscreenchange",
|
||||
"nextElementSibling",
|
||||
"previousElementSibling",
|
||||
"onwheel",
|
||||
"onselectstart",
|
||||
"onsearch",
|
||||
"onpaste",
|
||||
"oncut",
|
||||
"oncopy",
|
||||
"onbeforepaste",
|
||||
"onbeforecut",
|
||||
"onbeforecopy",
|
||||
"shadowRoot",
|
||||
"dataset",
|
||||
"classList",
|
||||
"className",
|
||||
"outerHTML",
|
||||
"innerHTML",
|
||||
"scrollHeight",
|
||||
"scrollWidth",
|
||||
"scrollTop",
|
||||
"scrollLeft",
|
||||
"clientHeight",
|
||||
"clientWidth",
|
||||
"clientTop",
|
||||
"clientLeft",
|
||||
"offsetParent",
|
||||
"offsetHeight",
|
||||
"offsetWidth",
|
||||
"offsetTop",
|
||||
"offsetLeft",
|
||||
"localName",
|
||||
"prefix",
|
||||
"namespaceURI",
|
||||
"id",
|
||||
"style",
|
||||
"attributes",
|
||||
"tagName",
|
||||
"parentElement",
|
||||
"textContent",
|
||||
"baseURI",
|
||||
"ownerDocument",
|
||||
"nextSibling",
|
||||
"previousSibling",
|
||||
"lastChild",
|
||||
"firstChild",
|
||||
"childNodes",
|
||||
"parentNode",
|
||||
"nodeType",
|
||||
"nodeValue",
|
||||
"nodeName",
|
||||
"closure_lm_714617",
|
||||
"__jsaction"
|
||||
];
|
||||
Reference in New Issue
Block a user