xmlapi-web
Version:
browser implementation of xmlapi
172 lines (171 loc) • 6.27 kB
JavaScript
"use strict";
const webapi_document_1 = require('./webapi_document');
const webapi_element_1 = require('./webapi_element');
const webapi_attribute_1 = require('./webapi_attribute');
const utils_1 = require('./utils');
const xmlapi_1 = require('xmlapi');
const utils_2 = require('xmlapi/utils');
class WebapiNode extends xmlapi_1.AbstractNode {
constructor(wrapee) {
super();
this.wrapee = wrapee;
} // todo: protected
get native() {
return this.wrapee;
}
get document() {
return utils_2.wrappedOrNull(webapi_document_1.WebapiDocument, this.wrapee.ownerDocument);
}
get parent() {
return utils_2.wrappedOrNull(webapi_element_1.WebapiElement, this.wrapee.parentElement);
}
get previousSibling() {
return utils_1.nodeOrElementOrNull(this.wrapee.previousSibling);
}
get nextSibling() {
return utils_1.nodeOrElementOrNull(this.wrapee.nextSibling);
}
get text() {
return this.wrapee.textContent;
}
set text(val) {
this.wrapee.textContent = val;
}
get type() {
switch (this.wrapee.nodeType) {
case Node.ELEMENT_NODE:
return 'element';
case Node.TEXT_NODE:
return 'text';
case Node.COMMENT_NODE:
return 'comment';
case Node.CDATA_SECTION_NODE:
return 'cdata';
default:
throw new Error('Unexpected Node type: ' + this.wrapee.nodeType);
}
}
equals(other) {
return !utils_2.isOddball(other) && other.wrapee === this.wrapee;
}
remove() {
this.wrapee.parentNode.removeChild(this.wrapee);
return this;
}
replace(replacement) {
this.wrapee.parentNode.replaceChild(replacement.wrapee, this.wrapee);
}
insertBefore(newNode) {
this.wrapee.parentNode.insertBefore(newNode.wrapee, this.wrapee);
}
insertAfter(newNode) {
this.wrapee.parentNode.insertBefore(newNode.wrapee, this.wrapee.nextSibling);
}
getPath() {
throw new Error('Not implemented'); // todo
}
evaluate(xpath, nsMap) {
let result = this.wrapee.ownerDocument.evaluate(xpath, this.wrapee, createNsResolver(nsMap), XPathResult.ANY_TYPE, null);
switch (result.resultType) {
case XPathResult.BOOLEAN_TYPE:
return result.booleanValue;
case XPathResult.NUMBER_TYPE:
return result.numberValue;
case XPathResult.STRING_TYPE:
return result.stringValue;
case XPathResult.FIRST_ORDERED_NODE_TYPE:
return utils_1.nodeOrElementOrNull(result.singleNodeValue);
case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
return wu(utils_1.generateFromXpathResultIterator(result)).map(x => utils_1.nodeOrElementOrAttribute(x));
case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
return wu(utils_1.generateFromXpathResultSnapshot(result)).map(x => utils_1.nodeOrElementOrAttribute(x));
default:
throw new Error('Unexpected XPath result type');
}
}
evaluateNode(xpath, nsMap) {
let wrapee = this.wrapee.ownerDocument.evaluate(xpath, this.wrapee, createNsResolver(nsMap), XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
if (!wrapee) {
return null;
}
if (!utils_1.isNode(wrapee)) {
throw new Error('Non-node XPath result');
}
return utils_1.nodeOrElement(wrapee);
}
evaluateElement(xpath, nsMap) {
let ret = this.evaluateNode(xpath, nsMap);
if (!ret) {
return null;
}
if (!ret.isElement()) {
throw new Error('Non-element XPath result');
}
return ret;
}
evaluateAttribute(xpath, nsMap) {
let wrapee = this.wrapee.ownerDocument.evaluate(xpath, this.wrapee, createNsResolver(nsMap), XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
if (!wrapee) {
return null;
}
if (wrapee.nodeType !== Node.ATTRIBUTE_NODE) {
throw new Error('Non-attribute XPath result');
}
return new webapi_attribute_1.WebapiAttribute(wrapee);
}
evaluateNodes(xpath, nsMap) {
return this._evaluateManyOrdered(xpath, nsMap).map(x => {
if (!utils_1.isNode(x)) {
throw new Error('Xpath result is not a list of attributes');
}
return utils_1.nodeOrElement(x);
});
}
evaluateElements(xpath, nsMap) {
return this._evaluateManyOrdered(xpath, nsMap).map(x => {
if (x.nodeType !== Node.ELEMENT_NODE) {
throw new Error('Xpath result is not a list of elements');
}
return new webapi_element_1.WebapiElement(x);
});
}
evaluateAttributes(xpath, nsMap) {
return this._evaluateManyOrdered(xpath, nsMap).map(x => {
if (x.nodeType !== Node.ATTRIBUTE_NODE) {
throw new Error('Xpath result is not a list of attributes');
}
return new webapi_attribute_1.WebapiAttribute(x);
});
}
serialize() {
throw new Error('Not implemented'); // todo
}
clone() {
return utils_1.nodeOrElement(this.wrapee.cloneNode(true));
}
_evaluateManyOrdered(xpath, nsMap) {
let result = this.wrapee.ownerDocument.evaluate(xpath, this.wrapee, createNsResolver(nsMap), XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
return wu(utils_1.generateFromXpathResultIterator(result));
}
}
exports.WebapiNode = WebapiNode;
//--------------------------------------------------------------------
function createNsResolver(nsMap) {
const defaultNsMap = {
'xml': utils_2.NS_XML,
};
if (nsMap) {
nsMap = Object.assign(defaultNsMap, nsMap);
}
else {
nsMap = defaultNsMap;
}
return {
lookupNamespaceURI(key) {
return nsMap[key];
},
};
}
exports.createNsResolver = createNsResolver;