218 lines
7.6 KiB
JavaScript
218 lines
7.6 KiB
JavaScript
import { DOCUMENT_MODE } from '../common/html.js';
|
|
/** The position of each name in the attribute lists `adoptAttributes` merged into, kept for the next merge into that list. */
|
|
const attrListIndexes = new WeakMap();
|
|
export const defaultTreeAdapter = {
|
|
//Node construction
|
|
createDocument() {
|
|
return {
|
|
nodeName: '#document',
|
|
mode: DOCUMENT_MODE.NO_QUIRKS,
|
|
childNodes: [],
|
|
};
|
|
},
|
|
createDocumentFragment() {
|
|
return {
|
|
nodeName: '#document-fragment',
|
|
childNodes: [],
|
|
};
|
|
},
|
|
createElement(tagName, namespaceURI, attrs) {
|
|
return {
|
|
nodeName: tagName,
|
|
tagName,
|
|
attrs,
|
|
namespaceURI,
|
|
childNodes: [],
|
|
parentNode: null,
|
|
};
|
|
},
|
|
createCommentNode(data) {
|
|
return {
|
|
nodeName: '#comment',
|
|
data,
|
|
parentNode: null,
|
|
};
|
|
},
|
|
createTextNode(value) {
|
|
return {
|
|
nodeName: '#text',
|
|
value,
|
|
parentNode: null,
|
|
};
|
|
},
|
|
//Tree mutation
|
|
appendChild(parentNode, newNode) {
|
|
parentNode.childNodes.push(newNode);
|
|
newNode.parentNode = parentNode;
|
|
},
|
|
insertBefore(parentNode, newNode, referenceNode) {
|
|
const { childNodes } = parentNode;
|
|
// The reference is usually the last child (fostered content precedes the table), so check that first.
|
|
const insertionIdx = childNodes[childNodes.length - 1] === referenceNode
|
|
? childNodes.length - 1
|
|
: childNodes.indexOf(referenceNode);
|
|
childNodes.splice(insertionIdx, 0, newNode);
|
|
newNode.parentNode = parentNode;
|
|
},
|
|
setTemplateContent(templateElement, contentElement) {
|
|
templateElement.content = contentElement;
|
|
},
|
|
getTemplateContent(templateElement) {
|
|
return templateElement.content;
|
|
},
|
|
setDocumentType(document, name, publicId, systemId) {
|
|
const doctypeNode = document.childNodes.find((node) => node.nodeName === '#documentType');
|
|
if (doctypeNode) {
|
|
doctypeNode.name = name;
|
|
doctypeNode.publicId = publicId;
|
|
doctypeNode.systemId = systemId;
|
|
}
|
|
else {
|
|
const node = {
|
|
nodeName: '#documentType',
|
|
name,
|
|
publicId,
|
|
systemId,
|
|
parentNode: null,
|
|
};
|
|
defaultTreeAdapter.appendChild(document, node);
|
|
}
|
|
},
|
|
setDocumentMode(document, mode) {
|
|
document.mode = mode;
|
|
},
|
|
getDocumentMode(document) {
|
|
return document.mode;
|
|
},
|
|
detachNode(node) {
|
|
if (node.parentNode) {
|
|
const { childNodes } = node.parentNode;
|
|
// The parser detaches from the end when it moves children, so check the last child first.
|
|
const idx = childNodes[childNodes.length - 1] === node ? childNodes.length - 1 : childNodes.indexOf(node);
|
|
childNodes.splice(idx, 1);
|
|
node.parentNode = null;
|
|
}
|
|
},
|
|
insertText(parentNode, text) {
|
|
if (parentNode.childNodes.length > 0) {
|
|
const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];
|
|
if (defaultTreeAdapter.isTextNode(prevNode)) {
|
|
prevNode.value += text;
|
|
return;
|
|
}
|
|
}
|
|
defaultTreeAdapter.appendChild(parentNode, defaultTreeAdapter.createTextNode(text));
|
|
},
|
|
insertTextBefore(parentNode, text, referenceNode) {
|
|
const { childNodes } = parentNode;
|
|
const referenceIdx = childNodes[childNodes.length - 1] === referenceNode
|
|
? childNodes.length - 1
|
|
: childNodes.indexOf(referenceNode);
|
|
const prevNode = childNodes[referenceIdx - 1];
|
|
if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) {
|
|
prevNode.value += text;
|
|
}
|
|
else {
|
|
defaultTreeAdapter.insertBefore(parentNode, defaultTreeAdapter.createTextNode(text), referenceNode);
|
|
}
|
|
},
|
|
/**
|
|
* Keeps the recipient's names between merges as a map from name to position. The map is rebuilt when the list changed
|
|
* length or has a repeated name, or when a merged name it holds no longer names the entry at that position. A name that
|
|
* other code gives an existing entry between two merges is missed otherwise, and merging it appends it a second time.
|
|
*/
|
|
adoptAttributes(recipient, attrs) {
|
|
// Merging a list into itself adds nothing: every name is already present.
|
|
if (attrs.length === 0 || attrs === recipient.attrs)
|
|
return;
|
|
const cached = attrListIndexes.get(recipient.attrs);
|
|
const isIndexed = (cached === null || cached === void 0 ? void 0 : cached.size) === recipient.attrs.length &&
|
|
attrs.every(({ name }) => {
|
|
var _a;
|
|
const index = cached.get(name);
|
|
return index === undefined || ((_a = recipient.attrs[index]) === null || _a === void 0 ? void 0 : _a.name) === name;
|
|
});
|
|
const recipientAttrsMap = isIndexed ? cached : new Map();
|
|
if (!isIndexed) {
|
|
for (let i = 0; i < recipient.attrs.length; i++) {
|
|
const attr = recipient.attrs[i];
|
|
// A sparse list is indexed again on every merge, as its size never matches its length.
|
|
if (attr !== undefined)
|
|
recipientAttrsMap.set(attr.name, i);
|
|
}
|
|
attrListIndexes.set(recipient.attrs, recipientAttrsMap);
|
|
}
|
|
const adoptedFrom = recipient.attrs.length;
|
|
for (let j = 0; j < attrs.length; j++) {
|
|
if (!recipientAttrsMap.has(attrs[j].name)) {
|
|
recipient.attrs.push(attrs[j]);
|
|
}
|
|
}
|
|
for (let j = adoptedFrom; j < recipient.attrs.length; j++) {
|
|
recipientAttrsMap.set(recipient.attrs[j].name, j);
|
|
}
|
|
// A list with a repeated name is indexed again on the next merge.
|
|
if (recipientAttrsMap.size !== recipient.attrs.length) {
|
|
attrListIndexes.delete(recipient.attrs);
|
|
}
|
|
},
|
|
//Tree traversing
|
|
getFirstChild(node) {
|
|
return node.childNodes[0];
|
|
},
|
|
getChildNodes(node) {
|
|
return node.childNodes;
|
|
},
|
|
getParentNode(node) {
|
|
return node.parentNode;
|
|
},
|
|
getAttrList(element) {
|
|
return element.attrs;
|
|
},
|
|
//Node data
|
|
getTagName(element) {
|
|
return element.tagName;
|
|
},
|
|
getNamespaceURI(element) {
|
|
return element.namespaceURI;
|
|
},
|
|
getTextNodeContent(textNode) {
|
|
return textNode.value;
|
|
},
|
|
getCommentNodeContent(commentNode) {
|
|
return commentNode.data;
|
|
},
|
|
getDocumentTypeNodeName(doctypeNode) {
|
|
return doctypeNode.name;
|
|
},
|
|
getDocumentTypeNodePublicId(doctypeNode) {
|
|
return doctypeNode.publicId;
|
|
},
|
|
getDocumentTypeNodeSystemId(doctypeNode) {
|
|
return doctypeNode.systemId;
|
|
},
|
|
//Node types
|
|
isTextNode(node) {
|
|
return node.nodeName === '#text';
|
|
},
|
|
isCommentNode(node) {
|
|
return node.nodeName === '#comment';
|
|
},
|
|
isDocumentTypeNode(node) {
|
|
return node.nodeName === '#documentType';
|
|
},
|
|
isElementNode(node) {
|
|
return Object.prototype.hasOwnProperty.call(node, 'tagName');
|
|
},
|
|
// Source code location
|
|
setNodeSourceCodeLocation(node, location) {
|
|
node.sourceCodeLocation = location;
|
|
},
|
|
getNodeSourceCodeLocation(node) {
|
|
return node.sourceCodeLocation;
|
|
},
|
|
updateNodeSourceCodeLocation(node, endLocation) {
|
|
node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation };
|
|
},
|
|
};
|