458 lines
9.3 KiB
Dart
458 lines
9.3 KiB
Dart
library angular2.dom.abstractHtmlAdapter;
|
|
|
|
import 'package:html/parser.dart' as parser;
|
|
import 'package:html/dom.dart';
|
|
|
|
import 'package:angular2/platform/common_dom.dart';
|
|
import 'package:angular2/src/compiler/xhr.dart';
|
|
|
|
import 'package:angular2/src/facade/lang.dart' show isBlank, isPresent;
|
|
import 'package:angular2/src/platform/dom/animation/dom_animate_player.dart' show DomAnimatePlayer;
|
|
|
|
const _attrToPropMap = const {
|
|
'innerHtml': 'innerHTML',
|
|
'readonly': 'readOnly',
|
|
'tabindex': 'tabIndex',
|
|
};
|
|
|
|
abstract class AbstractHtml5LibAdapter implements DomAdapter {
|
|
hasProperty(element, String name) {
|
|
// This is needed for serverside compile to generate the right getters/setters.
|
|
// TODO: change this once we have property schema support.
|
|
// Attention: Keep this in sync with browser_adapter.dart!
|
|
return true;
|
|
}
|
|
|
|
void setProperty(Element element, String name, Object value) =>
|
|
throw 'not implemented';
|
|
|
|
getProperty(Element element, String name) => throw 'not implemented';
|
|
|
|
invoke(Element element, String methodName, List args) =>
|
|
throw 'not implemented';
|
|
|
|
@override
|
|
get attrToPropMap => _attrToPropMap;
|
|
|
|
@override
|
|
set attrToPropMap(value) {
|
|
throw 'readonly';
|
|
}
|
|
|
|
@override
|
|
getGlobalEventTarget(String target) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
@override
|
|
getTitle() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
@override
|
|
setTitle(String newTitle) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
@override
|
|
String getEventKey(event) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
@override
|
|
void replaceChild(el, newNode, oldNode) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
@override
|
|
dynamic getBoundingClientRect(el) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
@override
|
|
Type getXHR() => XHR;
|
|
|
|
Element parse(String templateHtml) => parser.parse(templateHtml).firstChild;
|
|
query(selector) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
querySelector(el, String selector) {
|
|
return el.querySelector(selector);
|
|
}
|
|
|
|
List querySelectorAll(el, String selector) {
|
|
return el.querySelectorAll(selector);
|
|
}
|
|
|
|
on(el, evt, listener) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
Function onAndCancel(el, evt, listener) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
dispatchEvent(el, evt) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
createMouseEvent(eventType) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
createEvent(eventType) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
preventDefault(evt) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
isPrevented(evt) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getInnerHTML(el) {
|
|
return el.innerHtml;
|
|
}
|
|
|
|
getOuterHTML(el) {
|
|
return el.outerHtml;
|
|
}
|
|
|
|
String nodeName(node) {
|
|
switch (node.nodeType) {
|
|
case Node.ELEMENT_NODE:
|
|
return (node as Element).localName;
|
|
case Node.TEXT_NODE:
|
|
return '#text';
|
|
default:
|
|
throw 'not implemented for type ${node.nodeType}. '
|
|
'See http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1950641247'
|
|
' for node types definitions.';
|
|
}
|
|
}
|
|
|
|
String nodeValue(node) => node.data;
|
|
String type(node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
content(node) {
|
|
return node;
|
|
}
|
|
|
|
firstChild(el) => el is NodeList ? el.first : el.firstChild;
|
|
|
|
nextSibling(el) {
|
|
final parentNode = el.parentNode;
|
|
if (parentNode == null) return null;
|
|
final siblings = parentNode.nodes;
|
|
final index = siblings.indexOf(el);
|
|
if (index < siblings.length - 1) {
|
|
return siblings[index + 1];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
parentElement(el) {
|
|
return el.parent;
|
|
}
|
|
|
|
List childNodes(el) => el.nodes;
|
|
List childNodesAsList(el) => el.nodes;
|
|
clearNodes(el) {
|
|
el.nodes.forEach((e) => e.remove());
|
|
}
|
|
|
|
appendChild(el, node) => el.append(node.remove());
|
|
removeChild(el, node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
remove(el) => el.remove();
|
|
insertBefore(el, node) {
|
|
if (el.parent == null) throw '$el must have a parent';
|
|
el.parent.insertBefore(node, el);
|
|
}
|
|
|
|
insertAllBefore(el, nodes) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
insertAfter(el, node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
setInnerHTML(el, value) {
|
|
el.innerHtml = value;
|
|
}
|
|
|
|
getText(el) {
|
|
return el.text;
|
|
}
|
|
|
|
setText(el, String value) => el.text = value;
|
|
|
|
getValue(el) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
setValue(el, String value) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getChecked(el) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
setChecked(el, bool value) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
createComment(String text) => new Comment(text);
|
|
createTemplate(String html) => createElement('template')..innerHtml = html;
|
|
createElement(tagName, [doc]) {
|
|
return new Element.tag(tagName);
|
|
}
|
|
|
|
createElementNS(ns, tagName, [doc]) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
createTextNode(String text, [doc]) => new Text(text);
|
|
|
|
createScriptTag(String attrName, String attrValue, [doc]) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
createStyleElement(String css, [doc]) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
createShadowRoot(el) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getShadowRoot(el) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getHost(el) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
clone(node) => node.clone(true);
|
|
getElementsByClassName(element, String name) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getElementsByTagName(element, String name) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
List classList(element) => element.classes.toList();
|
|
|
|
addClass(element, String className) {
|
|
element.classes.add(className);
|
|
}
|
|
|
|
removeClass(element, String className) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
hasClass(element, String className) => element.classes.contains(className);
|
|
|
|
setStyle(element, String styleName, String styleValue) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
bool hasStyle(Element element, String styleName, [String styleValue]) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
removeStyle(element, String styleName) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getStyle(element, String styleName) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
String tagName(element) => element.localName;
|
|
|
|
attributeMap(element) {
|
|
// `attributes` keys can be {@link AttributeName}s.
|
|
var map = <String, String>{};
|
|
element.attributes.forEach((key, value) {
|
|
map['$key'] = value;
|
|
});
|
|
return map;
|
|
}
|
|
|
|
hasAttribute(element, String attribute) {
|
|
// `attributes` keys can be {@link AttributeName}s.
|
|
return element.attributes.keys.any((key) => '$key' == attribute);
|
|
}
|
|
|
|
hasAttributeNS(element, String ns, String attribute) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getAttribute(element, String attribute) {
|
|
// `attributes` keys can be {@link AttributeName}s.
|
|
var key = element.attributes.keys.firstWhere((key) => '$key' == attribute,
|
|
orElse: () {});
|
|
return element.attributes[key];
|
|
}
|
|
|
|
getAttributeNS(element, String ns, String attribute) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
setAttribute(element, String name, String value) {
|
|
element.attributes[name] = value;
|
|
}
|
|
|
|
setAttributeNS(element, String ns, String name, String value) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
removeAttribute(element, String attribute) {
|
|
element.attributes.remove(attribute);
|
|
}
|
|
|
|
removeAttributeNS(element, String ns, String attribute) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
templateAwareRoot(el) => el;
|
|
|
|
createHtmlDocument() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
defaultDoc() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
bool elementMatches(n, String selector) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
bool isTemplateElement(Element el) {
|
|
return el != null && el.localName.toLowerCase() == 'template';
|
|
}
|
|
|
|
bool isTextNode(node) => node.nodeType == Node.TEXT_NODE;
|
|
bool isCommentNode(node) => node.nodeType == Node.COMMENT_NODE;
|
|
|
|
bool isElementNode(node) => node.nodeType == Node.ELEMENT_NODE;
|
|
|
|
bool hasShadowRoot(node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
bool isShadowRoot(node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
importIntoDoc(node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
adoptNode(node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
String getHref(element) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
void resolveAndSetHref(element, baseUrl, href) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
List getDistributedNodes(Node) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
bool supportsDOMEvents() {
|
|
return false;
|
|
}
|
|
|
|
bool supportsNativeShadowDOM() {
|
|
return false;
|
|
}
|
|
|
|
bool supportsWebAnimation() {
|
|
return false;
|
|
}
|
|
|
|
getHistory() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getLocation() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getBaseHref() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
resetBaseElement() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
String getUserAgent() {
|
|
return 'Angular 2 Dart Transformer';
|
|
}
|
|
|
|
void setData(Element element, String name, String value) {
|
|
this.setAttribute(element, 'data-${name}', value);
|
|
}
|
|
|
|
getComputedStyle(element) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
String getData(Element element, String name) {
|
|
return this.getAttribute(element, 'data-${name}');
|
|
}
|
|
|
|
// TODO(tbosch): move this into a separate environment class once we have it
|
|
setGlobalVar(String name, value) {
|
|
// noop on the server
|
|
}
|
|
|
|
requestAnimationFrame(callback) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
cancelAnimationFrame(id) {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
performanceNow() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getAnimationPrefix() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
getTransitionEnd() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
supportsAnimation() {
|
|
throw 'not implemented';
|
|
}
|
|
|
|
DomAnimatePlayer animate(element, keyframes, options) {
|
|
throw 'not implemented';
|
|
}
|
|
}
|