angular-xml-editor
Version:
XML editor component for Angular
3,372 lines • 388 kB
JavaScript
import { Subject } from 'rxjs';
import { Injectable, Inject, Component, Input, NgModule, EventEmitter, ViewEncapsulation, forwardRef, Renderer2, ViewChild, Output, defineInjectable, inject } from '@angular/core';
import { DOCUMENT, CommonModule } from '@angular/common';
import { NG_VALUE_ACCESSOR, ReactiveFormsModule, FormsModule } from '@angular/forms';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditorDebugger {
constructor() {
this.actualCursorPosChanged$ = new Subject();
this.inputSelectionChanged$ = new Subject();
}
/**
* @param {?} pos
* @return {?}
*/
setActualCursorPos(pos) {
this.actualCursorPosChanged$.next(pos);
}
/**
* @param {?} info
* @return {?}
*/
setInputSelection(info) {
this.inputSelectionChanged$.next(info);
}
/**
* @return {?}
*/
ngOnDestroy() {
this.actualCursorPosChanged$.complete();
this.inputSelectionChanged$.complete();
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlToolbox {
/**
* @param {?} node
* @return {?}
*/
static IsTextOrCommentNode(node) {
switch (node.nodeType) {
case Node.TEXT_NODE: // text node
case Node.COMMENT_NODE:
return true;
default:
return false;
}
// return ((node.nodeType === System.Xml.XmlText) || (node.nodeType === System.Xml.XmlComment));
}
/**
* @param {?} node
* @return {?}
*/
static GetNodeDebugContext(node) {
if (node === null || node === undefined) {
return 'NULL';
}
if (node.nodeType === Node.TEXT_NODE) {
if (node.textContent === ' ' || node.textContent === String.fromCharCode(160)) {
return `TextContent!Parent=${XmlToolbox.GetNodeDebugContext(node.parentNode)}`;
}
else {
return `TextContent='${node.textContent}'`;
}
}
/** @type {?} */
const asElem = /** @type {?} */ (node);
if (asElem === undefined) {
return `localName: ${node.nodeName}, nodeType:${node.nodeType}`;
}
else {
return asElem.outerHTML;
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class Xml2htmlAttributeWorker {
/**
* @param {?} rules
*/
constructor(rules) {
this.rules = rules;
}
/**
* writes the given attributes to the html node in data-attribute-syntax *
* @param {?} xmlElement
* @param {?} htmlElement
* @return {?}
*/
writeAllXmlAttributesToHtml(xmlElement, htmlElement) {
/** @type {?} */
const attributes = xmlElement.attributes;
for (let i = 0; i < attributes.length; ++i) {
/** @type {?} */
const attr = attributes[i];
this.writeAttributeToHtml(htmlElement, attr.name, attr.value);
}
}
/**
* writes the given attribute value to the html node in data-attribute-syntax *
* @param {?} htmlElement
* @param {?} key
* @param {?} value
* @return {?}
*/
writeAttributeToHtml(htmlElement, key, value) {
/** @type {?} */
const name = `${Xml2htmlAttributeWorker.DataAttribPraefix}${key}`;
if (value && value.length > 0) {
htmlElement.setAttribute(name, value);
}
else {
htmlElement.removeAttribute(name);
}
this.updateAttributesDescriptionInHtmlElement(htmlElement);
}
/**
* writes the given attribute value from the html node data-attribute-syntax *
* @param {?} htmlElement
* @param {?} key
* @return {?}
*/
getAttributeValueFromHtml(htmlElement, key) {
/** @type {?} */
const attributes = htmlElement.attributes;
for (let i = 0; i < attributes.length; ++i) {
if (attributes[i].name === `${Xml2htmlAttributeWorker.DataAttribPraefix}${key}`) {
return attributes[i].value;
}
}
return undefined;
}
/**
* writes the given attribute value to the xml node (and gets it from the html node from data-attribute-syntax) *
* @param {?} htmlElement
* @param {?} xmlElement
* @return {?}
*/
writeAllHtmlAttributesToXml(htmlElement, xmlElement) {
/** @type {?} */
const attributes = htmlElement.attributes;
for (let i = 0; i < attributes.length; ++i) {
/** @type {?} */
const attr = attributes[i];
if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {
xmlElement.setAttribute(attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length), attr.value);
}
}
}
/**
* updates the 'for human eyes' only description of the attributes inside a html node *
* @param {?} htmlElement
* @return {?}
*/
updateAttributesDescriptionInHtmlElement(htmlElement) {
/** @type {?} */
const attributes = htmlElement.attributes;
/** @type {?} */
let allAttributes = '';
for (let i = 0; i < attributes.length; ++i) {
/** @type {?} */
const attr = attributes[i];
if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {
allAttributes = `${allAttributes} ${attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length)}="${attr.value}"`;
}
}
if (allAttributes.length > 0) {
htmlElement.setAttribute('data-attributes', allAttributes);
}
else {
htmlElement.removeAttribute('data-attributes');
}
}
}
Xml2htmlAttributeWorker.DataAttribPraefix = 'data-attribute-';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class Xml2html {
/**
* @param {?} rules
*/
constructor(rules) {
this.rules = rules;
this.attributeWorker = new Xml2htmlAttributeWorker(rules);
}
/**
* @param {?} node
* @return {?}
*/
static getTagNameFromNode(node) {
/** @type {?} */
const elem = /** @type {?} */ (node);
/** @type {?} */
let name = '';
if (elem) {
name = elem.getAttribute(Xml2html.DataTagName);
}
if (name === undefined || name === null || name === '') {
throw new Error(`node has no DataTagName attribute ${XmlToolbox.GetNodeDebugContext(node)}`);
}
return name;
}
/**
* @param {?} node
* @return {?}
*/
static isFloatingElement(node) {
/** @type {?} */
const elem = /** @type {?} */ (node);
if (elem && elem.classList) {
return elem.classList.contains(Xml2html.FloatingTagClassName);
}
return false;
}
/**
* @param {?} node
* @return {?}
*/
static isNoClosingElement(node) {
/** @type {?} */
const elem = /** @type {?} */ (node);
if (elem && elem.classList) {
return elem.classList.contains(Xml2html.NoClosingTagClassName);
}
return false;
}
/**
* @param {?} xml
* @return {?}
*/
ToHtml(xml) {
if (xml === '' || xml === undefined || xml === null) {
return '';
}
// alert(xml);
// remove newline / carriage return
xml = xml.replace(/\n/g, '');
xml = xml.replace(/\r/g, '');
// remove whitespace (tabs) before tags
xml = xml.replace(/[\t]+\</g, '<');
// remove whitespace between tags
xml = xml.replace(/\>[\t]+\</g, '><');
// remove whitespace after tags
xml = xml.replace(/\>[\t]+$/g, '>');
/** @type {?} */
const domparser = new DOMParser();
/** @type {?} */
const domdoc = domparser.parseFromString(xml, 'text/xml');
/** @type {?} */
const targetDocument = new Document();
if (domdoc.documentElement === null) {
return '';
}
/** @type {?} */
const body = this.GetHtmlElementFromXmlElement(domdoc.documentElement, targetDocument);
if (body && body.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const html = (/** @type {?} */ (body)).outerHTML;
return html;
}
else {
throw new Error(`root node ${XmlToolbox.GetNodeDebugContext(body)} is no element`);
}
}
/**
* @param {?} ruleElem
* @return {?}
*/
createNewElementHtml(ruleElem) {
/** @type {?} */
const elem = this.createNewElementByName(ruleElem.tagName);
return elem.outerHTML;
}
/**
* @param {?} tagName
* @return {?}
*/
createNewElementByName(tagName) {
/** @type {?} */
const tempDoc = new Document();
/** @type {?} */
const newElement = tempDoc.createElement('div');
/** @type {?} */
const rule = this.rules.ruleElements.get(tagName);
if (rule && rule.floating === true) {
newElement.classList.add(Xml2html.FloatingTagClassName);
}
// visualize closing tag or not?
if (rule && rule.empty === true) {
newElement.classList.add(Xml2html.NoClosingTagClassName);
}
newElement.setAttribute(Xml2html.DataTagName, tagName);
return newElement;
}
/**
* @param {?} node
* @param {?} targetDocument
* @return {?}
*/
GetHtmlElementFromXmlElement(node, targetDocument) {
switch (node.nodeType) {
case Node.ELEMENT_NODE: // element node
/** @type {?} */
const asElement = /** @type {?} */ (node);
/** @type {?} */
const nodeName = asElement.nodeName;
/** @type {?} */
let newElement = targetDocument.createElement('div');
/** @type {?} */
const rule = this.rules.ruleElements.get(nodeName);
if (rule && rule.floating) {
newElement.classList.add(Xml2html.FloatingTagClassName);
}
// visualize closing tag or not?
if (rule && rule.empty) {
newElement.classList.add(Xml2html.NoClosingTagClassName);
}
newElement.setAttribute(Xml2html.DataTagName, nodeName);
/** @type {?} */
const children = asElement.childNodes;
if (children.length === 0) {
newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags
}
else {
for (let i = 0; i < children.length; ++i) {
/** @type {?} */
const childAsHtml = this.GetHtmlElementFromXmlElement(children[i], targetDocument);
if (childAsHtml !== undefined) {
newElement.appendChild(childAsHtml);
}
}
}
// insert attributes
this.attributeWorker.writeAllXmlAttributesToHtml(asElement, newElement);
return newElement;
case Node.TEXT_NODE: // text node
/** @type {?} */
const content = (/** @type {?} */ (node)).textContent;
if (content.length > 0) {
return targetDocument.createTextNode(content);
}
else {
return undefined;
}
case Node.COMMENT_NODE:
// create element node
newElement = targetDocument.createElement('div');
newElement.classList.add(Xml2html.CommentTagClassName);
newElement.setAttribute(Xml2html.DataTagName, 'comment');
newElement.textContent = (/** @type {?} */ (node)).textContent;
return newElement;
/* yet not implemented types */
case Node.PROCESSING_INSTRUCTION_NODE:
console.warn(`nodeType "PROCESSING_INSTRUCTION_NODE" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);
return undefined;
case Node.DOCUMENT_NODE:
throw new Error(`nodeType "Node.DOCUMENT_NODE" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);
case Node.DOCUMENT_TYPE_NODE:
throw new Error(`nodeType "Node.DOCUMENT_NODE" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);
case Node.DOCUMENT_FRAGMENT_NODE:
throw new Error(`nodeType "Node.DOCUMENT_FRAGMENT_NODE" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);
/* Depreached node types */
case Node.ATTRIBUTE_NODE:
throw new Error(`nodeType "Node.ATTRIBUTE_NODE" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);
case Node.CDATA_SECTION_NODE:
throw new Error(`nodeType "Node.CDATA_SECTION_NODE" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);
case Node.ENTITY_REFERENCE_NODE:
throw new Error(`nodeType "Node.ENTITY_REFERENCE_NODE" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);
case Node.ENTITY_NODE:
throw new Error(`nodeType "Node.ENTITY_NODE" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);
case Node.NOTATION_NODE:
throw new Error(`nodeType "Node.NOTATION_NODE" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);
default:
// tslint:disable-next-line:max-line-length
throw new Error(`unknown xmlElement nodeType ${node.nodeType} in value: ${XmlToolbox.GetNodeDebugContext(node)}`);
}
}
}
Xml2html.DataTagName = 'data-tagname';
Xml2html.NoClosingTagClassName = 'xmlTagNoClosing';
Xml2html.FloatingTagClassName = 'floating';
Xml2html.CommentTagClassName = 'comment';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class DomDummyNodeManager {
constructor() { }
/**
* @param {?} node
* @return {?}
*/
static IsDummyNode(node) {
/** @type {?} */
const asElem = /** @type {?} */ (node);
if (asElem && node.nodeType === Node.ELEMENT_NODE) {
return asElem.classList.contains(DomDummyNodeManager.DummyNodeClassName);
}
return false;
}
/**
* @param {?} node
* @return {?}
*/
static IsBeforeFirstTagDummyNode(node) {
if (DomDummyNodeManager.IsDummyNode(node)) {
/** @type {?} */
const asElem = /** @type {?} */ (node);
if (asElem && node.nodeType === Node.ELEMENT_NODE) {
return asElem.classList.contains(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);
}
return false;
}
else {
return false;
}
}
/**
* @param {?} node
* @return {?}
*/
static getPreviousSibling(node) {
if (!node) {
return undefined;
}
while (node) {
node = node.previousSibling;
if (node) {
if (DomDummyNodeManager.IsDummyNode(node)) ;
else {
return node;
}
}
}
return undefined;
}
/**
* @param {?} node
* @return {?}
*/
static getNextSibling(node) {
if (!node) {
return undefined;
}
while (node) {
node = node.nextSibling;
if (node) {
if (DomDummyNodeManager.IsDummyNode(node)) ;
else {
return node;
}
}
}
return undefined;
}
/**
* @param {?} node
* @return {?}
*/
static getChildNodeCount(node) {
if (!node) {
return 0;
}
/** @type {?} */
let count = 0;
for (let i = 0; i < node.childNodes.length; i++) {
if (!DomDummyNodeManager.IsDummyNode(node.childNodes[i])) {
count++;
}
}
return count;
}
/**
* @param {?} node
* @return {?}
*/
static getFirstChild(node) {
if (!node) {
return undefined;
}
/** @type {?} */
let first = /** @type {?} */ (node.firstChild);
while (DomDummyNodeManager.IsDummyNode(first)) {
first = first.nextSibling;
}
return first;
}
/**
* @param {?} node
* @return {?}
*/
static getLastChild(node) {
if (!node) {
return undefined;
}
/** @type {?} */
let last = /** @type {?} */ (node.lastChild);
while (DomDummyNodeManager.IsDummyNode(last)) {
last = last.previousSibling;
}
return last;
}
/**
* @param {?} node
* @param {?=} nodeDepth
* @return {?}
*/
RemoveAllDummyNodes(node, nodeDepth = 0) {
/** @type {?} */
let children = [];
for (let i = 0; i < node.childNodes.length; ++i) {
children.push(node.childNodes[i]);
}
// delete all dummy node children
children.forEach(child => {
if (DomDummyNodeManager.IsDummyNode(child)) {
node.removeChild(child);
}
});
children = [];
for (let i = 0; i < node.childNodes.length; ++i) {
children.push(node.childNodes[i]);
}
// update child nodes
children.forEach(child => {
this.RemoveAllDummyNodes(child, nodeDepth + 1);
});
}
/**
* @param {?} node
* @param {?=} nodeDepth
* @return {?}
*/
UpdateDummyNodes(node, nodeDepth = 0) {
/** @type {?} */
const document = node.ownerDocument;
/** @type {?} */
const asElement = /** @type {?} */ (node);
/** @type {?} */
const children = [];
for (let i = 0; i < node.childNodes.length; ++i) {
children.push(node.childNodes[i]);
}
if (asElement && !DomDummyNodeManager.IsDummyNode(asElement) && !DomDummyNodeManager.IsDummyNode(asElement.parentElement)) {
if (asElement.nodeType === Node.TEXT_NODE) {
/** @type {?} */
const before = asElement.previousSibling;
if (before.nodeType === Node.TEXT_NODE) ;
else {
if (!DomDummyNodeManager.IsDummyNode(before)) {
asElement.parentNode.insertBefore(this.createDummyNode(document), asElement);
}
}
}
if (asElement.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
let firstChild = node.firstChild;
if (!firstChild) {
// create dummy node in empty tag
node.appendChild(this.createDummyNode(document));
firstChild = node.firstChild;
}
if (Xml2html.isNoClosingElement(node)) ;
else {
firstChild = node.firstChild;
if (!firstChild) {
// create dummy node in empty tag
node.appendChild(this.createDummyNode(document));
firstChild = node.firstChild;
}
// Insert a dummy node before the first child
if (!DomDummyNodeManager.IsDummyNode(firstChild)) {
if (firstChild) {
node.insertBefore(this.createDummyNode(document), firstChild);
firstChild = node.firstChild;
}
else {
node.appendChild(this.createDummyNode(document));
}
}
/** @type {?} */
let lastChild = node.lastChild;
if (!DomDummyNodeManager.IsDummyNode(lastChild)) {
node.appendChild(this.createDummyNode(document));
lastChild = node.lastChild;
}
// Insert a dummy node before the first (dummy child) but optical in front of the node (to show the cursor in front of the node)
if (nodeDepth > 0) {
if (DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
/** @type {?} */
const dummyNode = this.createDummyNode(document);
dummyNode.classList.add(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);
asElement.insertBefore(dummyNode, firstChild);
}
}
}
}
}
// update child nodes
children.forEach(child => {
this.UpdateDummyNodes(child, nodeDepth + 1);
});
}
/**
* @param {?} targetDocument
* @param {?=} content
* @return {?}
*/
createDummyNode(targetDocument, content) {
/** @type {?} */
const dummyNode = targetDocument.createElement('span');
/** @type {?} */
let dummy2TextNode;
if (content === undefined) {
dummy2TextNode = targetDocument.createTextNode(DomDummyNodeManager.DummyNodeContent);
}
else {
dummy2TextNode = targetDocument.createTextNode(content);
}
dummyNode.classList.add(DomDummyNodeManager.DummyNodeClassName);
dummyNode.appendChild(dummy2TextNode);
return dummyNode;
}
}
DomDummyNodeManager.DummyNodeClassName = 'dummyNode';
DomDummyNodeManager.DummyNodeBeforeFirstTagClassName = 'beforefirstTag';
DomDummyNodeManager.DummyNodeContent = String.fromCharCode(160);
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlCursorPos {
/**
* @param {?} position
* @return {?}
*/
static getXmlCursorPositionDebugName(position) {
switch (position) {
case XMLCursorPositions.CursorOnCompleteNode:
return 'CursorOnCompleteNode';
case XMLCursorPositions.CursorBehindNode:
return 'CursorBehindNode';
case XMLCursorPositions.CursorInEmptyNode:
return 'CursorInEmptyNode';
case XMLCursorPositions.CursorInsideTextNode:
return 'CursorInsideTextNode';
case XMLCursorPositions.CursorInFrontOfNode:
return 'CursorInFrontOfNode';
default:
return `unknown cursorPos ${position}`;
}
}
/**
* @param {?} pos
* @return {?}
*/
static getSelectionForPos(pos) {
if (DomDummyNodeManager.IsDummyNode(pos.ActualNode)) {
throw new Error(`XmlCursorPos.getSelectionForPos: pos.AktNode ${pos.getDebugDescription()} is a dummy node!`);
}
if (DomDummyNodeManager.IsDummyNode(pos.ActualNode.parentElement)) {
throw new Error(`XmlCursorPos.getSelectionForPos: pos.AktNode.parentElement ${pos.getDebugDescription()} is a dummy node!`);
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode: // (0)
/** @type {?} */
let firstChild = pos.ActualNode.firstChild;
if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
return {
node: firstChild.firstChild,
// text inside BeforeFirstTagDummyNod
offset: 0
};
}
else {
return {
node: pos.ActualNode,
offset: 0
};
}
case XMLCursorPositions.CursorInFrontOfNode: // (1)
// (1)
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
/** @type {?} */
const dummyBefore = pos.ActualNode.previousSibling;
if (DomDummyNodeManager.IsDummyNode(dummyBefore)) {
return {
node: dummyBefore.firstChild,
// before text node
offset: 1
};
}
else {
throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):text node: is no dummy node: ' + pos.getDebugDescription());
}
}
else {
// no text node
firstChild = pos.ActualNode.firstChild;
if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
return {
node: firstChild.firstChild,
// text inside BeforeFirstTagDummyNod
offset: 1
};
}
if (Xml2html.isNoClosingElement(pos.ActualNode) && DomDummyNodeManager.IsDummyNode(firstChild)) {
return { node: firstChild.firstChild, offset: 1 };
}
throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):no text node: dont know what to do! ');
}
break;
case XMLCursorPositions.CursorBehindNode: // (7, 11)
/** @type {?} */
const dummyAfter = pos.ActualNode.nextSibling;
if (DomDummyNodeManager.IsDummyNode(dummyAfter)) {
return {
node: dummyAfter.firstChild,
// before text node
offset: 0
};
}
else {
throw new Error(`XMLCursorPositionen.CursorBehindNode should only be set, when the element has no next sibling.`);
}
case XMLCursorPositions.CursorInEmptyNode:
/** @type {?} */
const lastChild = pos.ActualNode.lastChild;
if (!DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
return {
node: lastChild.firstChild,
// text inside DummyNode
offset: 0
};
}
break;
case XMLCursorPositions.CursorInsideTextNode:
return {
node: pos.ActualNode,
offset: pos.PosInTextnode
};
}
throw new Error(`showCursor.getSelectionForPos unknown CursorPos ${pos.getDebugDescription()}`);
}
constructor() {
this.ActualNode = null; // no node selected
this.PosAtNode = XMLCursorPositions.CursorOnCompleteNode;
this.PosInTextnode = 0;
}
/**
* @return {?}
*/
clone() {
/** @type {?} */
const klon = new XmlCursorPos();
klon.SetCursor(this.ActualNode, this.PosAtNode, this.PosInTextnode);
return klon;
}
/**
* @param {?} otherPos
* @return {?}
*/
equals(otherPos) {
if (!otherPos) {
return false;
}
if (otherPos.ActualNode !== this.ActualNode) {
return false;
}
if (otherPos.PosAtNode !== this.PosAtNode) {
return false;
}
if (this.PosAtNode === XMLCursorPositions.CursorInsideTextNode && this.PosInTextnode !== otherPos.PosInTextnode) {
return false;
}
return true;
}
/**
* @return {?}
*/
getDebugDescription() {
return `node:${XmlToolbox.GetNodeDebugContext(this.ActualNode)}, pos:${XmlCursorPos.getXmlCursorPositionDebugName(this.PosAtNode)}, posInText:${this.PosInTextnode}`;
}
/**
* @param {?} actualNode
* @param {?} posAtNode
* @param {?=} posInTextnode
* @return {?}
*/
SetCursor(actualNode, posAtNode, posInTextnode = 0) {
if (!actualNode) {
throw new Error('actualNode is null');
}
if (actualNode !== this.ActualNode) ;
else {
if (posAtNode !== this.PosAtNode) ;
else {
if (posInTextnode !== this.PosInTextnode) ;
}
}
this.ActualNode = actualNode;
this.PosAtNode = posAtNode;
this.PosInTextnode = posInTextnode;
}
/**
* @param {?} node
* @return {?}
*/
setCursorBehindNodeForDefaultOrRightMovement(node) {
/** @type {?} */
const nextSibling = DomDummyNodeManager.getNextSibling(node);
if (nextSibling) {
this.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);
}
else {
this.SetCursor(node, XMLCursorPositions.CursorBehindNode);
}
}
/**
* @param {?} node
* @return {?}
*/
setCursorpBehindNodeForLeftMovement(node) {
if (XmlToolbox.IsTextOrCommentNode(node)) {
// For a text node, the cursor is placed after the last character.
this.SetCursor(node, XMLCursorPositions.CursorInsideTextNode, Math.max(0, node.textContent.length - 1));
}
else {
/** @type {?} */
const childNodeCount = DomDummyNodeManager.getChildNodeCount(node);
if (childNodeCount === 0) {
// There are no children in the node.
if (!Xml2html.isNoClosingElement(node)) {
// If the cursor shows a close tag, then put it in the empty node
this.SetCursor(node, XMLCursorPositions.CursorInEmptyNode);
}
else {
// If the cursor does not display a close tag, then place it before the empty node.
this.SetCursor(node, XMLCursorPositions.CursorInFrontOfNode);
}
}
else {
// There are children in node
this.SetCursor(DomDummyNodeManager.getLastChild(node), XMLCursorPositions.CursorBehindNode);
}
}
}
}
/** @enum {number} */
const XMLCursorPositions = {
CursorInFrontOfNode: 0,
CursorOnCompleteNode: 1,
CursorInEmptyNode: 2,
CursorInsideTextNode: 3,
CursorBehindNode: 4,
};
XMLCursorPositions[XMLCursorPositions.CursorInFrontOfNode] = 'CursorInFrontOfNode';
XMLCursorPositions[XMLCursorPositions.CursorOnCompleteNode] = 'CursorOnCompleteNode';
XMLCursorPositions[XMLCursorPositions.CursorInEmptyNode] = 'CursorInEmptyNode';
XMLCursorPositions[XMLCursorPositions.CursorInsideTextNode] = 'CursorInsideTextNode';
XMLCursorPositions[XMLCursorPositions.CursorBehindNode] = 'CursorBehindNode';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlCursorPosMover {
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
static moveLeft(pos, rootNode, xmlRules) {
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
// Put in front of the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);
break;
case XMLCursorPositions.CursorInFrontOfNode:
if (pos.ActualNode === rootNode) {
return false;
}
else {
/** @type {?} */
const previousSibling = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);
if (previousSibling) {
// Previous sibling node exists
pos.setCursorpBehindNodeForLeftMovement(previousSibling);
}
else {
// no previous sibling node available -> set before parent node
pos.SetCursor(pos.ActualNode.parentNode, XMLCursorPositions.CursorInFrontOfNode);
}
}
break;
case XMLCursorPositions.CursorBehindNode:
pos.setCursorpBehindNodeForLeftMovement(pos.ActualNode);
break;
case XMLCursorPositions.CursorInEmptyNode:
// Put in front of the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);
break;
case XMLCursorPositions.CursorInsideTextNode:
if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {
// Node is Textnode
if (pos.PosInTextnode > 1) {
// Cursor one character to the left
pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode - 1);
}
else {
// Put in front of the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);
}
}
else {
/** @type {?} */
const elemt = /** @type {?} */ (pos.ActualNode);
throw new Error(`XMLCursorPos.MoveLeft: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes,
but no text node has been chosen, but the node ${elemt ? elemt.outerHTML : ''}`);
}
break;
default:
throw new Error(`XMLCursorPos.MoveLeft: unknown CursorPos ${pos.PosAtNode}`);
}
return true;
}
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
static moveRight(pos, rootNode, xmlRules) {
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
/** @type {?} */
const tagName = Xml2html.getTagNameFromNode(pos.ActualNode);
/** @type {?} */
const rule = xmlRules.ruleElements.get(tagName);
if (rule && rule.empty === true) {
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
}
else {
/** @type {?} */
const firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);
if (firstChild) {
pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);
}
else {
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);
}
}
break;
case XMLCursorPositions.CursorBehindNode:
/** @type {?} */
const nextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode);
if (nextSibling) {
/** @type {?} */
const elemt = /** @type {?} */ (pos.ActualNode);
throw new Error(`XMLCursorPos.MoveRight: cursor behind node should only be set, when no other siblings are following ${elemt ? elemt.outerHTML : ''}`);
}
else {
/** @type {?} */
const parentNextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode.parentElement);
if (parentNextSibling) {
pos.SetCursor(parentNextSibling, XMLCursorPositions.CursorInFrontOfNode);
}
else {
pos.SetCursor(pos.ActualNode.parentElement, XMLCursorPositions.CursorBehindNode);
}
}
break;
case XMLCursorPositions.CursorInEmptyNode:
// Place behind the node
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
break;
case XMLCursorPositions.CursorInFrontOfNode:
if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {
// Node is Textnode
if ((/** @type {?} */ (pos.ActualNode)).textContent.length > 1) {
// Textnode is not empty
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, 1); // one character forward, behind the first character
}
else {
// Textnode is empty
// put behind the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorBehindNode);
// Because "CursorBehindNode" is not attractive, one more step
this.moveRight(pos, rootNode, xmlRules);
}
}
else {
/** @type {?} */
const childNodeCount = DomDummyNodeManager.getChildNodeCount(pos.ActualNode);
if (childNodeCount === 0) {
// no Children existing
if (Xml2html.isNoClosingElement(pos.ActualNode)) {
// If no closed tag is displayed for this node, then directly behind the node
// Place behind the node
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
}
else {
// Node has closing tag, so put in between
// Place in empty node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);
}
}
else {
/** @type {?} */
const firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);
pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);
}
}
break;
case XMLCursorPositions.CursorInsideTextNode:
if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {
// Node is Textnode
if ((/** @type {?} */ (pos.ActualNode)).textContent.length > pos.PosInTextnode + 1) {
// there is still text in the right of the textnode
// step one character forwards: behind the first char
pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode + 1);
}
else {
// no text after the textnode
// place cursor behind the node
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
}
}
else {
/** @type {?} */
const elemt = /** @type {?} */ (pos.ActualNode);
throw new Error(`XMLCursorPos.MoveRight: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes,
but no text node has been chosen, but the node ${elemt ? elemt.outerHTML : ''}`);
}
break;
default:
throw new Error(`String.Format("XMLCursorPos.MoveRight: unknown CursorPos ${pos.PosAtNode}`);
}
return true;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlCursor {
constructor() {
this.xmlDocumentRootNode = undefined;
this.domDummyNodeManager = new DomDummyNodeManager();
this.StartPos = new XmlCursorPos();
this.EndPos = new XmlCursorPos();
}
/**
* is there nothing between start and end pos?
* @return {?}
*/
isEmptySelection() {
if (this.StartPos.equals(this.EndPos)) {
return true;
}
return false;
}
/**
* @return {?}
*/
sortStartAndEnd() {
if (this.StartPos.ActualNode && this.EndPos.ActualNode) {
if (this.StartPos.ActualNode.isSameNode(this.EndPos.ActualNode)) {
if (this.StartPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&
this.EndPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&
this.StartPos.PosInTextnode > this.EndPos.PosInTextnode) {
this.swapStartAndEnd();
}
}
else {
/** @type {?} */
const compared = this.StartPos.ActualNode.compareDocumentPosition(this.EndPos.ActualNode);
// tslint:disable-next-line:no-bitwise
if (!(compared & Node.DOCUMENT_POSITION_FOLLOWING)) {
this.swapStartAndEnd();
}
}
}
}
/**
* @return {?}
*/
swapStartAndEnd() {
/** @type {?} */
const node = this.StartPos.ActualNode;
/** @type {?} */
const pos = this.StartPos.PosAtNode;
/** @type {?} */
const text = this.StartPos.PosInTextnode;
this.StartPos.SetCursor(this.EndPos.ActualNode, this.EndPos.PosAtNode, this.EndPos.PosInTextnode);
this.EndPos.SetCursor(node, pos, text);
}
/**
* @return {?}
*/
show() {
if (window.getSelection) {
/** @type {?} */
const selection = window.getSelection();
this.show2(selection);
}
else {
throw new Error('showCursor: unable to get "window.getSelection"');
}
}
/**
* @param {?} selection
* @return {?}
*/
show2(selection) {
if (!selection) {
return;
}
/** @type {?} */
const elems = document.querySelectorAll('.selected');
[].forEach.call(elems, function (el) {
el.classList.remove('selected');
});
/** @type {?} */
const startSelection = XmlCursorPos.getSelectionForPos(this.StartPos);
if (this.EndPos && this.EndPos.ActualNode && !this.EndPos.equals(this.StartPos)) {
/** @type {?} */
const endSelection = XmlCursorPos.getSelectionForPos(this.EndPos);
selection.setBaseAndExtent(startSelection.node, startSelection.offset, endSelection.node, endSelection.offset);
}
else {
// only start pos
selection.setPosition(startSelection.node, startSelection.offset);
// select tag by adding "select" class
if (this.StartPos.PosAtNode === XMLCursorPositions.CursorOnCompleteNode) {
/** @type {?} */
const asElem = /** @type {?} */ (this.StartPos.ActualNode);
if (asElem && asElem.classList) {
asElem.classList.add('selected');
console.log('selected!');
}
else {
console.error(`no asElem.classList for select! ${XmlToolbox.GetNodeDebugContext(asElem)}`);
}
}
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlCursorPosSetter {
/**
* @param {?} pos
* @param {?} selectionAnchorNode
* @param {?} selectionAnchorOffset
* @param {?=} debugLog
* @return {?}
*/
static setFromSelection(pos, selectionAnchorNode, selectionAnchorOffset, debugLog = null) {
if (selectionAnchorNode !== undefined && selectionAnchorNode !== null) {
/** @type {?} */
let node = /** @type {?} */ (selectionAnchorNode);
if (DomDummyNodeManager.IsDummyNode(selectionAnchorNode.parentElement)) {
// clicked inside a dummy node
node = /** @type {?} */ (selectionAnchorNode.parentElement);
if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(node)) {
switch (selectionAnchorOffset) {
case 0:
if (debugLog) {
debugLog.setInputSelection(`(1) cursor here: #<tag> pos 0`);
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);
return;
case 1:
if (debugLog) {
debugLog.setInputSelection(`(2) cursor here: #<tag> pos 1`);
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInFrontOfNode, 0);
return;
default:
throw new Error(`selectionAnchorOffset=${selectionAnchorOffset}?!?`);
}
}
if (node.parentElement.childNodes.length === 2) {
if (debugLog) {
debugLog.setInputSelection(`(13, 14) cursor here: <tag>#</tag>`);
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInEmptyNode, 0);
return;
}
if (node === node.parentElement.lastChild && selectionAnchorOffset === 1) {
if (debugLog) {
debugLog.setInputSelection(`(8, 12) cursor here: #</tag>, selecting complete node`);
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);
return;
}
/** @type {?} */
const nextSibling = node.nextSibling;
if (nextSibling) {
if (debugLog) {
debugLog.setInputSelection(`(3, 4, 9, 10) cursor here: #Text or here #<tag>`);
}
pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode, 0);
return;
}
/** @type {?} */
const previousSibling = node.previousSibling;
if (previousSibling) {
if (debugLog) {
debugLog.setInputSelection(`(7, 11) cursor here: Text# or here <tag>#`);
}
pos.SetCursor(previousSibling, XMLCursorPositions.CursorBehindNode, 0);
return;
}
}
else {
// is no dummy node
if (selectionAnchorNode.nodeType === Node.TEXT_NODE) {
if (selectionAnchorOffset === 0) {
if (debugLog) {
debugLog.setInputSelection(`(6) cursor here: #Text`);
}
pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, 0);
return;
}
if (selectionAnchorOffset === selectionAnchorNode.textContent.length) {
if (debugLog) {
debugLog.setInputSelection(`(7 Alternative) cursor here: Text#`);
}
pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorNode.textContent.length);
return;
}
if (debugLog) {
debugLog.setInputSelection(`(5) cursor here: Text#Text`);
}
if (selectionAnchorOffset > selectionAnchorNode.textContent.length) {
throw new Error(`selectionAnchorOffset ${selectionAnchorOffset} is > than text-lenght ${selectionAnchorNode.textContent.length} of text '${selectionAnchorNode.textContent}' `);
}
pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorOffset);
return;
}
}
// if (DomDummyNodeManager.IsDummyNode(parentElem)) {
// const dummyElement = parentElem;
// const nextSibling = parentElem.nextSibling;
// if (XmlToolbox.IstTextOderKommentarNode(nextSibling)) {
// // cursor here: #text (# = red dummyNode)
// pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);
// return;
// }
// const previousSibling = dummyElement.previousSibling;
// if (!previousSibling) {
// // pos.CursorSetzen(dummyElement.parentElement, XMLCursorPositionen.c, 0);
// }
// }
// switch (node.nodeType) {
// case Node.TEXT_NODE:
// if (loopCount === 0) {
// const nextSibling = parentElem.nextSibling;
// if (nextSibling && nextSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 1) {
// // set cursor at start of following textnode
// pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);
// } else {
// const previousSibling = parentElem.previousSibling;
// if (previousSibling && previousSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 0) {
// // set cursor at end of previous textnode
// pos.CursorSetzen(previousSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, previousSibling.nodeValue.length);
// }
// }
// } else {
// node = parentElem; // up to dummy node
// }
// } else {
// pos.CursorSetzen(node, XMLCursorPositionen.CursorInnerhalbDesTextNodes, selectionAnchorOffset);
// }
// break;
// case Node.ELEMENT_NODE:
// if (DomDummyNodeManager.IsDummyNode(node)) {
// // node = parentElem; // up to parent node
// } else {
// pos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);
// }
// break;
// default:
// throw new Error(`unhandled nodeType '${node.nodeType}' of node ${XmlToolbox.GetNodeDebugContext(node)}`);
// }
}
console.error(`found no suiting cursor interpretation! For selectionAnchorNode=${XmlToolbox.GetNodeDebugContext(selectionAnchorNode)}, selectionAnchorOffset=${selectionAnchorOffset}`);
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlDomCleaner {
/**
* @param {?} node
* @param {?} actualCursor
* @return {?}
*/
static cleanUp(node, actualCursor) {
this.concatTextNodes(node, actualCursor);
}
/**
*
* if two textnodes are direct siblings: concat to one textnode
* @param {?} node
* @param {?} actualCursor
* @param {?=} nodeDepth
* @return {?}
*/
static concatTextNodes(node, actualCursor, nodeDepth = 0) {
/** @type {?} */
let restart = true;
while (restart === true) {
restart = false;
for (let i = 0; i < node.childNodes.length; ++i) {
/** @type {?} */
const firstToCheck = node.childNodes[i];
if (DomDummyNodeManager.IsDummyNode(firstToCheck)) {
throw new Error('Dummynodes have to be removed before using XmlDomCleaner!');
}
if (firstToCheck.nodeType === Node.TEXT_NODE) {
/** @type {?} */
const secondToCheck = firstToCheck.nextSibling;
if (secondToCheck !== null && secondToCheck.nodeType === Node.TEXT_NODE) {
// two text nodes after each other => concat
if (actualCursor.StartPos.ActualNode === secondToCheck) {
actualCursor.StartPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.StartPos.PosInTextnode);
}
if (actualCursor.EndPos.ActualNode === secondToCheck) {
actualCursor.EndPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.EndPos.PosInTextnode);
}
firstToCheck.textContent = firstToCheck.textContent + secondToCheck.textContent;
node.removeChild(secondToCheck);
restart = true;
}
}
}
}
// update child nodes
for (let i = 0; i < node.childNodes.length; ++i) {
this.concatTextNodes(node.childNodes[i], actualCursor, nodeDepth + 1);
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditDelete {
/**
* @param {?} cursor
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
static deleteSelection(cursor, rootNode, xmlRules) {
return true;
}
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
static deleteAfter(pos, rootNode, xmlRules) {
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
case XMLCursorPositions.CursorInEmptyNode:
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
case XMLCursorPositions.CursorInsideTextNode:
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
default:
throw new Error(`String.Format("XmlCursorEdit.deleteBefore: unknown CursorPos ${pos.PosAtNode}`);
}
return true;
}
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
static deleteBefore(pos, rootNode, xmlRules) {
/** @type {?} */
let deleteNode;
// console.log(pos.getDebugDescription());
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
deleteNode = pos.ActualNode;
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
deleteNode.parentElement.removeChild(deleteNode);
break;
case XMLCursorPositions.CursorBehindNode:
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.ActualNode.textContent.length);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
}
else {
pos.ActualNode.parentElement.removeChild(pos.ActualNode);
}
break;
case XMLCursorPositions.CursorInEmptyNode:
deleteNode = pos.ActualNode;
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
deleteNode.parentElement.removeChild(deleteNode);
break;
case XMLCursorPositions.CursorInFrontOfNode:
deleteNode = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);
if (!deleteNode) {
deleteNode = pos.ActualNode.parentElement;
}
if (deleteNode) {
if (deleteNode.nodeType === Node.TEXT_NODE) {
pos.SetCursor(deleteNode, XMLCursorPositions.CursorInsideTextNode, deleteNode.textContent.length);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
}
else {
deleteNode.parentElement.removeChild(deleteNode);
}
}
break;
case XMLCursorPositions.CursorInsideTextNode:
if (pos.PosInTextnode === 0) {
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode, 0);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
}
else {
/** @type {?} */
let text = pos.ActualNode.textContent;
text = text.substring(0, pos.PosInTextnode - 1) + text.substr(pos.PosInTextnode, pos.ActualNode.textContent.length);
pos.ActualNode.textContent = text;
XmlCursorPosMover.moveLeft(pos, rootNode, xmlRules);
// pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode - 1);
}
break;
default:
throw new Error(`String.Format("XmlEdit.deleteBefore: unknown CursorPos ${pos.PosAtNode}`);
}
return true;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditRuleCheckTextInsert {
/**
* @param {?} xsdNodes
*/
constructor(xsdNodes) {
this.xsdNodes = xsdNodes;
this.namespacePraefix = 'xs:';
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
isTextAllowedAtThisCursorPos(cursorPosToCheck) {
if (!cursorPosToCheck) {
return false;
}
/** @type {?} */
const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);
/** @type {?} */
const parentName = Xml2html.getTagNameFromNode(parentNode);
/** @type {?} */
const xsdNode = this.xsdNodes.get(parentName);
if (xsdNode) {
/** @type {?} */
const result = this.isTextAllowedInThisElement(xsdNode);
return result;
}
else {
return false; // element not found
}
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
getRelevantParentNodeForCursorPos(cursorPosToCheck) {
if (cursorPosToCheck) {
/** @type {?} */
let parentNode = cursorPosToCheck.ActualNode;
switch (parentNode.nodeType) {
case Node.COMMENT_NODE:
case Node.TEXT_NODE:
parentNode = parentNode.parentElement;
break;
case Node.ELEMENT_NODE:
switch (cursorPosToCheck.PosAtNode) {
case XMLCursorPositions.CursorInEmptyNode:
case XMLCursorPositions.CursorInsideTextNode:
break;
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
case XMLCursorPositions.CursorOnCompleteNode:
parentNode = parentNode.parentElement;
break;
default:
throw new Error(`unhandled cursorPosToCheck.PosAmNode "${cursorPosToCheck.PosAtNode}"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}" `);
}
break;
default:
throw new Error(`unhandled parentNode.nodeType "${parentNode.nodeType}"`);
}
return parentNode;
}
}
/**
* @param {?} xsdNode
* @param {?=} alreadyAddedElementNames
* @return {?}
*/
isTextAllowedInThisElement(xsdNode, alreadyAddedElementNames = new Set()) {
/** @type {?} */
let elementName;
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const asElem = /** @type {?} */ (xsdNode);
if (asElem) {
/** @type {?} */
const mixedAttrib = asElem.getAttribute('mixed');
if (mixedAttrib) {
return true;
}
/** @type {?} */
const typeAttrib = asElem.getAttribute('type');
if (typeAttrib && typeAttrib === `${this.namespacePraefix}string`) {
return true;
}
if (asElem.localName === 'element') {
elementName = asElem.getAttribute('name');
if (elementName) {
if (alreadyAddedElementNames.has(elementName)) {
return false; // element recursion detected
}
}
alreadyAddedElementNames.add(elementName);
}
}
}
/** @type {?} */
const childNodes = /** @type {?} */ (Array.prototype.slice.call(xsdNode.childNodes));
/** @type {?} */
let allowed = false;
childNodes.forEach(child => {
if (child.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const childElem = /** @type {?} */ (child);
if (childElem) {
switch (childElem.localName) {
case 'complexType':
case 'sequence':
case 'choice':
case 'simpleContent':
case 'extension':
if (this.isTextAllowedInThisElement(child, alreadyAddedElementNames) === true) {
allowed = true;
break;
}
break;
case 'element':
/** @type {?} */
const refname = childElem.attributes.getNamedItem('ref');
if (refname) {
/** @type {?} */
const referedNode = this.xsdNodes.get(refname.value);
if (referedNode) {
if (this.isTextAllowedInThisElement(referedNode, alreadyAddedElementNames) === true) {
allowed = true;
break;
}
}
else {
throw new Error(` refered element "${refname}" for element "${childElem.outerHTML}" not found`);
}
}
break;
case 'attribute':
break;
default:
alert('unknown childElem.localname "' + childElem.localName + '"/' + childElem.outerHTML);
}
}
}
});
return allowed;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditInsert {
/**
* @param {?} pos
* @param {?} value
* @param {?} rootNode
* @param {?} xmlRules
* @param {?} xmlSchema
* @return {?}
*/
static replaceWithText(pos, value, rootNode, xmlRules, xmlSchema) {
if (pos === undefined) {
return false;
}
if (value === '' || value === undefined || value == null) {
return false;
}
if (pos.isEmptySelection() === false) {
if (XmlEditDelete.deleteSelection(pos, rootNode, xmlRules) === false) {
return false;
}
}
return XmlEditInsert.insertText(pos.EndPos, value, rootNode, xmlRules, xmlSchema);
}
/**
* @param {?} pos
* @param {?} value
* @param {?} rootNode
* @param {?} xmlRules
* @param {?} xmlSchema
* @return {?}
*/
static insertText(pos, value, rootNode, xmlRules, xmlSchema) {
if (pos === undefined) {
return false;
}
if (value === '' || value === undefined || value == null) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
/** @type {?} */
let textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);
if (textAllowed === true) {
/** @type {?} */
const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);
pos.ActualNode.parentElement.removeChild(pos.ActualNode);
/** @type {?} */
const nextSibling = DomDummyNodeManager.getNextSibling(newTextNode);
if (nextSibling) {
pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);
}
else {
pos.SetCursor(newTextNode, XMLCursorPositions.CursorBehindNode);
}
return true;
}
else {
return false;
}
case XMLCursorPositions.CursorBehindNode:
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
pos.ActualNode.textContent = pos.ActualNode.textContent + value;
return true;
}
else {
textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);
if (textAllowed === true) {
/** @type {?} */
const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode.nextSibling); // inserts the new node after the actual node
return true;
}
else {
return false;
}
}
case XMLCursorPositions.CursorInFrontOfNode:
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
pos.ActualNode.textContent = value + pos.ActualNode.textContent;
return true;
}
else {
textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);
if (textAllowed === true) {
/** @type {?} */
const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);
return true;
}
else {
return false;
}
}
case XMLCursorPositions.CursorInEmptyNode:
textAllowed = new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(pos);
if (textAllowed === true) {
/** @type {?} */
const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.appendChild(newTextNode);
return true;
}
else {
return false;
}
case XMLCursorPositions.CursorInsideTextNode:
/** @type {?} */
const text = pos.ActualNode.textContent;
pos.ActualNode.textContent = text.substr(0, pos.PosInTextnode) + value + text.substr(pos.PosInTextnode, text.length);
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode + 1);
break;
default:
throw new Error(`String.Format("XmlEditInsert.insert: unknown CursorPos ${pos.getDebugDescription()}`);
}
return true;
}
/**
* @param {?} pos
* @param {?} xmlSchema
* @return {?}
*/
static isTextAllowedInParentNode(pos, xmlSchema) {
/** @type {?} */
const parentNode = pos.ActualNode.parentElement;
/** @type {?} */
const parentCursorPos = pos.clone();
parentCursorPos.SetCursor(parentNode, XMLCursorPositions.CursorInEmptyNode);
return new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(parentCursorPos);
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditorContext {
/**
* @param {?} _document
*/
constructor(_document) {
this._document = _document;
this.actualCursor = new XmlCursor();
this.dummyNodeManager = new DomDummyNodeManager();
this.actualCursorChanged = new Subject();
this.debugService = new XmlEditorDebugger();
}
/**
* @return {?}
*/
ngOnDestroy() {
this.actualCursorChanged.unsubscribe();
}
/**
* @param {?} cursorPos
* @return {?}
*/
setCursorPos(cursorPos) {
this.actualCursor = cursorPos;
this.actualCursorChanged.next(cursorPos);
this.debugService.setActualCursorPos(cursorPos);
}
/**
* @param {?} mouseEvent
* @return {?}
*/
mouseUp(mouseEvent) {
if (window.getSelection) {
/** @type {?} */
let userSelection;
userSelection = window.getSelection();
XmlCursorPosSetter.setFromSelection(this.actualCursor.StartPos, userSelection.anchorNode, userSelection.anchorOffset, this.debugService);
XmlCursorPosSetter.setFromSelection(this.actualCursor.EndPos, userSelection.focusNode, userSelection.focusOffset, this.debugService);
this.setCursorPos(this.actualCursor);
this.actualCursor.sortStartAndEnd();
this.actualCursor.show();
}
else {
throw new Error(`can't get window.getSelection, target=${JSON.stringify(mouseEvent.target)}`);
}
}
/**
* @param {?} event
* @return {?}
*/
keyDown(event) {
console.log('keydown! key:' + event.key + ' / code:' + event.code);
switch (event.key) {
case 'Control':
this.keyCtrlIsDown = true;
break;
case 'Shift':
this.keyShiftIsDown = true;
break;
case 'c':
if (this.keyCtrlIsDown) {
// Copy
return false;
}
else {
if (this.insertText('c')) {
return false;
}
}
break;
case 'ArrowUp':
case 'ArrowDown':
return true;
case 'ArrowRight':
if (this.keyShiftIsDown) {
XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);
}
this.actualCursor.sortStartAndEnd();
this.actualCursor.show();
this.setCursorPos(this.actualCursor);
return false;
case 'ArrowLeft':
if (this.keyShiftIsDown) {
XmlCursorPosMover.moveLeft(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlCursorPosMover.moveLeft(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);
}
this.actualCursor.sortStartAndEnd();
this.actualCursor.show();
this.setCursorPos(this.actualCursor);
return false;
case 'Backspace':
if (this.actualCursor.isEmptySelection()) {
XmlEditDelete.deleteBefore(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
return false;
case 'Delete':
if (this.actualCursor.isEmptySelection()) {
XmlEditDelete.deleteAfter(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
return false;
case 'Enter':
return false;
default:
/** @type {?} */
const textInsert = event.key;
if (this.insertText(textInsert)) {
return false;
}
break;
}
return true;
}
/**
* @param {?} event
* @return {?}
*/
keyUp(event) {
switch (event.key) {
case 'Control':
this.keyCtrlIsDown = false;
break;
case 'Shift':
this.actualCursor.sortStartAndEnd();
this.keyShiftIsDown = false;
break;
case 'ArrowLeft':
case 'ArrowRight':
this.actualCursor.show();
break;
case 'ArrowUp':
case 'ArrowDown':
case 'Backspace':
case 'Delete':
case 'Enter':
case 'Control':
case 'Shift':
break;
}
return true;
}
/**
* @param {?} text
* @return {?}
*/
pasted(text) {
alert('pasted: ' + text);
return false;
}
/**
* @return {?}
*/
copied() {
alert('copied');
return false;
}
/**
* @param {?} value
* @return {?}
*/
insertText(value) {
if (value === '' || value === null || value === undefined) {
return true;
}
/** @type {?} */
let inserted = false;
if (this.actualCursor.isEmptySelection()) {
inserted = XmlEditInsert.insertText(this.actualCursor.EndPos, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);
}
else {
inserted = XmlEditInsert.replaceWithText(this.actualCursor, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);
}
if (inserted) {
// character inserted -> move cursor right
// for (let index = 0; index < value.length; index++) {
// XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
// }
this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
console.warn('text inserted!');
return true;
}
else {
console.warn('text NOT inserted!');
return false;
}
}
/**
* inserts a new element at the actual cursor pos
* @param {?} element
* @return {?}
*/
insertElement(element) {
/** @type {?} */
const html = new Xml2html(this.config.rules).createNewElementHtml(element);
this.domInsertHtml(html);
this.cleanUpAndUpdateDummyElements();
// this.actualCursor.show();
console.warn('element inserted!');
}
/**
* Create raw HTML
* @param {?} html HTML string
* @return {?}
*/
domInsertHtml(html) {
if (document.getSelection) {
/** @type {?} */
const range = document.getSelection().getRangeAt(0);
range.insertNode(range.createContextualFragment(html));
}
else {
throw new Error('document.getSelection not defined!');
}
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
}
/**
* save selection when the editor is focussed out
* @return {?}
*/
saveSelection() {
if (window.getSelection) {
/** @type {?} */
const sel = window.getSelection();
if (sel.getRangeAt && sel.rangeCount) {
this.savedSelection = sel.getRangeAt(0);
this.selectedText = sel.toString();
}
}
else if (this._document.getSelection && this._document.createRange) {
this.savedSelection = document.createRange();
}
else {
this.savedSelection = null;
}
}
/**
* restore selection when the editor is focussed in
* @return {?}
*/
restoreSelection() {
if (this.savedSelection) {
if (window.getSelection) {
/** @type {?} */
const sel = window.getSelection();
sel.removeAllRanges();
sel.addRange(this.savedSelection);
return true;
}
else if (this._document.getSelection /*&& this.savedSelection.select*/) {
// this.savedSelection.select();
return true;
}
}
else {
return false;
}
}
/**
* @return {?}
*/
cleanUpAndUpdateDummyElements() {
this.dummyNodeManager.RemoveAllDummyNodes(this.actualCursor.xmlDocumentRootNode);
XmlDomCleaner.cleanUp(this.actualCursor.xmlDocumentRootNode, this.actualCursor);
this.dummyNodeManager.UpdateDummyNodes(this.actualCursor.xmlDocumentRootNode);
this.actualCursor.sortStartAndEnd();
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* \@dynamic
*/
class AngularXmlEditorService {
/**
* @param {?} _document
*/
constructor(_document) {
this._document = _document;
this.contexts = new Map();
}
/**
* @return {?}
*/
getNewEditorContextId() {
/** @type {?} */
let no = 0;
while (this.contexts.has(no.toString())) {
no++;
}
return no.toString();
}
/**
* @param {?} contextId
* @return {?}
*/
getEditorContext(contextId) {
/** @type {?} */
let context = this.contexts.get(contextId);
if (context === undefined) {
context = new XmlEditorContext(this._document);
this.contexts.set(contextId, context);
}
return context;
}
/**
* @param {?} contextId
* @return {?}
*/
disposeEditorContext(contextId) {
this.contexts.delete(contextId);
}
}
AngularXmlEditorService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
AngularXmlEditorService.ctorParameters = () => [
{ type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
/** @nocollapse */ AngularXmlEditorService.ngInjectableDef = defineInjectable({ factory: function AngularXmlEditorService_Factory() { return new AngularXmlEditorService(inject(DOCUMENT)); }, token: AngularXmlEditorService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class Html2xml {
/**
* @param {?} rules
*/
constructor(rules) {
this.rules = rules;
this.attributeWorker = new Xml2htmlAttributeWorker(rules);
}
/**
* @param {?} html
* @return {?}
*/
ToXml(html) {
if (html === '') {
return '';
}
/** @type {?} */
const cleanHtml = this.CleanUpHtmlBeforeConvert2Xml(html);
/** @type {?} */
const domparser = new DOMParser();
/** @type {?} */
const domdoc = domparser.parseFromString(cleanHtml, 'text/xml');
/** @type {?} */
const targetDocument = new Document();
if (domdoc.documentElement === null) {
return '';
}
/** @type {?} */
const body = this.GetXmlElementFromHtmlElement(domdoc.documentElement, targetDocument);
if (body && body.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const xml = (/** @type {?} */ (body)).outerHTML;
return xml;
}
else {
throw new Error(`root node ${XmlToolbox.GetNodeDebugContext(body)} is no element`);
}
}
/**
* @param {?} html
* @return {?}
*/
CleanUpHtmlBeforeConvert2Xml(html) {
/** @type {?} */
const domparser = new DOMParser();
/** @type {?} */
const domdoc = domparser.parseFromString(html, 'text/html');
new DomDummyNodeManager().RemoveAllDummyNodes(domdoc.documentElement);
/** @type {?} */
const cleanHtml = domdoc.body.innerHTML;
return cleanHtml;
}
/**
* @param {?} node
* @param {?} targetDocument
* @return {?}
*/
GetXmlElementFromHtmlElement(node, targetDocument) {
switch (node.nodeType) {
case Node.ELEMENT_NODE: // element node
/** @type {?} */
const asElement = /** @type {?} */ (node);
/** @type {?} */
const tagName = Xml2html.getTagNameFromNode(node);
if (!tagName || tagName === '') {
throw new Error(`no tagname in ${XmlToolbox.GetNodeDebugContext(node)}`);
}
/** @type {?} */
const newElement = targetDocument.createElement(tagName);
/** @type {?} */
const children = asElement.childNodes;
if (children.length === 0 && !asElement.classList.contains(Xml2html.NoClosingTagClassName)) {
newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags
}
else {
for (let i = 0; i < children.length; ++i) {
/** @type {?} */
const childAsHtml = this.GetXmlElementFromHtmlElement(children[i], targetDocument);
if (childAsHtml !== undefined) {
newElement.appendChild(childAsHtml);
}
}
}
// // insert attributes
this.attributeWorker.writeAllHtmlAttributesToXml(asElement, newElement);
return newElement;
case Node.TEXT_NODE: // text node
/** @type {?} */
const content = (/** @type {?} */ (node)).textContent;
if (content.length > 0) {
return targetDocument.createTextNode(content);
}
else {
return undefined;
}
default:
// tslint:disable-next-line:max-line-length
throw new Error(`unknown html element nodeType ${node.nodeType} in value: ${XmlToolbox.GetNodeDebugContext(node)}`);
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class AngularXmlEditorComponent {
/**
* @param {?} _renderer
* @param {?} editorService
*/
constructor(_renderer, editorService) {
this._renderer = _renderer;
this.editorService = editorService;
this.isDebugMode = false;
this.valueChange = new EventEmitter();
// actualXmlCursor: XmlCursor = new XmlCursor();
this.domDummyNodeManager = new DomDummyNodeManager();
}
/**
* @return {?}
*/
get config() {
if (this.editorContext !== undefined && this.editorContext.config !== undefined) {
return this.editorContext && this.editorContext.config;
}
return undefined;
}
/**
* @param {?} value
* @return {?}
*/
set editorContextId(value) {
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
}
/**
* @param {?} value
* @return {?}
*/
set debugMode(value) {
this.isDebugMode = value;
}
/**
* @return {?}
*/
ngOnChanges() { }
/**
* @return {?}
*/
ngOnDestroy() { }
/**
* @return {?}
*/
onLostFocus() {
this.editorContext.saveSelection(); // save selection on lost focus
if (typeof this.onTouchedFunction === 'function') {
this.onTouchedFunction();
}
return;
}
/**
* @return {?}
*/
onGotFocus() {
this.editorContext.restoreSelection();
this.textArea.nativeElement.focus(); // set focus to the text area
}
/**
* @return {?}
*/
clicked() { }
/**
* @return {?}
*/
mousedown() { }
/**
* @param {?} mouseEvent
* @return {?}
*/
mouseup(mouseEvent) {
return this.editorContext.mouseUp(mouseEvent);
}
/**
* @param {?} text
* @return {?}
*/
pasted(text) {
return this.editorContext.pasted(text);
}
/**
* @return {?}
*/
copied() {
return this.editorContext.copied();
}
/**
* @param {?} event
* @return {?}
*/
keyDown(event) {
return this.editorContext.keyDown(event);
}
/**
* @param {?} event
* @return {?}
*/
keyUp(event) {
return this.editorContext.keyUp(event);
}
/**
* @param {?} xml
* @return {?}
*/
showXml(xml) {
if (this.textArea && this.editorContext && this.editorContext.config && this.editorContext.config.rules) {
if (xml === undefined) {
return;
}
/** @type {?} */
const xml2html = new Xml2html(this.editorContext.config.rules);
/** @type {?} */
const html = xml2html.ToHtml(xml);
/** @type {?} */
const normalizedValue = xml === null ? '' : html;
this._renderer.setProperty(this.textArea.nativeElement, 'innerHTML', normalizedValue);
}
}
/**
* Sets the function called when the control gets a change event
* @param {?} func
* @return {?}
*/
registerOnChange(func) {
this.onChangeFunction = func;
}
/**
* Sets the function called when the control gets a touch event
* @param {?} func
* @return {?}
*/
registerOnTouched(func) {
this.onTouchedFunction = func;
}
/**
* Write the new value to the element
* @param {?} value
* @return {?}
*/
writeValue(value) {
if (this.editorContext && this.editorContext.config) {
if (value === null || value === undefined || value === '') {
value = undefined;
}
this.showXml(value);
if (value === undefined) {
this.editorContext.actualCursor.xmlDocumentRootNode = undefined;
}
else {
/** @type {?} */
const el = /** @type {?} */ (this.textArea.nativeElement);
/** @type {?} */
const node = /** @type {?} */ (el.firstChild);
this.editorContext.actualCursor.xmlDocumentRootNode = node;
this.editorContext.actualCursor.StartPos.SetCursor(this.editorContext.actualCursor.xmlDocumentRootNode, XMLCursorPositions.CursorOnCompleteNode);
this.domDummyNodeManager.UpdateDummyNodes(this.editorContext.actualCursor.xmlDocumentRootNode);
}
}
}
/**
* Executed from the contenteditable section while the input property changes
* @param {?} html html string from contenteditable
* @return {?}
*/
onContentChange(html) {
if (typeof this.onChangeFunction === 'function') {
/** @type {?} */
const html2xml = new Html2xml(this.editorContext.config.rules);
/** @type {?} */
const xml = html2xml.ToXml(html);
/** @type {?} */
const normalizedValue = xml === null ? '' : xml;
this.onChangeFunction(normalizedValue);
}
return;
}
/**
* sets the disabled state for this element
* @param {?} isDisabled
* @return {?}
*/
setDisabledState(isDisabled) {
/** @type {?} */
const div = this.textArea.nativeElement;
/** @type {?} */
const action = isDisabled ? 'addClass' : 'removeClass';
this._renderer[action](div, 'disabled');
}
}
AngularXmlEditorComponent.decorators = [
{ type: Component, args: [{
selector: 'axed-editor',
template: "<div\r\n *ngIf=\"config\"\r\n #editor\r\n class=\"axed axed-textarea showtags debugOff\"\r\n (focus)=\"onGotFocus()\"\r\n [attr.contenteditable]=\"true\"\r\n [style.height]=\"config.height\"\r\n [style.width]=\"config.width\"\r\n (input)=\"onContentChange($event.target.innerHTML)\"\r\n (blur)=\"onLostFocus()\"\r\n (click)=\"clicked()\"\r\n (mousedown)=\"mousedown()\"\r\n (mouseup)=\"mouseup($event)\"\r\n (keyup)=\"keyUp($event)\"\r\n (keydown)=\"keyDown($event)\"\r\n (copy)=\"copied()\"\r\n (paste)=\"pasted($event.clipboardData.getData('text/plain'))\"\r\n></div>\r\n",
encapsulation: ViewEncapsulation.None,
// to prevent the scss to rename the class names and not match the new generated xml dom
providers: [
{
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => AngularXmlEditorComponent),
multi: true
}
],
styles: ["a{cursor:pointer}.axed-textarea{min-height:150px;overflow:auto;margin-top:5px;resize:vertical;outline:0;--font-size:15px;--topBottomTagPadding:2px;--tagIndent:20px;font-size:var(--font-size);font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Oxygen,Ubuntu,Cantarell,'Open Sans','Helvetica Neue',sans-serif}.axed-textarea.showtags{line-height:calc(var(--font-size) + (var(--topBottomTagPadding) * 2) + 10px)}.axed-textarea.showtags div::after,.axed-textarea.showtags div::before{background:orange;white-space:pre-wrap;border:1px solid #778899}.axed-textarea.showtags div::after,.axed-textarea.showtags div:not(.xmlTagNoClosing)::before{content:\" \" attr(data-tagname) \" \";padding:var(--topBottomTagPadding) 0 var(--topBottomTagPadding);margin:0 2px 2px}.axed-textarea.showtags div:not(.xmlTagNoClosing)::after{content:\" \" attr(data-tagname);padding-right:7px;border-radius:10px 0 0 10px}.axed-textarea.showtags div:not(.xmlTagNoClosing)::before{border-radius:0 10px 10px 0}.axed-textarea.showtags div[data-attributes].xmlTagNoClosing:not([data-attributes=''])::after,.axed-textarea.showtags div[data-attributes]:not([data-attributes='']):not(.xmlTagNoClosing)::before{content:\" \" attr(data-tagname) \" \" attr(data-attributes) \" \"}.axed-textarea.showtags div.comment::after,.axed-textarea.showtags div.comment::before{content:' ' 'comment' ' ';background-color:#d3d3d3}.axed-textarea div div:not(.floating){margin-left:var(--tagIndent)}.tagElement>.dummyNode.parent{color:red}div.floating{display:inline}span.dummyNode.beforefirstTag{float:left;width:0}.axed-textarea.debug span.dummyNode{background-color:red;width:inherit}.axed-textarea.debug span.dummyNode.beforefirstTag{background-color:violet;width:inherit}.axed-textarea.showtags div.selected,.axed-textarea.showtags div.selected::after,.axed-textarea.showtags div.selected::before{background:#add8e6!important;color:#fff}[data-tagname=parsererror],[data-tagname=parsererror] div,[data-tagname=parsererror] div ::after,[data-tagname=parsererror] div::before,[data-tagname=parsererror]::after,[data-tagname=parsererror]::before{background:red!important;color:#fff!important;font-weight:700!important;font-size:20px!important;line-height:32px!important}.angular-editor{position:relative}.angular-editor ::ng-deep [contenteditable=true]:empty:before{content:attr(placeholder);display:block;color:#868e96;opacity:1}.angular-editor .axed-wrapper{position:relative}.angular-editor .axed-wrapper .axed-textarea{min-height:5rem;padding:.5rem .8rem 1rem;border:1px solid #ddd;background-color:transparent;overflow-x:hidden;overflow-y:auto;z-index:2;position:relative}.angular-editor .axed-wrapper .axed-textarea.focus,.angular-editor .axed-wrapper .axed-textarea:focus{outline:0}.angular-editor .axed-wrapper .axed-textarea ::ng-deep blockquote{margin-left:1rem;border-left:.2em solid #dfe2e5;padding-left:.5rem}.angular-editor .axed-wrapper ::ng-deep p{margin-bottom:0}.angular-editor .axed-wrapper .axed-placeholder{display:none;position:absolute;top:0;padding:.5rem .8rem 1rem .9rem;z-index:1;color:#6c757d;opacity:.75}.angular-editor .axed-wrapper.show-placeholder .angular-editor-placeholder{display:block}.angular-editor .axed-wrapper.disabled{cursor:not-allowed;opacity:.5;pointer-events:none}.axed-attribute-editor-toolbar{min-height:100px;font:100 .8rem/15px Roboto,Arial,sans-serif;background-color:#f5f5f5;padding:15px;border:1px solid #ddd;margin:0}.axed-attribute-editor-toolbar input,.axed-attribute-editor-toolbar select{width:100%}"]
}] }
];
/** @nocollapse */
AngularXmlEditorComponent.ctorParameters = () => [
{ type: Renderer2 },
{ type: AngularXmlEditorService }
];
AngularXmlEditorComponent.propDecorators = {
config: [{ type: Input, args: ['config',] }],
editorContextId: [{ type: Input, args: ['editorContextId',] }],
debugMode: [{ type: Input, args: ['debugMode',] }],
textArea: [{ type: ViewChild, args: ['editor',] }],
editorWrapper: [{ type: ViewChild, args: ['editorWrapper',] }],
valueChange: [{ type: Output }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlRuleElement {
/**
* @param {?} elements
* @return {?}
*/
static Sorted(elements) {
/** @type {?} */
const result = elements.sort((e1, e2) => {
if (e1.tagName > e2.tagName) {
return 1;
}
if (e1.tagName < e2.tagName) {
return -1;
}
return 0;
});
return result;
}
/**
* @param {?=} init
*/
constructor(init) {
Object.assign(this, init);
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditRuleCheckElements {
/**
* @param {?} xsdNodes
*/
constructor(xsdNodes) {
this.xsdNodes = xsdNodes;
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
ElementsAllowedAtThisCursorPos(cursorPosToCheck) {
if (!cursorPosToCheck) {
return [];
}
/** @type {?} */
const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);
/** @type {?} */
const parentName = Xml2html.getTagNameFromNode(parentNode);
/** @type {?} */
const xsdNode = this.xsdNodes.get(parentName);
if (xsdNode) {
/** @type {?} */
const result = this.getSubElementNames(xsdNode, []);
return result;
}
else {
// console.warn('element "' + parentName + '" not found');
return [];
}
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
getRelevantParentNodeForCursorPos(cursorPosToCheck) {
if (cursorPosToCheck) {
/** @type {?} */
let parentNode = cursorPosToCheck.ActualNode;
switch (parentNode.nodeType) {
case Node.COMMENT_NODE:
case Node.TEXT_NODE:
parentNode = parentNode.parentElement;
break;
case Node.ELEMENT_NODE:
switch (cursorPosToCheck.PosAtNode) {
case XMLCursorPositions.CursorInEmptyNode:
case XMLCursorPositions.CursorInsideTextNode:
break;
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
case XMLCursorPositions.CursorOnCompleteNode:
parentNode = parentNode.parentElement;
break;
default:
throw new Error(`unhandled cursorPosToCheck.PosAmNode "${cursorPosToCheck.PosAtNode}"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}" `);
}
break;
default:
throw new Error(`unhandled parentNode.nodeType "${parentNode.nodeType}"`);
}
return parentNode;
}
}
/**
* @param {?} xsdNode
* @param {?} alreadyAddedElementNames
* @param {?=} depth
* @return {?}
*/
getSubElementNames(xsdNode, alreadyAddedElementNames, depth = 0) {
/** @type {?} */
let elementNames = [];
/** @type {?} */
let elementName;
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const asElem = /** @type {?} */ (xsdNode);
if (asElem) {
if (asElem.localName === 'element') {
elementName = asElem.getAttribute('name');
}
}
}
if (elementName) {
// console.warn('found: ' + JSON.stringify(elementName) + ' depth: ' + depth);
if (alreadyAddedElementNames.length !== 0) {
if (alreadyAddedElementNames.indexOf(elementName) !== -1) {
return elementNames; // element recursion detected
}
if (depth === 0) ;
else {
elementNames = elementNames.concat(elementName);
return elementNames;
}
}
alreadyAddedElementNames.push(elementName);
}
/** @type {?} */
const childNodes = /** @type {?} */ (Array.prototype.slice.call(xsdNode.childNodes));
depth++;
childNodes.forEach(child => {
if (child.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const childElem = /** @type {?} */ (child);
if (childElem) {
switch (childElem.localName) {
case 'complexType':
case 'sequence':
case 'choice':
case 'simpleContent':
case 'extension':
elementNames = elementNames.concat(this.getSubElementNames(child, alreadyAddedElementNames, depth));
break;
case 'element':
/** @type {?} */
const refname = childElem.attributes.getNamedItem('ref');
if (refname) {
/** @type {?} */
const referedNode = this.xsdNodes.get(refname.value);
if (referedNode) {
elementNames = elementNames.concat(this.getSubElementNames(referedNode, alreadyAddedElementNames, depth));
}
else {
throw new Error(` refered element "${refname}" for element "${childElem.outerHTML}" not found`);
}
}
else {
elementNames = elementNames.concat(this.getSubElementNames(child, alreadyAddedElementNames, depth));
}
break;
case 'attribute':
break;
default:
throw new Error(`unknown childElem.localname "${childElem.localName}"/${childElem.outerHTML}`);
}
}
}
});
return elementNames;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditorToolbarComponent {
/**
* @param {?} editorService
*/
constructor(editorService) {
this.editorService = editorService;
this.elementGroups = [];
}
/**
* @return {?}
*/
get config() {
if (this.editorContext !== undefined && this.editorContext.config !== undefined) {
return this.editorContext && this.editorContext.config;
}
return undefined;
}
/**
* @param {?} value
* @return {?}
*/
set editorContextId(value) {
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(pos => {
this.elementGroups = this.GetElementGroupsForCursorPos(pos.StartPos);
});
}
/**
* inserts an element at the actual cursor pos
* @param {?} element
* @return {?}
*/
insertElement(element) {
/** @type {?} */
const html = new Xml2html(this.editorContext.config.rules).createNewElementHtml(element);
this.editorContext.domInsertHtml(html);
}
/**
* @return {?}
*/
ngAfterViewInit() { }
/**
* @return {?}
*/
ngOnChanges() { }
/**
* @return {?}
*/
ngOnDestroy() {
this.actualCursorPosChangedSubscription.unsubscribe();
}
/**
* @param {?} pos
* @return {?}
*/
GetElementGroupsForCursorPos(pos) {
/** @type {?} */
const allowedElements = new XmlEditRuleCheckElements(this.editorContext.config.xmlSchema.xsdNodes).ElementsAllowedAtThisCursorPos(pos);
return this.GetAllElementGroups()
.map(g => {
return /** @type {?} */ ({
title: g.title,
elements: g.elements.filter(e => allowedElements.includes(e.tagName))
});
})
.filter(g => g.elements.length > 0);
}
/**
* @return {?}
*/
GetAllElementGroups() {
/** @type {?} */
const unusedElements = XmlRuleElement.Sorted(Array.from(this.editorContext.config.rules.ruleElements.values()).filter(elem => this.editorContext.config.elementGroups.some(group => !group.elementNames.includes(elem.tagName))));
/** @type {?} */
const otherElementsGroup = /** @type {?} */ ({
title: 'other',
elements: unusedElements
});
return this.editorContext.config.elementGroups
.map(g => {
return /** @type {?} */ ({
title: g.title,
elements: XmlRuleElement.Sorted(g.elementNames.map(elementName => this.editorContext.config.rules.ruleElements.get(elementName)).filter(e => e !== undefined))
});
})
.concat(otherElementsGroup)
.filter(g => g.elements.length !== 0);
}
}
XmlEditorToolbarComponent.decorators = [
{ type: Component, args: [{
selector: 'axed-toolbar',
template: "<div class=\"sws-xml-editor-toolbar\">\r\n <h3>Insert element</h3>\r\n\r\n <!--\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button type=\"button\" title=\"Undo\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('undo')\"><i class='fa fa-undo'></i></button>\r\n <button type=\"button\" title=\"Redo\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('redo')\"><i class='fa fa-repeat'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'bold-'+id\" type=\"button\" title=\"Bold\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('bold')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-bold'></i></button>\r\n <button [id]=\"'italic-'+id\" type=\"button\" title=\"Italic\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('italic')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-italic'></i></button>\r\n <button [id]=\"'underline-'+id\" type=\"button\" title=\"Underline\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('underline')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-underline'></i></button>\r\n <button [id]=\"'strikeThrough-'+id\" type=\"button\" title=\"Strikethrough\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('strikeThrough')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-strikethrough'></i></button>\r\n <button [id]=\"'subscript-'+id\" type=\"button\" title=\"Subscript\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('subscript')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-subscript'></i></button>\r\n <button [id]=\"'superscript-'+id\" type=\"button\" title=\"Superscript\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('superscript')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-superscript'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'justifyLeft-'+id\" type=\"button\" title=\"Justify Left\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('justifyLeft')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-align-left'></i></button>\r\n <button [id]=\"'justifyCenter-'+id\" type=\"button\" title=\"Justify Center\" class=\"angular-editor-button\" (click)=\"triggerCommand('justifyCenter')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-align-center'></i></button>\r\n <button [id]=\"'justifyRight-'+id\" type=\"button\" title=\"Justify Right\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('justifyRight')\"\r\n [disabled]=\"htmlMode\">\r\n <i class='fa fa-align-right'></i></button>\r\n <button [id]=\"'justifyFull-'+id\" type=\"button\" title=\"Justify Full\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('justifyFull')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-align-justify'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'indent-'+id\" type=\"button\" title=\"Indent\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('indent')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-indent'></i></button>\r\n <button [id]=\"'outdent-'+id\" type=\"button\" title=\"Outdent\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('outdent')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-outdent'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'insertUnorderedList-'+id\" type=\"button\" title=\"Unordered List\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('insertUnorderedList')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-list-ul'></i></button>\r\n <button [id]=\"'insertOrderedList-'+id\" type=\"button\" title=\"Ordered List\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('insertOrderedList')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-list-ol'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'heading-'+id\" class=\"block-label\"></label>\r\n <select title=\"Formatting\" [id]=\"'heading-'+id\" class=\"select-heading\" [(ngModel)]=\"block\" (change)=\"triggerCommand(block)\"\r\n [disabled]=\"htmlMode\">\r\n <optgroup label=\"Formatting\"></optgroup>\r\n <option class=\"h1\" value=\"h1\">Heading 1</option>\r\n <option class=\"h2\" value=\"h2\">Heading 2</option>\r\n <option class=\"h3\" value=\"h3\">Heading 3</option>\r\n <option class=\"h4\" value=\"h4\">Heading 4</option>\r\n <option class=\"h5\" value=\"h5\">Heading 5</option>\r\n <option class=\"h6\" value=\"h6\">Heading 6</option>\r\n <option class=\"p\" value=\"p\">Paragraph</option>\r\n <option class=\"pre\" value=\"pre\">Predefined</option>\r\n <option class=\"div\" value=\"div\">Standard</option>\r\n <option class=\"default\" value=\"default\">Default</option>\r\n </select>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'fontSelector-'+id\" class=\"block-label\"></label>\r\n <select title=\"Font Name\" [id]=\"'fontSelector-'+id\" class=\"select-font\" [(ngModel)]=\"fontName\" (change)=\"setFontName(fontName)\"\r\n [disabled]=\"htmlMode\">\r\n <optgroup label=\"Font Name\"></optgroup>\r\n <option class=\"arial\" value=\"Arial\">Arial</option>\r\n <option class=\"calibri\" value=\"Calibri\">Calibri</option>\r\n <option class=\"comic-sans-ms\" value=\"Comic Sans MS\">Comic Sans MS</option>\r\n <option class=\"times-new-roman\" value=\"Times New Roman\">Times New Roman</option>\r\n </select>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'fontSizeSelector-'+id\" class=\"block-label\"></label>\r\n <select title=\"Font Size\" [id]=\"'fontSizeSelector-'+id\" class=\"select-font-size\" [(ngModel)]=\"fontSize\" (change)=\"setFontSize(fontSize)\"\r\n [disabled]=\"htmlMode\">\r\n <optgroup label=\"Font Sizing\"></optgroup>\r\n <option class=\"size1\" value=\"1\">1</option>\r\n <option class=\"size2\" value=\"2\">2</option>\r\n <option class=\"size3\" value=\"3\">3</option>\r\n <option class=\"size4\" value=\"4\">4</option>\r\n <option class=\"size5\" value=\"5\">5</option>\r\n <option class=\"size6\" value=\"6\">6</option>\r\n <option class=\"size7\" value=\"7\">7</option>\r\n </select>\r\n </div>\r\n <div class=\"angular-editor-toolbar-set\">\r\n <input style=\"display: none\" type=\"color\" (change)=\"insertColor(fgInput.value, 'textColor')\" #fgInput>\r\n <button [id]=\"'foregroundColorPicker-'+id\" type=\"button\" class=\"sws-xml-editor-button\" (click)=\"fgInput.click()\"\r\n title=\"Text Color\" [disabled]=\"htmlMode\"><span class=\"color-label foreground\"><i class=\"fa fa-font\"></i></span></button>\r\n <input style=\"display: none\" type=\"color\" (change)=\"insertColor(bgInput.value, 'backgroundColor')\" #bgInput>\r\n <button [id]=\"'backgroundColorPicker-'+id\" type=\"button\" class=\"sws-xml-editor-button\" (click)=\"bgInput.click()\"\r\n title=\"Background Color\" [disabled]=\"htmlMode\"><span class=\"color-label background\"><i class=\"fa fa-font\"></i></span></button>\r\n </div>\r\n <div *ngIf=\"customClasses\" class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'customClassSelector-'+id\" class=\"block-label\"></label>\r\n <select title=\"Custom Style\" [id]=\"'customClassSelector-'+id\" class=\"select-custom-style\" [(ngModel)]=\"customClassId\"\r\n (change)=\"setCustomClass(customClassId)\" [disabled]=\"htmlMode\">\r\n <optgroup label=\"Custom Class\"></optgroup>\r\n <option class=\"\" value=-1>Clear Class</option>\r\n <option *ngFor=\"let item of customClasses; let i = index\" [class]=\"item.class\" [value]=\"i\">{{item.name}}</option>\r\n </select>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'link-'+id\" type=\"button\" class=\"sws-xml-editor-button\" (click)=\"insertUrl()\" title=\"Insert Link\"\r\n [disabled]=\"htmlMode\">\r\n <i class=\"fa fa-link\"></i>\r\n </button>\r\n <button type=\"button\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('unlink')\" title=\"Unlink\" [disabled]=\"htmlMode\">\r\n <i class=\"fa fa-chain-broken\"></i>\r\n </button>\r\n <input style=\"display: none\" type=\"file\" (change)=\"onFileChanged($event)\" #fileInput>\r\n <button type=\"button\" class=\"sws-xml-editor-button\" (click)=\"fileInput.click()\" title=\"Insert Image\" [disabled]=\"htmlMode\"><i\r\n class=\"fa fa-image\"></i></button>\r\n\r\n <button type=\"button\" title=\"Horizontal Line\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('insertElement_STAR')\"\r\n [disabled]=\"htmlMode\"><i class=\"fa fa-minus\"></i> STAR</button>\r\n </div>\r\n -->\r\n\r\n\r\n\r\n <div class=\"sws-xml-editor-toolbar-set\" *ngFor=\"let group of elementGroups\">\r\n <label class=\"sws-editor-toolbar-grouplabel\" *ngIf=\"group.title\">{{ group.title }}:</label>\r\n <button *ngFor=\"let elem of group.elements\" type=\"button\" title=\"{{elem.title}}\" class=\"sws-xml-editor-button\"\r\n (click)=\"insertElement(elem)\">\r\n <span *ngIf=\"elem.iconClass\"><i class=\"{{elem.iconClass}}\"></i> </span>{{ elem.tagName }}\r\n </button>\r\n </div>\r\n\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button type=\"button\" title=\"remove tag\" class=\"sws-xml-editor-button\"><i class=\"fa fa-remove\"></i> remove</button>\r\n </div>\r\n\r\n <!--\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'toggleEditorMode-'+id\" type=\"button\" title=\"HTML Code\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('toggleEditorMode')\"><i\r\n class='fa fa-code'></i></button>\r\n </div>\r\n -->\r\n</div>\r\n",
styles: [".sws-xml-editor-toolbar{display:inline-block}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set{border-radius:5px;background-color:#fff;margin-right:5px;margin-bottom:5px;border:1px solid #ddd;clear:both;float:left;display:block;position:relative}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set .sws-editor-toolbar-grouplabel{display:block;font-weight:700;background-color:transparent;float:left;padding:.5em .5em 0}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set .sws-xml-editor-button{border-radius:5px;background-color:transparent;margin:2px;padding:.6em;min-width:3em;float:left;border:.5px solid #eee}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set .sws-xml-editor-button:hover{cursor:pointer;background-color:#ff8c00;transition:.2s}"]
}] }
];
/** @nocollapse */
XmlEditorToolbarComponent.ctorParameters = () => [
{ type: AngularXmlEditorService }
];
XmlEditorToolbarComponent.propDecorators = {
config: [{ type: Input, args: ['config',] }],
editorContextId: [{ type: Input, args: ['editorContextId',] }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlRuleAttribut {
/**
* @param {?=} init
*/
constructor(init) {
Object.assign(this, init);
this.typ = this.getTyp();
}
/**
* @return {?}
*/
getTyp() {
if (this.fixedValues && this.fixedValues.length > 0) {
return RuleAttributeTypes.Enum;
}
return RuleAttributeTypes.String;
}
}
/** @enum {number} */
const RuleAttributeTypes = {
String: 0,
Enum: 1,
Number: 2,
};
RuleAttributeTypes[RuleAttributeTypes.String] = 'String';
RuleAttributeTypes[RuleAttributeTypes.Enum] = 'Enum';
RuleAttributeTypes[RuleAttributeTypes.Number] = 'Number';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditRuleCheckAttributes {
/**
* @param {?} xmlSchema
*/
constructor(xmlSchema) {
this.xmlSchema = xmlSchema;
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
AttributesAllowedAtThisCursorPos(cursorPosToCheck) {
if (!cursorPosToCheck) {
return [];
}
/** @type {?} */
const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);
/** @type {?} */
const parentName = Xml2html.getTagNameFromNode(parentNode);
return this.getAttributesForElementName(parentName);
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
getRelevantParentNodeForCursorPos(cursorPosToCheck) {
if (cursorPosToCheck) {
/** @type {?} */
let parentNode = cursorPosToCheck.ActualNode;
switch (parentNode.nodeType) {
case Node.COMMENT_NODE:
case Node.TEXT_NODE:
parentNode = parentNode.parentElement;
break;
case Node.ELEMENT_NODE:
switch (cursorPosToCheck.PosAtNode) {
case XMLCursorPositions.CursorInEmptyNode:
case XMLCursorPositions.CursorInsideTextNode:
case XMLCursorPositions.CursorOnCompleteNode:
break;
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
parentNode = parentNode.parentElement;
break;
default:
throw new Error(`unhandled cursorPosToCheck.PosAmNode "${cursorPosToCheck.PosAtNode}"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}" `);
}
break;
default:
throw new Error(`unhandled parentNode.nodeType "${parentNode.nodeType}"`);
}
return parentNode;
}
}
/**
* @param {?} elementName
* @return {?}
*/
getAttributesForElementName(elementName) {
/** @type {?} */
const xsdNode = this.xmlSchema.findXsdNodeForTagName(elementName);
return this.getAttributesForElement(xsdNode, new Set([xsdNode]));
}
/**
* @param {?} xsdNode
* @param {?} alreadyAddedElements
* @return {?}
*/
getAttributesForElement(xsdNode, alreadyAddedElements) {
/** @type {?} */
let attributes = [];
if (xsdNode) {
alreadyAddedElements.add(xsdNode);
/** @type {?} */
const childNodes = Array.prototype.slice.call(xsdNode.childNodes);
childNodes.forEach(child => {
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const childElem = /** @type {?} */ (child);
if (childElem) {
if (child.localName === 'attribute') {
// is attribute
attributes = attributes.concat([
new XmlRuleAttribut({
attribName: childElem.attributes.getNamedItem('name').value,
required: this.isRequiredAttribute(childElem),
xsdRawNode: childElem,
fixedValues: this.getFixedValues(childElem),
defaultValue: this.getDefaultValue(childElem)
})
]);
}
else {
// no attribute
if (!alreadyAddedElements.has(child)) {
/** @type {?} */
const subNodeAttributes = this.getAttributesForElement(child, alreadyAddedElements);
attributes = attributes.concat(subNodeAttributes);
}
}
}
}
});
}
return attributes;
}
/**
* the default value for this attribute
* @param {?} childElem
* @return {?}
*/
getDefaultValue(childElem) {
/** @type {?} */
const attrib = childElem.attributes.getNamedItem('default');
if (attrib !== null) {
return attrib.value;
}
return undefined;
}
/**
* is this attribute required?
* @param {?} childElem
* @return {?}
*/
isRequiredAttribute(childElem) {
/** @type {?} */
const attrib = childElem.attributes.getNamedItem('use');
/** @type {?} */
const value = attrib !== null && attrib.value === 'required';
return value;
}
/**
* get the allowes values for this attribute
* @param {?} xsdNode
* @param {?=} alreadyChecked
* @return {?}
*/
getFixedValues(xsdNode, alreadyChecked = []) {
/** @type {?} */
let values = [];
/** @type {?} */
const childNodes = Array.prototype.slice.call(xsdNode.childNodes);
childNodes.forEach(child => {
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
const childElem = /** @type {?} */ (child);
if (childElem) {
if (child.localName === 'enumeration') {
values = values.concat([childElem.attributes.getNamedItem('value').value]);
}
else {
// no attribute
if (alreadyChecked.indexOf(child) === -1) {
/** @type {?} */
const subNodeAttributes = this.getFixedValues(child, alreadyChecked);
values = values.concat(subNodeAttributes);
}
}
}
}
});
return values;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditorAttributeEditorComponent {
/**
* @param {?} editorService
*/
constructor(editorService) {
this.editorService = editorService;
this.attribTypes = RuleAttributeTypes;
this.attributes = [];
}
/**
* @param {?} value
* @return {?}
*/
set editorContextId(value) {
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(pos => {
this.attributes = this.GetAttributesForCursorPos(pos.StartPos);
this.elementName = this.GetElementNameForCursorPos(pos.StartPos);
});
}
/**
* @return {?}
*/
ngOnInit() { }
/**
* @return {?}
*/
ngOnDestroy() {
this.actualCursorPosChangedSubscription.unsubscribe();
}
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
attributeValueChanged(key, value) {
if (this.actualElement) {
/** @type {?} */
const attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);
attribWorker.writeAttributeToHtml(this.actualElement, key, value);
}
}
/**
* @param {?} pos
* @return {?}
*/
GetElementNameForCursorPos(pos) {
/** @type {?} */
const rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);
/** @type {?} */
const parentNode = /** @type {?} */ (rulesCheck.getRelevantParentNodeForCursorPos(pos));
if (parentNode) {
return Xml2html.getTagNameFromNode(parentNode);
}
return undefined;
}
/**
* @param {?} pos
* @return {?}
*/
GetAttributesForCursorPos(pos) {
/** @type {?} */
const attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);
/** @type {?} */
const rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);
/** @type {?} */
const parentNode = /** @type {?} */ (rulesCheck.getRelevantParentNodeForCursorPos(pos));
this.actualElement = parentNode;
if (parentNode) {
/** @type {?} */
const allowedAttributes = rulesCheck.AttributesAllowedAtThisCursorPos(pos);
return allowedAttributes.map(a => {
return /** @type {?} */ ({
rules: a,
value: attribWorker.getAttributeValueFromHtml(parentNode, a.attribName)
});
});
}
return [];
}
}
XmlEditorAttributeEditorComponent.decorators = [
{ type: Component, args: [{
selector: 'axed-attribute-editor',
template: "<div class=\"sws-attribute-editor-toolbar\" *ngIf=\"elementName\">\r\n\r\n <h3>Attributes</h3>\r\n\r\n <div *ngIf=\"attributes.length > 0; else noAttributes\">\r\n <p>Attributes for <b>{{elementName}}</b> element</p>\r\n <div *ngFor=\"let attrib of attributes\">\r\n <span>{{attrib.rules.attribName}}</span>:<br />\r\n\r\n <input type=\"text\" *ngIf=\"attrib.rules.typ === attribTypes.String\" value=\"{{attrib.value}}\"\r\n (input)=\"attributeValueChanged(attrib.rules.attribName, $event.target.value);\">\r\n\r\n <select *ngIf=\"attrib.rules.typ === attribTypes.Enum\" value=\"{{attrib.value}}\"\r\n (input)=\"attributeValueChanged(attrib.rules.attribName, $event.target.value);\">\r\n <option *ngIf=\"attrib.rules.required === false\"></option>\r\n <option *ngFor=\"let value of attrib.rules.fixedValues\">{{value}}</option>\r\n </select>\r\n\r\n </div>\r\n </div>\r\n\r\n <ng-template #noAttributes>\r\n No attributes to edit for element <b>{{elementName}}</b>\r\n </ng-template>\r\n\r\n</div>\r\n",
styles: [".sws-attribute-editor-toolbar input,.sws-attribute-editor-toolbar select{width:100%;border-radius:5px;background-color:transparent;padding:.6em 0 .4em;margin-bottom:.3em;border:.5px solid #eee}"]
}] }
];
/** @nocollapse */
XmlEditorAttributeEditorComponent.ctorParameters = () => [
{ type: AngularXmlEditorService }
];
XmlEditorAttributeEditorComponent.propDecorators = {
editorContextId: [{ type: Input, args: ['editorContextId',] }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlEditorDebugComponent {
/**
* @param {?} editorService
*/
constructor(editorService) {
this.editorService = editorService;
}
/**
* @param {?} value
* @return {?}
*/
set editorContextId(value) {
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
this.actualCursorPosChangedSubscription = this.editorContext.debugService.actualCursorPosChanged$.subscribe(pos => {
this.cursorPosInfo = pos.StartPos.getDebugDescription();
});
this.inputSelectionSubscription = this.editorContext.debugService.inputSelectionChanged$.subscribe(info => {
this.inputSelection = info;
});
}
/**
* @return {?}
*/
ngOnInit() { }
/**
* @return {?}
*/
ngOnDestroy() {
this.actualCursorPosChangedSubscription.unsubscribe();
this.inputSelectionSubscription.unsubscribe();
}
}
XmlEditorDebugComponent.decorators = [
{ type: Component, args: [{
selector: 'axed-debug',
template: "<div class=\"sws-xml-editor-toolbar\">\r\n\r\n <h3>Debugging</h3>\r\n\r\n <div class=\"block\">\r\n <label>Cursor: </label>\r\n {{cursorPosInfo}}\r\n </div>\r\n\r\n <div class=\"block\">\r\n <label>Selection set: </label>\r\n {{inputSelection}}\r\n </div>\r\n\r\n</div>",
styles: [".sws-xml-editor-toolbar{min-height:50px;font:100 .8rem/15px Roboto,Arial,sans-serif;background-color:#f5f5f5;padding:15px;border:1px solid #ddd}.sws-xml-editor-toolbar .block{background-color:transparent;min-width:2rem;border:solid #ddd;padding-bottom:1em}.sws-xml-editor-toolbar label{font-weight:700}"]
}] }
];
/** @nocollapse */
XmlEditorDebugComponent.ctorParameters = () => [
{ type: AngularXmlEditorService }
];
XmlEditorDebugComponent.propDecorators = {
editorContextId: [{ type: Input, args: ['editorContextId',] }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class DomBreakcrumbComponent {
constructor() {
this.nodes = [];
}
/**
* @return {?}
*/
ngOnInit() { }
/**
* @param {?} selection
* @return {?}
*/
showSelection(selection) {
if (selection === undefined) {
this.nodes = ['none'];
}
else {
/** @type {?} */
const collectNodes = [];
/** @type {?} */
let node = selection.focusNode;
/** @type {?} */
let reachedTop = node === undefined || node === null;
while (!reachedTop) {
switch (node.nodeType) {
case Node.ELEMENT_NODE: // element node
/** @type {?} */
const asElement = /** @type {?} */ (node);
if (asElement !== undefined) {
/** @type {?} */
const name = asElement.getAttribute('data-tagname');
if (asElement.className === 'sws-xml-editor-textarea') {
reachedTop = true;
}
else {
collectNodes.unshift(name);
}
}
}
node = node.parentElement;
if (node === undefined || node == null) {
reachedTop = true;
}
}
this.nodes = collectNodes;
}
}
}
DomBreakcrumbComponent.decorators = [
{ type: Component, args: [{
selector: 'axed-dom-breakcrumb',
template: "<ul>\r\n <li *ngFor=\"let element of nodes\">\r\n {{ element }}\r\n </li>\r\n</ul>\r\n",
styles: ["ul{list-style-type:none;margin:0;padding:0}ul li{display:inline-block;zoom:1;padding-right:10px}ul li::before{content:'>';color:#d3d3d3}"]
}] }
];
/** @nocollapse */
DomBreakcrumbComponent.ctorParameters = () => [];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class AngularXmlEditorModule {
}
AngularXmlEditorModule.decorators = [
{ type: NgModule, args: [{
imports: [CommonModule, FormsModule, ReactiveFormsModule],
declarations: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent],
exports: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent]
},] }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlSchema {
/**
* @param {?} xsdNodes
*/
constructor(xsdNodes) {
this.xsdNodes = xsdNodes;
}
/**
* @param {?} tagName
* @return {?}
*/
findXsdNodeForTagName(tagName) {
return this.xsdNodes.get(tagName);
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlSchemaLoader {
/**
* @param {?} schemaContent
*/
constructor(schemaContent) {
if (!schemaContent || schemaContent === '') {
return;
}
/** @type {?} */
const domparser = new DOMParser();
/** @type {?} */
const schemaDom = domparser.parseFromString(schemaContent, 'text/xml');
/** @type {?} */
let result = [];
/** @type {?} */
const rawElementsAtRoot = /** @type {?} */ (Array.from(schemaDom.documentElement.childNodes));
rawElementsAtRoot.forEach(e => {
/** @type {?} */
const subChilds = this.getRawElements(e);
result = result.concat(subChilds);
});
this.xmlSchema = new XmlSchema(this.getXsdNodes(/** @type {?} */ (result)));
}
/**
* @param {?} node
* @return {?}
*/
getRawElements(node) {
/** @type {?} */
let result = [];
if (this.isValidXsdNode(node)) {
result = result.concat(node);
}
/** @type {?} */
const children = /** @type {?} */ (Array.from(node.childNodes));
children.forEach(child => {
result = result.concat(this.getRawElements(child));
});
return result;
}
/**
* @param {?} node
* @return {?}
*/
isValidXsdNode(node) {
/** @type {?} */
const allowedXsdTypes = ['element', 'group', 'complexType'];
/** @type {?} */
const asElem = /** @type {?} */ (node);
if (asElem) {
if (allowedXsdTypes.includes(asElem.localName)) {
if (asElem.attributes.getNamedItem('name')) {
// console.warn(asElem.attributes.getNamedItem('name').value);
return true;
}
else {
return false;
}
}
else {
return false;
}
}
else {
return false;
}
}
/**
* @param {?} rawElements
* @return {?}
*/
getXsdNodes(rawElements) {
// console.warn(rawElements.length);
return new Map(rawElements.map(n => [n.attributes.getNamedItem('name').value, /** @type {?} */ (n)]));
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlRules {
/**
* @param {?} ruleElements
*/
constructor(ruleElements) {
this.ruleElements = ruleElements;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class XmlRulesCreator {
/**
* @param {?} schema
* @param {?} _floatingElementNames
*/
constructor(schema, _floatingElementNames) {
this.schema = schema;
this._floatingElementNames = _floatingElementNames;
this.rules = new XmlRules(this.getAllElementRuleNodes(Array.from(this.schema.xsdNodes.values())));
}
/**
* @param {?} node
* @return {?}
*/
findXsdNodeForHtmlNode(node) {
/** @type {?} */
const tagName = Xml2html.getTagNameFromNode(node);
return this.schema.xsdNodes.get(tagName);
}
/**
* @param {?} xsdNodes
* @return {?}
*/
getAllElementRuleNodes(xsdNodes) {
return new Map(xsdNodes.map(xsdNode => [xsdNode.attributes.getNamedItem('name').value, this.getRuleElementForXsdNode(xsdNode)]));
}
/**
* @param {?} xsdNode
* @return {?}
*/
getRuleElementForXsdNode(xsdNode) {
if (xsdNode) {
/** @type {?} */
const tagName = xsdNode.attributes.getNamedItem('name').value;
return new XmlRuleElement({
tagName: tagName,
floating: this.isFloating(tagName),
empty: this.isEmpty(xsdNode)
});
}
else {
return undefined;
}
}
/**
* @param {?} xsdNode
* @return {?}
*/
isEmpty(xsdNode) {
if (new XmlEditRuleCheckTextInsert(this.schema.xsdNodes).isTextAllowedInThisElement(xsdNode) === true) {
return false;
}
return true;
}
/**
* @param {?} tagName
* @return {?}
*/
isFloating(tagName) {
return this._floatingElementNames.includes(tagName);
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
export { AngularXmlEditorService, AngularXmlEditorComponent, AngularXmlEditorModule, XmlSchemaLoader, XmlRulesCreator, XmlEditorContext, XmlSchema as ɵe, DomBreakcrumbComponent as ɵd, XmlEditorAttributeEditorComponent as ɵb, XmlEditorDebugComponent as ɵc, XmlEditorToolbarComponent as ɵa };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"angular-xml-editor.js.map","sources":["ng://angular-xml-editor/lib/code/xmlEditorDebugger.ts","ng://angular-xml-editor/lib/code/xmlToolbox.class.ts","ng://angular-xml-editor/lib/code/xml-html-converter/xml2htmlAttributeWorker.class.ts","ng://angular-xml-editor/lib/code/xml-html-converter/xml2html.class.ts","ng://angular-xml-editor/lib/code/dummyNodes/domDummyNodeManager.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursorPos.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursorPosMover.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursor.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursorPosSetter.class.ts","ng://angular-xml-editor/lib/code/xml-editing/xmlDomCleaner.class.ts","ng://angular-xml-editor/lib/code/xml-editing/xmlEditDeleteclass.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlEditRuleCheckTextInsert.class.ts","ng://angular-xml-editor/lib/code/xml-editing/xmlEditInsert.class.ts","ng://angular-xml-editor/lib/code/xmlEditorContext.class.ts","ng://angular-xml-editor/lib/angular-xml-editor.service.ts","ng://angular-xml-editor/lib/code/xml-html-converter/html2xml.class.ts","ng://angular-xml-editor/lib/angular-xml-editor.component.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRuleElement.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlEditRuleCheckElements.class.ts","ng://angular-xml-editor/lib/components/xml-editor-toolbar/xml-editor-toolbar.component.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRuleAttribut.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlEditRuleCheckAttributes.class.ts","ng://angular-xml-editor/lib/components/xml-editor-attribute-editor/xml-editor-attribute-editor.component.ts","ng://angular-xml-editor/lib/components/xml-editor-debug/xml-editor-debug.component.ts","ng://angular-xml-editor/lib/components/dom-breakcrumb/dom-breakcrumb.component.ts","ng://angular-xml-editor/lib/angular-xml-editor.module.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlSchema.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/XmlSchemaLoader.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRules.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRulesCreator.class.ts"],"sourcesContent":["import { OnDestroy } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { XmlCursor } from './cursor/xmlCursor.class';\r\n\r\n// @Injectable({\r\n//   providedIn: 'root'\r\n// })\r\nexport class XmlEditorDebugger implements OnDestroy {\r\n  public actualCursorPosChanged$ = new Subject<XmlCursor>();\r\n  public inputSelectionChanged$ = new Subject<string>();\r\n\r\n  constructor() {}\r\n\r\n  setActualCursorPos(pos: XmlCursor) {\r\n    this.actualCursorPosChanged$.next(pos);\r\n  }\r\n\r\n  setInputSelection(info: string) {\r\n    this.inputSelectionChanged$.next(info);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChanged$.complete();\r\n    this.inputSelectionChanged$.complete();\r\n  }\r\n}\r\n","export class XmlToolbox {\r\n  /// <summary>\r\n  /// Ist dieser Node ein als Text bearbeitbarer Node\r\n  /// </summary>\r\n  /// <param name=\"node\"></param>\r\n  /// <returns></returns>\r\n  public static IsTextOrCommentNode(node: Node): boolean {\r\n    switch (node.nodeType) {\r\n      case Node.TEXT_NODE: // text node\r\n      case Node.COMMENT_NODE:\r\n        return true;\r\n      default:\r\n        return false;\r\n    }\r\n    // return ((node.nodeType === System.Xml.XmlText) || (node.nodeType === System.Xml.XmlComment));\r\n  }\r\n\r\n  // Gets the info to identify a node for exception or debug purposes\r\n  public static GetNodeDebugContext(node: Node): string {\r\n    if (node === null || node === undefined) {\r\n      return 'NULL';\r\n    }\r\n\r\n    if (node.nodeType === Node.TEXT_NODE) {\r\n      if (node.textContent === ' ' || node.textContent === String.fromCharCode(160)) {\r\n        return `TextContent!Parent=${XmlToolbox.GetNodeDebugContext(node.parentNode)}`;\r\n      } else {\r\n        return `TextContent='${node.textContent}'`;\r\n      }\r\n    }\r\n\r\n    const asElem = node as Element;\r\n    if (asElem === undefined) {\r\n      return `localName: ${node.nodeName}, nodeType:${node.nodeType}`;\r\n    } else {\r\n      return asElem.outerHTML;\r\n    }\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\n\r\nexport class Xml2htmlAttributeWorker {\r\n  public static DataAttribPraefix = 'data-attribute-';\r\n\r\n  constructor(public rules: XmlRules) {}\r\n\r\n  /** writes the given attributes to the html node in data-attribute-syntax **/\r\n  writeAllXmlAttributesToHtml(xmlElement: Element, htmlElement: Element) {\r\n    const attributes = xmlElement.attributes;\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      const attr = attributes[i];\r\n      this.writeAttributeToHtml(htmlElement, attr.name, attr.value);\r\n    }\r\n  }\r\n\r\n  /** writes the given attribute value to the html node in data-attribute-syntax **/\r\n  writeAttributeToHtml(htmlElement: Element, key: string, value: string) {\r\n    const name = `${Xml2htmlAttributeWorker.DataAttribPraefix}${key}`;\r\n    if (value && value.length > 0) {\r\n      htmlElement.setAttribute(name, value);\r\n    } else {\r\n      htmlElement.removeAttribute(name);\r\n    }\r\n    this.updateAttributesDescriptionInHtmlElement(htmlElement);\r\n  }\r\n\r\n  /** writes the given attribute value from the html node data-attribute-syntax **/\r\n  getAttributeValueFromHtml(htmlElement: Element, key: string): string {\r\n    const attributes = htmlElement.attributes;\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      if (attributes[i].name === `${Xml2htmlAttributeWorker.DataAttribPraefix}${key}`) {\r\n        return attributes[i].value;\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /** writes the given attribute value to the xml node (and gets it from the html node from data-attribute-syntax) **/\r\n  writeAllHtmlAttributesToXml(htmlElement: Element, xmlElement: Element) {\r\n    const attributes = htmlElement.attributes;\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      const attr = attributes[i];\r\n      if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {\r\n        xmlElement.setAttribute(attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length), attr.value);\r\n      }\r\n    }\r\n  }\r\n\r\n  /** updates the 'for human eyes' only description of the attributes inside a html node **/\r\n  private updateAttributesDescriptionInHtmlElement(htmlElement: Element) {\r\n    const attributes = htmlElement.attributes;\r\n    let allAttributes = '';\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      const attr = attributes[i];\r\n      if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {\r\n        allAttributes = `${allAttributes} ${attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length)}=\"${attr.value}\"`;\r\n      }\r\n    }\r\n    if (allAttributes.length > 0) {\r\n      htmlElement.setAttribute('data-attributes', allAttributes);\r\n    } else {\r\n      htmlElement.removeAttribute('data-attributes');\r\n    }\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { Xml2htmlAttributeWorker } from './xml2htmlAttributeWorker.class';\r\nimport { XmlRuleElement } from '../xml-rules-check/xmlRuleElement.class';\r\n\r\nexport class Xml2html {\r\n  private static DataTagName = 'data-tagname';\r\n  public static NoClosingTagClassName = 'xmlTagNoClosing';\r\n  public static FloatingTagClassName = 'floating';\r\n  public static CommentTagClassName = 'comment';\r\n\r\n  private attributeWorker: Xml2htmlAttributeWorker;\r\n\r\n  constructor(public rules: XmlRules) {\r\n    this.attributeWorker = new Xml2htmlAttributeWorker(rules);\r\n  }\r\n\r\n  static getTagNameFromNode(node: Node): string {\r\n    const elem = node as Element;\r\n    let name = '';\r\n    if (elem) {\r\n      name = elem.getAttribute(Xml2html.DataTagName);\r\n    }\r\n    if (name === undefined || name === null || name === '') {\r\n      throw new Error(`node has no DataTagName attribute ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n    }\r\n    return name;\r\n  }\r\n\r\n  static isFloatingElement(node: Node): boolean {\r\n    const elem = node as Element;\r\n    if (elem && elem.classList) {\r\n      return elem.classList.contains(Xml2html.FloatingTagClassName);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  static isNoClosingElement(node: Node): boolean {\r\n    const elem = node as Element;\r\n    if (elem && elem.classList) {\r\n      return elem.classList.contains(Xml2html.NoClosingTagClassName);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  public ToHtml(xml: string): string {\r\n    if (xml === '' || xml === undefined || xml === null) {\r\n      return '';\r\n    }\r\n\r\n    // alert(xml);\r\n\r\n    // remove newline / carriage return\r\n    xml = xml.replace(/\\n/g, '');\r\n    xml = xml.replace(/\\r/g, '');\r\n    // remove whitespace (tabs) before tags\r\n    xml = xml.replace(/[\\t]+\\</g, '<');\r\n    // remove whitespace between tags\r\n    xml = xml.replace(/\\>[\\t]+\\</g, '><');\r\n    // remove whitespace after tags\r\n    xml = xml.replace(/\\>[\\t]+$/g, '>');\r\n\r\n    const domparser = new DOMParser();\r\n    const domdoc = domparser.parseFromString(xml, 'text/xml');\r\n\r\n    const targetDocument = new Document();\r\n\r\n    if (domdoc.documentElement === null) {\r\n      return '';\r\n    }\r\n\r\n    const body = this.GetHtmlElementFromXmlElement(domdoc.documentElement, targetDocument);\r\n    if (body && body.nodeType === Node.ELEMENT_NODE) {\r\n      const html = (body as Element).outerHTML;\r\n      return html;\r\n    } else {\r\n      throw new Error(`root node ${XmlToolbox.GetNodeDebugContext(body)} is no element`);\r\n    }\r\n  }\r\n\r\n  createNewElementHtml(ruleElem: XmlRuleElement): string {\r\n    const elem = this.createNewElementByName(ruleElem.tagName);\r\n    return elem.outerHTML;\r\n  }\r\n\r\n  public createNewElementByName(tagName: string): Element {\r\n    const tempDoc = new Document();\r\n    const newElement = tempDoc.createElement('div');\r\n    // floating element or not?\r\n    const rule = this.rules.ruleElements.get(tagName);\r\n    if (rule && rule.floating === true) {\r\n      newElement.classList.add(Xml2html.FloatingTagClassName);\r\n    }\r\n    // visualize closing tag or not?\r\n    if (rule && rule.empty === true) {\r\n      newElement.classList.add(Xml2html.NoClosingTagClassName);\r\n    }\r\n    newElement.setAttribute(Xml2html.DataTagName, tagName);\r\n    return newElement;\r\n  }\r\n\r\n  private GetHtmlElementFromXmlElement(node: Node, targetDocument: Document): Node {\r\n    switch (node.nodeType) {\r\n      case Node.ELEMENT_NODE: // element node\r\n        const asElement = node as Element;\r\n        const nodeName = asElement.nodeName;\r\n\r\n        // create element node\r\n        let newElement = targetDocument.createElement('div');\r\n\r\n        // floating element or not?\r\n        const rule = this.rules.ruleElements.get(nodeName);\r\n        if (rule && rule.floating) {\r\n          newElement.classList.add(Xml2html.FloatingTagClassName);\r\n        }\r\n        // visualize closing tag or not?\r\n        if (rule && rule.empty) {\r\n          newElement.classList.add(Xml2html.NoClosingTagClassName);\r\n        }\r\n        newElement.setAttribute(Xml2html.DataTagName, nodeName);\r\n\r\n        // append child elements recursive\r\n        const children = asElement.childNodes;\r\n        if (children.length === 0) {\r\n          newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags\r\n        } else {\r\n          for (let i = 0; i < children.length; ++i) {\r\n            const childAsHtml = this.GetHtmlElementFromXmlElement(children[i], targetDocument);\r\n            if (childAsHtml !== undefined) {\r\n              newElement.appendChild(childAsHtml);\r\n            }\r\n          }\r\n        }\r\n\r\n        // insert attributes\r\n        this.attributeWorker.writeAllXmlAttributesToHtml(asElement, newElement);\r\n\r\n        return newElement;\r\n\r\n      case Node.TEXT_NODE: // text node\r\n        const content = (node as Element).textContent;\r\n        if (content.length > 0) {\r\n          return targetDocument.createTextNode(content);\r\n        } else {\r\n          return undefined;\r\n        }\r\n\r\n      case Node.COMMENT_NODE:\r\n        // create element node\r\n        newElement = targetDocument.createElement('div');\r\n        newElement.classList.add(Xml2html.CommentTagClassName);\r\n        newElement.setAttribute(Xml2html.DataTagName, 'comment');\r\n        newElement.textContent = (node as Element).textContent;\r\n        return newElement;\r\n\r\n      /* yet not implemented types */\r\n      case Node.PROCESSING_INSTRUCTION_NODE:\r\n        console.warn(`nodeType \"PROCESSING_INSTRUCTION_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n        return undefined;\r\n\r\n      case Node.DOCUMENT_NODE:\r\n        throw new Error(`nodeType \"Node.DOCUMENT_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n      case Node.DOCUMENT_TYPE_NODE:\r\n        throw new Error(`nodeType \"Node.DOCUMENT_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n      case Node.DOCUMENT_FRAGMENT_NODE:\r\n        throw new Error(`nodeType \"Node.DOCUMENT_FRAGMENT_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n\r\n      /* Depreached node types */\r\n      case Node.ATTRIBUTE_NODE:\r\n        throw new Error(`nodeType \"Node.ATTRIBUTE_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.CDATA_SECTION_NODE:\r\n        throw new Error(`nodeType \"Node.CDATA_SECTION_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.ENTITY_REFERENCE_NODE:\r\n        throw new Error(`nodeType \"Node.ENTITY_REFERENCE_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.ENTITY_NODE:\r\n        throw new Error(`nodeType \"Node.ENTITY_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.NOTATION_NODE:\r\n        throw new Error(`nodeType \"Node.NOTATION_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n\r\n      default:\r\n        // tslint:disable-next-line:max-line-length\r\n        throw new Error(`unknown xmlElement nodeType ${node.nodeType} in value: ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n    }\r\n  }\r\n}\r\n","import { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class DomDummyNodeManager {\r\n  public static DummyNodeClassName = 'dummyNode';\r\n  public static DummyNodeBeforeFirstTagClassName = 'beforefirstTag';\r\n  public static DummyNodeContent = String.fromCharCode(160);\r\n\r\n  constructor() {}\r\n\r\n  public static IsDummyNode(node: Node) {\r\n    const asElem = node as Element;\r\n    if (asElem && node.nodeType === Node.ELEMENT_NODE) {\r\n      return asElem.classList.contains(DomDummyNodeManager.DummyNodeClassName);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  public static IsBeforeFirstTagDummyNode(node: Node) {\r\n    if (DomDummyNodeManager.IsDummyNode(node)) {\r\n      const asElem = node as Element;\r\n      if (asElem && node.nodeType === Node.ELEMENT_NODE) {\r\n        return asElem.classList.contains(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);\r\n      }\r\n      return false;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  // get previos sibling - except dummy nodes\r\n  public static getPreviousSibling(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    while (node) {\r\n      node = node.previousSibling;\r\n      if (node) {\r\n        if (DomDummyNodeManager.IsDummyNode(node)) {\r\n        } else {\r\n          return node;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  // get next sibling - except dummy nodes\r\n  public static getNextSibling(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    while (node) {\r\n      node = node.nextSibling;\r\n      if (node) {\r\n        if (DomDummyNodeManager.IsDummyNode(node)) {\r\n        } else {\r\n          return node;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  // get children count - except dummy nodes\r\n  public static getChildNodeCount(node: Node): number {\r\n    if (!node) {\r\n      return 0;\r\n    }\r\n    let count = 0;\r\n    for (let i = 0; i < node.childNodes.length; i++) {\r\n      if (!DomDummyNodeManager.IsDummyNode(node.childNodes[i])) {\r\n        count++;\r\n      }\r\n    }\r\n    return count;\r\n  }\r\n\r\n  // get first child - except dummy nodes\r\n  public static getFirstChild(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    let first = node.firstChild as Node;\r\n    while (DomDummyNodeManager.IsDummyNode(first)) {\r\n      first = first.nextSibling;\r\n    }\r\n    return first;\r\n  }\r\n\r\n  // get last child - except dummy nodes\r\n  public static getLastChild(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    let last = node.lastChild as Node;\r\n    while (DomDummyNodeManager.IsDummyNode(last)) {\r\n      last = last.previousSibling;\r\n    }\r\n    return last;\r\n  }\r\n\r\n  RemoveAllDummyNodes(node: Node, nodeDepth = 0): void {\r\n    let children: Node[] = [];\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      children.push(node.childNodes[i]);\r\n    }\r\n\r\n    // delete all dummy node children\r\n    children.forEach(child => {\r\n      if (DomDummyNodeManager.IsDummyNode(child)) {\r\n        node.removeChild(child);\r\n      }\r\n    });\r\n\r\n    children = [];\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      children.push(node.childNodes[i]);\r\n    }\r\n\r\n    // update child nodes\r\n    children.forEach(child => {\r\n      this.RemoveAllDummyNodes(child, nodeDepth + 1);\r\n    });\r\n  }\r\n\r\n  UpdateDummyNodes(node: Node, nodeDepth = 0) {\r\n    const document = node.ownerDocument;\r\n    const asElement = node as Element;\r\n\r\n    const children: Node[] = [];\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      children.push(node.childNodes[i]);\r\n    }\r\n\r\n    if (asElement && !DomDummyNodeManager.IsDummyNode(asElement) && !DomDummyNodeManager.IsDummyNode(asElement.parentElement)) {\r\n      if (asElement.nodeType === Node.TEXT_NODE) {\r\n        const before = asElement.previousSibling;\r\n        if (before.nodeType === Node.TEXT_NODE) {\r\n          // textnode after text node: dont insert dummy node!\r\n        } else {\r\n          if (!DomDummyNodeManager.IsDummyNode(before)) {\r\n            asElement.parentNode.insertBefore(this.createDummyNode(document), asElement);\r\n          }\r\n        }\r\n      }\r\n\r\n      if (asElement.nodeType === Node.ELEMENT_NODE) {\r\n        let firstChild = node.firstChild;\r\n        if (!firstChild) {\r\n          // create dummy node in empty tag\r\n          node.appendChild(this.createDummyNode(document));\r\n          firstChild = node.firstChild;\r\n        }\r\n\r\n        if (Xml2html.isNoClosingElement(node)) {\r\n        } else {\r\n          firstChild = node.firstChild;\r\n\r\n          if (!firstChild) {\r\n            // create dummy node in empty tag\r\n            node.appendChild(this.createDummyNode(document));\r\n            firstChild = node.firstChild;\r\n          }\r\n\r\n          // Insert a dummy node before the first child\r\n          if (!DomDummyNodeManager.IsDummyNode(firstChild)) {\r\n            if (firstChild) {\r\n              node.insertBefore(this.createDummyNode(document), firstChild);\r\n              firstChild = node.firstChild;\r\n            } else {\r\n              node.appendChild(this.createDummyNode(document));\r\n            }\r\n          }\r\n\r\n          // Insert a dummy node after the last child\r\n          let lastChild = node.lastChild;\r\n          if (!DomDummyNodeManager.IsDummyNode(lastChild)) {\r\n            node.appendChild(this.createDummyNode(document));\r\n            lastChild = node.lastChild;\r\n          }\r\n\r\n          // Insert a dummy node before the first (dummy child) but optical in front of the node (to show the cursor in front of the node)\r\n          if (nodeDepth > 0) {\r\n            if (DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n              const dummyNode = this.createDummyNode(document);\r\n              dummyNode.classList.add(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);\r\n              asElement.insertBefore(dummyNode, firstChild);\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // update child nodes\r\n    children.forEach(child => {\r\n      this.UpdateDummyNodes(child, nodeDepth + 1);\r\n    });\r\n  }\r\n\r\n  public createDummyNode(targetDocument: Document, content?: string): Element {\r\n    const dummyNode = targetDocument.createElement('span');\r\n    let dummy2TextNode;\r\n    if (content === undefined) {\r\n      dummy2TextNode = targetDocument.createTextNode(DomDummyNodeManager.DummyNodeContent);\r\n    } else {\r\n      dummy2TextNode = targetDocument.createTextNode(content);\r\n    }\r\n    dummyNode.classList.add(DomDummyNodeManager.DummyNodeClassName);\r\n    dummyNode.appendChild(dummy2TextNode);\r\n    return dummyNode;\r\n  }\r\n}\r\n","import { XmlToolbox } from '../xmlToolbox.class';\r\nimport { SelectionPos } from './xmlCursor.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlCursorPos {\r\n  public ActualNode: Node; // this XMLNode actual has the editor focus\r\n  public PosAtNode: XMLCursorPositions; // At this position the cursor is - inside oder outside the actual focussed node\r\n  public PosInTextnode: number; // The cursor positio inside floating text when pos  is CursorInnerhalbDesTextNodes\r\n\r\n  static getXmlCursorPositionDebugName(position: XMLCursorPositions): string {\r\n    switch (position) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        return 'CursorOnCompleteNode';\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        return 'CursorBehindNode';\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        return 'CursorInEmptyNode';\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        return 'CursorInsideTextNode';\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        return 'CursorInFrontOfNode';\r\n      default:\r\n        return `unknown cursorPos ${position}`;\r\n    }\r\n  }\r\n\r\n  static getSelectionForPos(pos: XmlCursorPos): SelectionPos {\r\n    if (DomDummyNodeManager.IsDummyNode(pos.ActualNode)) {\r\n      throw new Error(`XmlCursorPos.getSelectionForPos: pos.AktNode ${pos.getDebugDescription()} is a dummy node!`);\r\n    }\r\n\r\n    if (DomDummyNodeManager.IsDummyNode(pos.ActualNode.parentElement)) {\r\n      throw new Error(`XmlCursorPos.getSelectionForPos: pos.AktNode.parentElement ${pos.getDebugDescription()} is a dummy node!`);\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode: // (0)\r\n        let firstChild = pos.ActualNode.firstChild;\r\n        if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n          return {\r\n            node: firstChild.firstChild, // text inside BeforeFirstTagDummyNod\r\n            offset: 0\r\n          };\r\n        } else {\r\n          return {\r\n            node: pos.ActualNode,\r\n            offset: 0\r\n          };\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode: // (1)\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          // text node\r\n          const dummyBefore = pos.ActualNode.previousSibling;\r\n          if (DomDummyNodeManager.IsDummyNode(dummyBefore)) {\r\n            return {\r\n              node: dummyBefore.firstChild, // before text node\r\n              offset: 1\r\n            };\r\n          } else {\r\n            throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):text node: is no dummy node:  ' + pos.getDebugDescription());\r\n          }\r\n        } else {\r\n          // no text node\r\n          firstChild = pos.ActualNode.firstChild;\r\n          if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n            return {\r\n              node: firstChild.firstChild, // text inside BeforeFirstTagDummyNod\r\n              offset: 1\r\n            };\r\n          }\r\n          if (Xml2html.isNoClosingElement(pos.ActualNode) && DomDummyNodeManager.IsDummyNode(firstChild)) {\r\n            return { node: firstChild.firstChild, offset: 1 };\r\n          }\r\n          throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):no text node: dont know what to do! ');\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode: // (7, 11)\r\n        const dummyAfter = pos.ActualNode.nextSibling;\r\n        if (DomDummyNodeManager.IsDummyNode(dummyAfter)) {\r\n          return {\r\n            node: dummyAfter.firstChild, // before text node\r\n            offset: 0\r\n          };\r\n        } else {\r\n          throw new Error(`XMLCursorPositionen.CursorBehindNode should only be set, when the element has no next sibling.`);\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        const lastChild = pos.ActualNode.lastChild;\r\n        if (!DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n          return {\r\n            node: lastChild.firstChild, // text inside DummyNode\r\n            offset: 0\r\n          };\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        return {\r\n          node: pos.ActualNode,\r\n          offset: pos.PosInTextnode\r\n        };\r\n    }\r\n    throw new Error(`showCursor.getSelectionForPos unknown CursorPos ${pos.getDebugDescription()}`);\r\n  }\r\n\r\n  constructor() {\r\n    this.ActualNode = null; // no node selected\r\n    this.PosAtNode = XMLCursorPositions.CursorOnCompleteNode;\r\n    this.PosInTextnode = 0;\r\n  }\r\n\r\n  clone(): XmlCursorPos {\r\n    const klon = new XmlCursorPos();\r\n    klon.SetCursor(this.ActualNode, this.PosAtNode, this.PosInTextnode);\r\n    return klon;\r\n  }\r\n\r\n  equals(otherPos: XmlCursorPos): boolean {\r\n    if (!otherPos) {\r\n      return false;\r\n    }\r\n    if (otherPos.ActualNode !== this.ActualNode) {\r\n      return false;\r\n    }\r\n    if (otherPos.PosAtNode !== this.PosAtNode) {\r\n      return false;\r\n    }\r\n    if (this.PosAtNode === XMLCursorPositions.CursorInsideTextNode && this.PosInTextnode !== otherPos.PosInTextnode) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  getDebugDescription(): string {\r\n    return `node:${XmlToolbox.GetNodeDebugContext(this.ActualNode)}, pos:${XmlCursorPos.getXmlCursorPositionDebugName(this.PosAtNode)}, posInText:${this.PosInTextnode}`;\r\n  }\r\n\r\n  SetCursor(actualNode: Node, posAtNode: XMLCursorPositions, posInTextnode: number = 0) {\r\n    if (!actualNode) {\r\n      throw new Error('actualNode is null');\r\n    }\r\n\r\n    let changed: boolean;\r\n    if (actualNode !== this.ActualNode) {\r\n      changed = true;\r\n    } else {\r\n      if (posAtNode !== this.PosAtNode) {\r\n        changed = true;\r\n      } else {\r\n        if (posInTextnode !== this.PosInTextnode) {\r\n          changed = true;\r\n        } else {\r\n          changed = false;\r\n        }\r\n      }\r\n    }\r\n\r\n    this.ActualNode = actualNode;\r\n    this.PosAtNode = posAtNode;\r\n    this.PosInTextnode = posInTextnode;\r\n\r\n    // console.log(`SetCursor: ${this.getDebugDescription()}`);\r\n\r\n    if (changed) {\r\n      // PosChanged(EventArgs.Empty); // inform you that the cursor has now been changed\r\n    }\r\n  }\r\n\r\n  setCursorBehindNodeForDefaultOrRightMovement(node: Node) {\r\n    const nextSibling = DomDummyNodeManager.getNextSibling(node);\r\n    if (nextSibling) {\r\n      this.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);\r\n    } else {\r\n      this.SetCursor(node, XMLCursorPositions.CursorBehindNode);\r\n    }\r\n  }\r\n\r\n  setCursorpBehindNodeForLeftMovement(node: Node) {\r\n    if (XmlToolbox.IsTextOrCommentNode(node)) {\r\n      //  For a text node, the cursor is placed after the last character.\r\n      this.SetCursor(node, XMLCursorPositions.CursorInsideTextNode, Math.max(0, node.textContent.length - 1));\r\n    } else {\r\n      const childNodeCount = DomDummyNodeManager.getChildNodeCount(node);\r\n      if (childNodeCount === 0) {\r\n        // There are no children in the node.\r\n        if (!Xml2html.isNoClosingElement(node)) {\r\n          // If the cursor shows a close tag, then put it in the empty node\r\n          this.SetCursor(node, XMLCursorPositions.CursorInEmptyNode);\r\n        } else {\r\n          // If the cursor does not display a close tag, then place it before the empty node.\r\n          this.SetCursor(node, XMLCursorPositions.CursorInFrontOfNode);\r\n        }\r\n      } else {\r\n        // There are children in node\r\n        this.SetCursor(DomDummyNodeManager.getLastChild(node), XMLCursorPositions.CursorBehindNode);\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nexport enum XMLCursorPositions {\r\n  CursorInFrontOfNode = 0,\r\n  CursorOnCompleteNode = 1,\r\n  CursorInEmptyNode = 2,\r\n  CursorInsideTextNode = 3,\r\n  CursorBehindNode = 4\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from './xmlCursorPos.class';\r\nimport { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlCursorPosMover {\r\n  public static moveLeft(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        // Put in front of the node\r\n        pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        if (pos.ActualNode === rootNode) {\r\n          return false;\r\n        } else {\r\n          const previousSibling = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);\r\n          if (previousSibling) {\r\n            // Previous sibling node exists\r\n            pos.setCursorpBehindNodeForLeftMovement(previousSibling);\r\n          } else {\r\n            // no previous sibling node available -> set before parent node\r\n            pos.SetCursor(pos.ActualNode.parentNode, XMLCursorPositions.CursorInFrontOfNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        pos.setCursorpBehindNodeForLeftMovement(pos.ActualNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        // Put in front of the node\r\n        pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {\r\n          // Node is Textnode\r\n          if (pos.PosInTextnode > 1) {\r\n            // Cursor one character to the left\r\n            pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode - 1);\r\n          } else {\r\n            // Put in front of the node\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);\r\n          }\r\n        } else {\r\n          // no Textnode\r\n          const elemt = pos.ActualNode as Element;\r\n          throw new Error(`XMLCursorPos.MoveLeft: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes,\r\n                           but no text node has been chosen, but the node ${elemt ? elemt.outerHTML : ''}`);\r\n        }\r\n        break;\r\n\r\n      default:\r\n        throw new Error(`XMLCursorPos.MoveLeft: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n    return true;\r\n  }\r\n\r\n  public static moveRight(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        // Hinter den Node setzen\r\n        const tagName = Xml2html.getTagNameFromNode(pos.ActualNode);\r\n        const rule = xmlRules.ruleElements.get(tagName);\r\n        if (rule && rule.empty === true) {\r\n          pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n        } else {\r\n          const firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);\r\n          if (firstChild) {\r\n            pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);\r\n          } else {\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        const nextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode);\r\n        if (nextSibling) {\r\n          // cursor behind node should only be set, when no other siblings are following\r\n          const elemt = pos.ActualNode as Element;\r\n          throw new Error(`XMLCursorPos.MoveRight: cursor behind node should only be set, when no other siblings are following ${elemt ? elemt.outerHTML : ''}`);\r\n        } else {\r\n          // No following siblings present, then set after parent node\r\n          const parentNextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode.parentElement);\r\n          if (parentNextSibling) {\r\n            pos.SetCursor(parentNextSibling, XMLCursorPositions.CursorInFrontOfNode);\r\n          } else {\r\n            pos.SetCursor(pos.ActualNode.parentElement, XMLCursorPositions.CursorBehindNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        // Place behind the node\r\n        pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {\r\n          // Node is Textnode\r\n          if ((pos.ActualNode as Element).textContent.length > 1) {\r\n            // Textnode is not empty\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, 1); // one character forward, behind the first character\r\n          } else {\r\n            // Textnode is empty\r\n            // put behind the node\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorBehindNode);\r\n            // Because \"CursorBehindNode\" is not attractive, one more step\r\n            this.moveRight(pos, rootNode, xmlRules);\r\n          }\r\n        } else {\r\n          // Node is not Textnode\r\n          const childNodeCount = DomDummyNodeManager.getChildNodeCount(pos.ActualNode);\r\n          if (childNodeCount === 0) {\r\n            // no Children existing\r\n            if (Xml2html.isNoClosingElement(pos.ActualNode)) {\r\n              // If no closed tag is displayed for this node, then directly behind the node\r\n              // Place behind the node\r\n              pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n            } else {\r\n              // Node has closing tag, so put in between\r\n              // Place in empty node\r\n              pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);\r\n            }\r\n          } else {\r\n            // Children existing\r\n            const firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);\r\n            pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {\r\n          // Node is Textnode\r\n          if ((pos.ActualNode as Element).textContent.length > pos.PosInTextnode + 1) {\r\n            // there is still text in the right of the textnode\r\n            // step one character forwards: behind the first char\r\n            pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode + 1);\r\n          } else {\r\n            // no text after the textnode\r\n            // place cursor behind the node\r\n            pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n          }\r\n        } else {\r\n          // Node is no Textnode\r\n          const elemt = pos.ActualNode as Element;\r\n          throw new Error(`XMLCursorPos.MoveRight: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes, \r\n                        but no text node has been chosen, but the node ${elemt ? elemt.outerHTML : ''}`);\r\n        }\r\n        break;\r\n      default:\r\n        throw new Error(`String.Format(\"XMLCursorPos.MoveRight: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from './xmlCursorPos.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\n\r\nexport class XmlCursor {\r\n  xmlDocumentRootNode: Element = undefined;\r\n  domDummyNodeManager = new DomDummyNodeManager();\r\n\r\n  public StartPos = new XmlCursorPos();\r\n  public EndPos = new XmlCursorPos();\r\n\r\n  /**\r\n   * is there nothing between start and end pos?\r\n   */\r\n  isEmptySelection(): boolean {\r\n    if (this.StartPos.equals(this.EndPos)) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  sortStartAndEnd() {\r\n    if (this.StartPos.ActualNode && this.EndPos.ActualNode) {\r\n      if (this.StartPos.ActualNode.isSameNode(this.EndPos.ActualNode)) {\r\n        if (\r\n          this.StartPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&\r\n          this.EndPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&\r\n          this.StartPos.PosInTextnode > this.EndPos.PosInTextnode\r\n        ) {\r\n          this.swapStartAndEnd();\r\n        }\r\n      } else {\r\n        const compared = this.StartPos.ActualNode.compareDocumentPosition(this.EndPos.ActualNode);\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (!(compared & Node.DOCUMENT_POSITION_FOLLOWING)) {\r\n          this.swapStartAndEnd();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  swapStartAndEnd() {\r\n    const node = this.StartPos.ActualNode;\r\n    const pos = this.StartPos.PosAtNode;\r\n    const text = this.StartPos.PosInTextnode;\r\n    this.StartPos.SetCursor(this.EndPos.ActualNode, this.EndPos.PosAtNode, this.EndPos.PosInTextnode);\r\n    this.EndPos.SetCursor(node, pos, text);\r\n  }\r\n\r\n  show() {\r\n    if (window.getSelection) {\r\n      const selection: Selection = window.getSelection();\r\n      this.show2(selection);\r\n    } else {\r\n      throw new Error('showCursor: unable to get \"window.getSelection\"');\r\n    }\r\n  }\r\n\r\n  private show2(selection: Selection) {\r\n    if (!selection) {\r\n      return;\r\n    }\r\n\r\n    // Remove all selected classes\r\n    const elems = document.querySelectorAll('.selected');\r\n    [].forEach.call(elems, function(el) {\r\n      el.classList.remove('selected');\r\n    });\r\n\r\n    const startSelection = XmlCursorPos.getSelectionForPos(this.StartPos);\r\n    if (this.EndPos && this.EndPos.ActualNode && !this.EndPos.equals(this.StartPos)) {\r\n      // start + end pos\r\n      const endSelection = XmlCursorPos.getSelectionForPos(this.EndPos);\r\n      selection.setBaseAndExtent(startSelection.node, startSelection.offset, endSelection.node, endSelection.offset);\r\n    } else {\r\n      // only start pos\r\n      selection.setPosition(startSelection.node, startSelection.offset);\r\n\r\n      // select tag by adding \"select\" class\r\n      if (this.StartPos.PosAtNode === XMLCursorPositions.CursorOnCompleteNode) {\r\n        const asElem = this.StartPos.ActualNode as Element;\r\n        if (asElem && asElem.classList) {\r\n          asElem.classList.add('selected');\r\n          console.log('selected!');\r\n        } else {\r\n          console.error(`no asElem.classList for select! ${XmlToolbox.GetNodeDebugContext(asElem)}`);\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nexport interface SelectionPos {\r\n  node: Node;\r\n  offset: number;\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from './xmlCursorPos.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { XmlEditorDebugger } from '../xmlEditorDebugger';\r\n\r\nexport class XmlCursorPosSetter {\r\n  public static setFromSelection(pos: XmlCursorPos, selectionAnchorNode: Node, selectionAnchorOffset: number, debugLog: XmlEditorDebugger = null) {\r\n    if (selectionAnchorNode !== undefined && selectionAnchorNode !== null) {\r\n      let node = selectionAnchorNode as Element;\r\n      if (DomDummyNodeManager.IsDummyNode(selectionAnchorNode.parentElement)) {\r\n        // clicked inside a dummy node\r\n        node = selectionAnchorNode.parentElement as Element;\r\n\r\n        if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(node)) {\r\n          switch (selectionAnchorOffset) {\r\n            case 0:\r\n              if (debugLog) {\r\n                debugLog.setInputSelection(`(1) cursor here: #<tag> pos 0`);\r\n              }\r\n              pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);\r\n              return;\r\n\r\n            case 1:\r\n              if (debugLog) {\r\n                debugLog.setInputSelection(`(2) cursor here: #<tag> pos 1`);\r\n              }\r\n              pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInFrontOfNode, 0);\r\n              return;\r\n\r\n            default:\r\n              throw new Error(`selectionAnchorOffset=${selectionAnchorOffset}?!?`);\r\n          }\r\n        }\r\n\r\n        if (node.parentElement.childNodes.length === 2) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(13, 14) cursor here: <tag>#</tag>`);\r\n          }\r\n          pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInEmptyNode, 0);\r\n          return;\r\n        }\r\n\r\n        if (node === node.parentElement.lastChild && selectionAnchorOffset === 1) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(8, 12) cursor here: #</tag>, selecting complete node`);\r\n          }\r\n          pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);\r\n          return;\r\n        }\r\n\r\n        const nextSibling = node.nextSibling;\r\n        if (nextSibling) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(3, 4, 9, 10) cursor here: #Text or here #<tag>`);\r\n          }\r\n          pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode, 0);\r\n          return;\r\n        }\r\n\r\n        const previousSibling = node.previousSibling;\r\n        if (previousSibling) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(7, 11) cursor here: Text# or here <tag>#`);\r\n          }\r\n          pos.SetCursor(previousSibling, XMLCursorPositions.CursorBehindNode, 0);\r\n          return;\r\n        }\r\n      } else {\r\n        // is no dummy node\r\n        if (selectionAnchorNode.nodeType === Node.TEXT_NODE) {\r\n          if (selectionAnchorOffset === 0) {\r\n            if (debugLog) {\r\n              debugLog.setInputSelection(`(6) cursor here: #Text`);\r\n            }\r\n            pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, 0);\r\n            return;\r\n          }\r\n\r\n          if (selectionAnchorOffset === selectionAnchorNode.textContent.length) {\r\n            if (debugLog) {\r\n              debugLog.setInputSelection(`(7 Alternative) cursor here: Text#`);\r\n            }\r\n            pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorNode.textContent.length);\r\n            return;\r\n          }\r\n\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(5) cursor here: Text#Text`);\r\n          }\r\n          if (selectionAnchorOffset > selectionAnchorNode.textContent.length) {\r\n            throw new Error(\r\n              `selectionAnchorOffset ${selectionAnchorOffset} is > than text-lenght ${selectionAnchorNode.textContent.length} of text '${selectionAnchorNode.textContent}' `\r\n            );\r\n          }\r\n          pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorOffset);\r\n          return;\r\n        }\r\n      }\r\n\r\n      // if (DomDummyNodeManager.IsDummyNode(parentElem)) {\r\n      //     const dummyElement = parentElem;\r\n\r\n      //     const nextSibling = parentElem.nextSibling;\r\n      //     if (XmlToolbox.IstTextOderKommentarNode(nextSibling)) {\r\n      //         // cursor here: #text (# = red dummyNode)\r\n      //         pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);\r\n      //         return;\r\n      //     }\r\n\r\n      //     const previousSibling = dummyElement.previousSibling;\r\n      //     if (!previousSibling) {\r\n      //     //    pos.CursorSetzen(dummyElement.parentElement, XMLCursorPositionen.c, 0);\r\n      //     }\r\n      // }\r\n\r\n      // switch (node.nodeType) {\r\n\r\n      //     case Node.TEXT_NODE:\r\n\r\n      // if (loopCount === 0) {\r\n      //     const nextSibling = parentElem.nextSibling;\r\n      //     if (nextSibling && nextSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 1) {\r\n      //         // set cursor at start of following textnode\r\n      //         pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);\r\n      //     } else {\r\n      //         const previousSibling = parentElem.previousSibling;\r\n      //         if (previousSibling && previousSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 0) {\r\n      //             // set cursor at end of previous textnode\r\n      //             pos.CursorSetzen(previousSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, previousSibling.nodeValue.length);\r\n      //         }\r\n      //     }\r\n      // } else {\r\n      //     node = parentElem; // up to dummy node\r\n      // }\r\n\r\n      //         } else {\r\n      //             pos.CursorSetzen(node, XMLCursorPositionen.CursorInnerhalbDesTextNodes, selectionAnchorOffset);\r\n      //         }\r\n      //         break;\r\n\r\n      //     case Node.ELEMENT_NODE:\r\n      //         if (DomDummyNodeManager.IsDummyNode(node)) {\r\n      //             // node = parentElem; // up to parent node\r\n      //         } else {\r\n      //             pos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);\r\n      //         }\r\n      //         break;\r\n\r\n      //     default:\r\n      //         throw new Error(`unhandled nodeType '${node.nodeType}' of node ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n      // }\r\n    }\r\n    console.error(\r\n      `found no suiting cursor interpretation! For selectionAnchorNode=${XmlToolbox.GetNodeDebugContext(selectionAnchorNode)}, selectionAnchorOffset=${selectionAnchorOffset}`\r\n    );\r\n  }\r\n}\r\n","import { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { XmlCursor } from '../cursor/xmlCursor.class';\r\nimport { XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\n\r\nexport class XmlDomCleaner {\r\n  public static cleanUp(node: Node, actualCursor: XmlCursor) {\r\n    this.concatTextNodes(node, actualCursor);\r\n  }\r\n\r\n  /***\r\n   * if two textnodes are direct siblings: concat to one textnode\r\n   */\r\n  public static concatTextNodes(node: Node, actualCursor: XmlCursor, nodeDepth = 0): void {\r\n    let restart = true;\r\n\r\n    while (restart === true) {\r\n      restart = false;\r\n\r\n      for (let i = 0; i < node.childNodes.length; ++i) {\r\n        const firstToCheck = node.childNodes[i];\r\n        if (DomDummyNodeManager.IsDummyNode(firstToCheck)) {\r\n          throw new Error('Dummynodes have to be removed before using XmlDomCleaner!');\r\n        }\r\n        if (firstToCheck.nodeType === Node.TEXT_NODE) {\r\n          const secondToCheck = firstToCheck.nextSibling;\r\n          if (secondToCheck !== null && secondToCheck.nodeType === Node.TEXT_NODE) {\r\n            // two text nodes after each other => concat\r\n            if (actualCursor.StartPos.ActualNode === secondToCheck) {\r\n              actualCursor.StartPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.StartPos.PosInTextnode);\r\n            }\r\n            if (actualCursor.EndPos.ActualNode === secondToCheck) {\r\n              actualCursor.EndPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.EndPos.PosInTextnode);\r\n            }\r\n            firstToCheck.textContent = firstToCheck.textContent + secondToCheck.textContent;\r\n            node.removeChild(secondToCheck);\r\n            restart = true;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // update child nodes\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      this.concatTextNodes(node.childNodes[i], actualCursor, nodeDepth + 1);\r\n    }\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { XmlCursorPosMover } from '../cursor/xmlCursorPosMover.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { XmlCursor } from '../cursor/xmlCursor.class';\r\n\r\nexport class XmlEditDelete {\r\n  public static deleteSelection(cursor: XmlCursor, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    return true;\r\n  }\r\n\r\n  public static deleteAfter(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      default:\r\n        throw new Error(`String.Format(\"XmlCursorEdit.deleteBefore: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  public static deleteBefore(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    let deleteNode: Node;\r\n\r\n    // console.log(pos.getDebugDescription());\r\n\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        deleteNode = pos.ActualNode;\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        deleteNode.parentElement.removeChild(deleteNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.ActualNode.textContent.length);\r\n          return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n        } else {\r\n          pos.ActualNode.parentElement.removeChild(pos.ActualNode);\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        deleteNode = pos.ActualNode;\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        deleteNode.parentElement.removeChild(deleteNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        deleteNode = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);\r\n        if (!deleteNode) {\r\n          deleteNode = pos.ActualNode.parentElement;\r\n        }\r\n        if (deleteNode) {\r\n          if (deleteNode.nodeType === Node.TEXT_NODE) {\r\n            pos.SetCursor(deleteNode, XMLCursorPositions.CursorInsideTextNode, deleteNode.textContent.length);\r\n            return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n          } else {\r\n            deleteNode.parentElement.removeChild(deleteNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        if (pos.PosInTextnode === 0) {\r\n          pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode, 0);\r\n          return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n        } else {\r\n          let text = pos.ActualNode.textContent;\r\n          text = text.substring(0, pos.PosInTextnode - 1) + text.substr(pos.PosInTextnode, pos.ActualNode.textContent.length);\r\n          pos.ActualNode.textContent = text;\r\n          XmlCursorPosMover.moveLeft(pos, rootNode, xmlRules);\r\n          // pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode - 1);\r\n        }\r\n        break;\r\n\r\n      default:\r\n        throw new Error(`String.Format(\"XmlEdit.deleteBefore: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlEditRuleCheckTextInsert {\r\n  namespacePraefix = 'xs:';\r\n\r\n  constructor(private xsdNodes: Map<string, Element>) {}\r\n\r\n  isTextAllowedAtThisCursorPos(cursorPosToCheck: XmlCursorPos): boolean {\r\n    if (!cursorPosToCheck) {\r\n      return false;\r\n    }\r\n    const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);\r\n    const parentName = Xml2html.getTagNameFromNode(parentNode);\r\n    const xsdNode = this.xsdNodes.get(parentName);\r\n    if (xsdNode) {\r\n      const result = this.isTextAllowedInThisElement(xsdNode);\r\n      return result;\r\n    } else {\r\n      return false; // element not found\r\n    }\r\n  }\r\n\r\n  getRelevantParentNodeForCursorPos(cursorPosToCheck: XmlCursorPos): Node {\r\n    if (cursorPosToCheck) {\r\n      let parentNode = cursorPosToCheck.ActualNode;\r\n\r\n      switch (parentNode.nodeType) {\r\n        case Node.COMMENT_NODE:\r\n        case Node.TEXT_NODE:\r\n          parentNode = parentNode.parentElement;\r\n          break;\r\n\r\n        case Node.ELEMENT_NODE:\r\n          switch (cursorPosToCheck.PosAtNode) {\r\n            case XMLCursorPositions.CursorInEmptyNode:\r\n            case XMLCursorPositions.CursorInsideTextNode:\r\n              break;\r\n\r\n            case XMLCursorPositions.CursorBehindNode:\r\n            case XMLCursorPositions.CursorInFrontOfNode:\r\n            case XMLCursorPositions.CursorOnCompleteNode:\r\n              parentNode = parentNode.parentElement;\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unhandled  cursorPosToCheck.PosAmNode \"${cursorPosToCheck.PosAtNode}\"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}\" `);\r\n          }\r\n          break;\r\n\r\n        default:\r\n          throw new Error(`unhandled  parentNode.nodeType \"${parentNode.nodeType}\"`);\r\n      }\r\n      return parentNode;\r\n    }\r\n  }\r\n\r\n  isTextAllowedInThisElement(xsdNode: Node, alreadyAddedElementNames: Set<string> = new Set<string>()): boolean {\r\n    let elementName: string;\r\n\r\n    if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n      const asElem = xsdNode as Element;\r\n      if (asElem) {\r\n        const mixedAttrib = asElem.getAttribute('mixed');\r\n        if (mixedAttrib) {\r\n          return true;\r\n        }\r\n        const typeAttrib = asElem.getAttribute('type');\r\n        if (typeAttrib && typeAttrib === `${this.namespacePraefix}string`) {\r\n          return true;\r\n        }\r\n\r\n        if (asElem.localName === 'element') {\r\n          elementName = asElem.getAttribute('name');\r\n          if (elementName) {\r\n            if (alreadyAddedElementNames.has(elementName)) {\r\n              return false; // element recursion detected\r\n            }\r\n          }\r\n          alreadyAddedElementNames.add(elementName);\r\n        }\r\n      }\r\n    }\r\n\r\n    const childNodes = Array.prototype.slice.call(xsdNode.childNodes) as Node[];\r\n\r\n    let allowed = false;\r\n\r\n    childNodes.forEach(child => {\r\n      if (child.nodeType === Node.ELEMENT_NODE) {\r\n        const childElem = child as Element;\r\n        if (childElem) {\r\n          switch (childElem.localName) {\r\n            case 'complexType':\r\n            case 'sequence':\r\n            case 'choice':\r\n            case 'simpleContent':\r\n            case 'extension':\r\n              if (this.isTextAllowedInThisElement(child, alreadyAddedElementNames) === true) {\r\n                allowed = true;\r\n                break;\r\n              }\r\n              break;\r\n\r\n            case 'element':\r\n              const refname = childElem.attributes.getNamedItem('ref');\r\n              if (refname) {\r\n                const referedNode = this.xsdNodes.get(refname.value);\r\n                if (referedNode) {\r\n                  if (this.isTextAllowedInThisElement(referedNode, alreadyAddedElementNames) === true) {\r\n                    allowed = true;\r\n                    break;\r\n                  }\r\n                } else {\r\n                  throw new Error(` refered element \"${refname}\" for element \"${childElem.outerHTML}\" not found`);\r\n                }\r\n              }\r\n              break;\r\n\r\n            case 'attribute':\r\n              break;\r\n\r\n            default:\r\n              alert('unknown childElem.localname \"' + childElem.localName + '\"/' + childElem.outerHTML);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return allowed;\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlEditRuleCheckTextInsert } from '../xml-rules-check/xmlEditRuleCheckTextInsert.class';\r\nimport { XmlSchema } from '../xml-rules-check/xmlSchema.class';\r\nimport { XmlEditDelete } from './xmlEditDeleteclass';\r\nimport { XmlCursor } from '../cursor/xmlCursor.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\n\r\nexport class XmlEditInsert {\r\n  public static replaceWithText(pos: XmlCursor, value: string, rootNode: Element, xmlRules: XmlRules, xmlSchema: XmlSchema): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n    if (value === '' || value === undefined || value == null) {\r\n      return false;\r\n    }\r\n\r\n    if (pos.isEmptySelection() === false) {\r\n      if (XmlEditDelete.deleteSelection(pos, rootNode, xmlRules) === false) {\r\n        return false;\r\n      }\r\n    }\r\n\r\n    return XmlEditInsert.insertText(pos.EndPos, value, rootNode, xmlRules, xmlSchema);\r\n  }\r\n\r\n  public static insertText(pos: XmlCursorPos, value: string, rootNode: Element, xmlRules: XmlRules, xmlSchema: XmlSchema): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    if (value === '' || value === undefined || value == null) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        let textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);\r\n        if (textAllowed === true) {\r\n          const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n          pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);\r\n          pos.ActualNode.parentElement.removeChild(pos.ActualNode);\r\n          const nextSibling = DomDummyNodeManager.getNextSibling(newTextNode);\r\n          if (nextSibling) {\r\n            pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);\r\n          } else {\r\n            pos.SetCursor(newTextNode, XMLCursorPositions.CursorBehindNode);\r\n          }\r\n          return true;\r\n        } else {\r\n          return false;\r\n        }\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          pos.ActualNode.textContent = pos.ActualNode.textContent + value;\r\n          return true;\r\n        } else {\r\n          textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);\r\n          if (textAllowed === true) {\r\n            const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n            pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode.nextSibling); // inserts the new node after the actual node\r\n            return true;\r\n          } else {\r\n            return false;\r\n          }\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          pos.ActualNode.textContent = value + pos.ActualNode.textContent;\r\n          return true;\r\n        } else {\r\n          textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);\r\n          if (textAllowed === true) {\r\n            const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n            pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);\r\n            return true;\r\n          } else {\r\n            return false;\r\n          }\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        textAllowed = new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(pos);\r\n        if (textAllowed === true) {\r\n          const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n          pos.ActualNode.appendChild(newTextNode);\r\n          return true;\r\n        } else {\r\n          return false;\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        const text = pos.ActualNode.textContent;\r\n        pos.ActualNode.textContent = text.substr(0, pos.PosInTextnode) + value + text.substr(pos.PosInTextnode, text.length);\r\n        pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode + 1);\r\n        break;\r\n\r\n      default:\r\n        throw new Error(`String.Format(\"XmlEditInsert.insert: unknown CursorPos  ${pos.getDebugDescription()}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  private static isTextAllowedInParentNode(pos: XmlCursorPos, xmlSchema: XmlSchema): boolean {\r\n    const parentNode = pos.ActualNode.parentElement;\r\n    const parentCursorPos = pos.clone();\r\n    parentCursorPos.SetCursor(parentNode, XMLCursorPositions.CursorInEmptyNode);\r\n    return new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(parentCursorPos);\r\n  }\r\n}\r\n","import { Subject } from 'rxjs';\r\nimport { XmlRuleElement } from './xml-rules-check/xmlRuleElement.class';\r\nimport { XmlEditorConfig } from './xmlEditorConfig';\r\nimport { XmlEditorDebugger } from './xmlEditorDebugger';\r\nimport { XmlCursorPosMover } from './cursor/xmlCursorPosMover.class';\r\nimport { XmlCursor } from './cursor/xmlCursor.class';\r\nimport { OnDestroy } from '@angular/core';\r\nimport { XmlCursorPosSetter } from './cursor/xmlCursorPosSetter.class';\r\nimport { DomDummyNodeManager } from './dummyNodes/domDummyNodeManager.class';\r\nimport { XmlDomCleaner } from './xml-editing/xmlDomCleaner.class';\r\nimport { XmlEditDelete } from './xml-editing/xmlEditDeleteclass';\r\nimport { Xml2html } from './xml-html-converter/xml2html.class';\r\nimport { TouchSequence } from 'selenium-webdriver';\r\nimport { XmlEditInsert } from './xml-editing/xmlEditInsert.class';\r\nimport { debug } from 'util';\r\n\r\nexport class XmlEditorContext implements OnDestroy {\r\n  public debugService: XmlEditorDebugger;\r\n  public config: XmlEditorConfig;\r\n\r\n  actualCursorChanged: Subject<XmlCursor>;\r\n  actualCursor = new XmlCursor();\r\n  dummyNodeManager = new DomDummyNodeManager();\r\n\r\n  savedSelection: Range | null;\r\n  selectedText: string;\r\n\r\n  keyCtrlIsDown: boolean;\r\n  keyShiftIsDown: boolean;\r\n\r\n  constructor(private _document: Document) {\r\n    this.actualCursorChanged = new Subject<XmlCursor>();\r\n    this.debugService = new XmlEditorDebugger();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorChanged.unsubscribe();\r\n  }\r\n\r\n  setCursorPos(cursorPos: XmlCursor) {\r\n    this.actualCursor = cursorPos;\r\n    this.actualCursorChanged.next(cursorPos);\r\n    this.debugService.setActualCursorPos(cursorPos);\r\n  }\r\n\r\n  // /**\r\n  //   * Executed command from editor header buttons\r\n  //   * @param command string from triggerCommand\r\n  //   */\r\n  // executeCommand(command: string) {\r\n  //   if (command !== '') {\r\n  //     this.commander.executeCommand(command);\r\n  //     this.exec();\r\n  //   }\r\n  //   this.onEditorFocus();\r\n  //   const cleanUpFirst = false;\r\n  //   this.domDummyNodeManager.UpdateDummyNodes(this.xmlDocumentRootNode, cleanUpFirst);\r\n  //   return;\r\n  // }\r\n\r\n  mouseUp(mouseEvent: MouseEvent) {\r\n    if (window.getSelection) {\r\n      let userSelection: Selection;\r\n      userSelection = window.getSelection();\r\n      XmlCursorPosSetter.setFromSelection(this.actualCursor.StartPos, userSelection.anchorNode, userSelection.anchorOffset, this.debugService);\r\n      XmlCursorPosSetter.setFromSelection(this.actualCursor.EndPos, userSelection.focusNode, userSelection.focusOffset, this.debugService);\r\n      this.setCursorPos(this.actualCursor);\r\n      this.actualCursor.sortStartAndEnd();\r\n      this.actualCursor.show();\r\n    } else {\r\n      throw new Error(`can't get window.getSelection, target=${JSON.stringify(mouseEvent.target)}`);\r\n    }\r\n  }\r\n\r\n  keyDown(event: KeyboardEvent): boolean {\r\n    console.log('keydown! key:' + event.key + ' / code:' + event.code);\r\n\r\n    switch (event.key) {\r\n      case 'Control':\r\n        this.keyCtrlIsDown = true;\r\n        break;\r\n\r\n      case 'Shift':\r\n        this.keyShiftIsDown = true;\r\n        break;\r\n\r\n      case 'c':\r\n        if (this.keyCtrlIsDown) {\r\n          // Copy\r\n          return false;\r\n        } else {\r\n          if (this.insertText('c')) {\r\n            return false;\r\n          }\r\n        }\r\n        break;\r\n\r\n      case 'ArrowUp':\r\n      case 'ArrowDown':\r\n        return true;\r\n\r\n      case 'ArrowRight':\r\n        if (this.keyShiftIsDown) {\r\n          XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n          this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);\r\n        }\r\n        this.actualCursor.sortStartAndEnd();\r\n        this.actualCursor.show();\r\n        this.setCursorPos(this.actualCursor);\r\n        return false;\r\n\r\n      case 'ArrowLeft':\r\n        if (this.keyShiftIsDown) {\r\n          XmlCursorPosMover.moveLeft(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlCursorPosMover.moveLeft(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n          this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);\r\n        }\r\n        this.actualCursor.sortStartAndEnd();\r\n        this.actualCursor.show();\r\n        this.setCursorPos(this.actualCursor);\r\n        return false;\r\n\r\n      case 'Backspace':\r\n        if (this.actualCursor.isEmptySelection()) {\r\n          XmlEditDelete.deleteBefore(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        }\r\n        this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);\r\n        this.cleanUpAndUpdateDummyElements();\r\n        this.actualCursor.show();\r\n        return false;\r\n\r\n      case 'Delete':\r\n        if (this.actualCursor.isEmptySelection()) {\r\n          XmlEditDelete.deleteAfter(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        }\r\n        this.cleanUpAndUpdateDummyElements();\r\n        this.actualCursor.show();\r\n        return false;\r\n\r\n      case 'Enter':\r\n        return false;\r\n\r\n      default:\r\n        const textInsert = event.key;\r\n        if (this.insertText(textInsert)) {\r\n          return false;\r\n        }\r\n        break;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  keyUp(event: KeyboardEvent): boolean {\r\n    switch (event.key) {\r\n      case 'Control':\r\n        this.keyCtrlIsDown = false;\r\n        break;\r\n      case 'Shift':\r\n        this.actualCursor.sortStartAndEnd();\r\n        this.keyShiftIsDown = false;\r\n        break;\r\n\r\n      case 'ArrowLeft':\r\n      case 'ArrowRight':\r\n        this.actualCursor.show();\r\n        break;\r\n\r\n      case 'ArrowUp':\r\n      case 'ArrowDown':\r\n      case 'Backspace':\r\n      case 'Delete':\r\n      case 'Enter':\r\n      case 'Control':\r\n      case 'Shift':\r\n        break;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  pasted(text: string): boolean {\r\n    alert('pasted: ' + text);\r\n    return false;\r\n  }\r\n\r\n  copied(): boolean {\r\n    alert('copied');\r\n    return false;\r\n  }\r\n\r\n  insertText(value: string): boolean {\r\n    if (value === '' || value === null || value === undefined) {\r\n      return true;\r\n    }\r\n\r\n    let inserted = false;\r\n\r\n    if (this.actualCursor.isEmptySelection()) {\r\n      inserted = XmlEditInsert.insertText(this.actualCursor.EndPos, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);\r\n    } else {\r\n      inserted = XmlEditInsert.replaceWithText(this.actualCursor, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);\r\n    }\r\n\r\n    if (inserted) {\r\n      // character inserted -> move cursor right\r\n      // for (let index = 0; index < value.length; index++) {\r\n      //   XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n      // }\r\n      this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);\r\n      this.cleanUpAndUpdateDummyElements();\r\n      this.actualCursor.show();\r\n      console.warn('text inserted!');\r\n      return true;\r\n    } else {\r\n      console.warn('text NOT inserted!');\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /** inserts a new element at the actual cursor pos */\r\n  insertElement(element: XmlRuleElement) {\r\n    const html = new Xml2html(this.config.rules).createNewElementHtml(element);\r\n    this.domInsertHtml(html);\r\n    this.cleanUpAndUpdateDummyElements();\r\n    // this.actualCursor.show();\r\n    console.warn('element inserted!');\r\n  }\r\n\r\n  /**\r\n   * Create raw HTML\r\n   * @param html HTML string\r\n   */\r\n  public domInsertHtml(html: string): void {\r\n    if (document.getSelection) {\r\n      const range = document.getSelection().getRangeAt(0);\r\n      range.insertNode(range.createContextualFragment(html));\r\n    } else {\r\n      throw new Error('document.getSelection not defined!');\r\n    }\r\n    this.cleanUpAndUpdateDummyElements();\r\n    this.actualCursor.show();\r\n  }\r\n\r\n  /**\r\n   * save selection when the editor is focussed out\r\n   */\r\n  saveSelection(): any {\r\n    if (window.getSelection) {\r\n      const sel = window.getSelection();\r\n      if (sel.getRangeAt && sel.rangeCount) {\r\n        this.savedSelection = sel.getRangeAt(0);\r\n        this.selectedText = sel.toString();\r\n      }\r\n    } else if (this._document.getSelection && this._document.createRange) {\r\n      this.savedSelection = document.createRange();\r\n    } else {\r\n      this.savedSelection = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * restore selection when the editor is focussed in\r\n   */\r\n  restoreSelection(): boolean {\r\n    if (this.savedSelection) {\r\n      if (window.getSelection) {\r\n        const sel = window.getSelection();\r\n        sel.removeAllRanges();\r\n        sel.addRange(this.savedSelection);\r\n        return true;\r\n      } else if (this._document.getSelection /*&& this.savedSelection.select*/) {\r\n        // this.savedSelection.select();\r\n        return true;\r\n      }\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  cleanUpAndUpdateDummyElements() {\r\n    this.dummyNodeManager.RemoveAllDummyNodes(this.actualCursor.xmlDocumentRootNode);\r\n    XmlDomCleaner.cleanUp(this.actualCursor.xmlDocumentRootNode, this.actualCursor);\r\n    this.dummyNodeManager.UpdateDummyNodes(this.actualCursor.xmlDocumentRootNode);\r\n    this.actualCursor.sortStartAndEnd();\r\n  }\r\n\r\n  // /** check any slection is made or not */\r\n  // private checkSelection(): any {\r\n  //   const slectedText = this.savedSelection.toString();\r\n\r\n  //   if (slectedText.length === 0) {\r\n  //     throw new Error('No Selection Made');\r\n  //   }\r\n\r\n  //   return true;\r\n  // }\r\n\r\n  // setDefaultParagraphSeparator(separator: string) {\r\n  //   this._document.execCommand('defaultParagraphSeparator', false, separator);\r\n  // }\r\n}\r\n","import { Injectable, Inject } from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { XmlEditorContext } from './code/xmlEditorContext.class';\r\n\r\n/** @dynamic */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AngularXmlEditorService {\r\n  private contexts = new Map<string, XmlEditorContext>();\r\n\r\n  constructor(@Inject(DOCUMENT) private _document: Document) {}\r\n\r\n  getNewEditorContextId(): string {\r\n    let no = 0;\r\n    while (this.contexts.has(no.toString())) {\r\n      no++;\r\n    }\r\n    return no.toString();\r\n  }\r\n\r\n  getEditorContext(contextId: string): XmlEditorContext {\r\n    let context = this.contexts.get(contextId);\r\n    if (context === undefined) {\r\n      context = new XmlEditorContext(this._document);\r\n      this.contexts.set(contextId, context);\r\n    }\r\n    return context;\r\n  }\r\n\r\n  disposeEditorContext(contextId: string) {\r\n    this.contexts.delete(contextId);\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { Xml2html } from './xml2html.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { Xml2htmlAttributeWorker } from './xml2htmlAttributeWorker.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\n\r\nexport class Html2xml {\r\n  private attributeWorker: Xml2htmlAttributeWorker;\r\n\r\n  constructor(public rules: XmlRules) {\r\n    this.attributeWorker = new Xml2htmlAttributeWorker(rules);\r\n  }\r\n\r\n  public ToXml(html: string): string {\r\n    if (html === '') {\r\n      return '';\r\n    }\r\n    // html = html.replace('\\t', '');\r\n    // html = html.replace('\\r', '');\r\n    // html = html.replace('\\n', '');\r\n\r\n    const cleanHtml = this.CleanUpHtmlBeforeConvert2Xml(html);\r\n    const domparser = new DOMParser();\r\n    const domdoc = domparser.parseFromString(cleanHtml, 'text/xml');\r\n    const targetDocument = new Document();\r\n    if (domdoc.documentElement === null) {\r\n      return '';\r\n    }\r\n\r\n    const body = this.GetXmlElementFromHtmlElement(domdoc.documentElement, targetDocument);\r\n    if (body && body.nodeType === Node.ELEMENT_NODE) {\r\n      const xml = (body as Element).outerHTML;\r\n      return xml;\r\n    } else {\r\n      throw new Error(`root node ${XmlToolbox.GetNodeDebugContext(body)} is no element`);\r\n    }\r\n  }\r\n\r\n  private CleanUpHtmlBeforeConvert2Xml(html: string): string {\r\n    const domparser = new DOMParser();\r\n    const domdoc = domparser.parseFromString(html, 'text/html');\r\n    new DomDummyNodeManager().RemoveAllDummyNodes(domdoc.documentElement); // remove all dummy nodes\r\n    const cleanHtml = domdoc.body.innerHTML;\r\n    return cleanHtml;\r\n  }\r\n\r\n  private GetXmlElementFromHtmlElement(node: Node, targetDocument: Document): Node {\r\n    switch (node.nodeType) {\r\n      case Node.ELEMENT_NODE: // element node\r\n        const asElement = node as Element;\r\n        const tagName = Xml2html.getTagNameFromNode(node);\r\n\r\n        if (!tagName || tagName === '') {\r\n          throw new Error(`no tagname in ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n        }\r\n\r\n        // create element node\r\n        const newElement = targetDocument.createElement(tagName);\r\n\r\n        // append child elements recursive\r\n        const children = asElement.childNodes;\r\n        if (children.length === 0 && !asElement.classList.contains(Xml2html.NoClosingTagClassName)) {\r\n          newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags\r\n        } else {\r\n          for (let i = 0; i < children.length; ++i) {\r\n            const childAsHtml = this.GetXmlElementFromHtmlElement(children[i], targetDocument);\r\n            if (childAsHtml !== undefined) {\r\n              newElement.appendChild(childAsHtml);\r\n            }\r\n          }\r\n        }\r\n\r\n        // // insert attributes\r\n        this.attributeWorker.writeAllHtmlAttributesToXml(asElement, newElement);\r\n\r\n        return newElement;\r\n\r\n      case Node.TEXT_NODE: // text node\r\n        const content = (node as Element).textContent;\r\n        if (content.length > 0) {\r\n          return targetDocument.createTextNode(content);\r\n        } else {\r\n          return undefined;\r\n        }\r\n\r\n      default:\r\n        // tslint:disable-next-line:max-line-length\r\n        throw new Error(`unknown html element nodeType ${node.nodeType} in value: ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n    }\r\n  }\r\n}\r\n","import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { XmlEditorConfig } from './code/xmlEditorConfig';\r\nimport { XMLCursorPositions } from './code/cursor/xmlCursorPos.class';\r\nimport { DomDummyNodeManager } from './code/dummyNodes/domDummyNodeManager.class';\r\nimport { Component, OnChanges, Input, ViewChild, Output, EventEmitter, Renderer2, forwardRef, ViewEncapsulation, OnDestroy, ElementRef } from '@angular/core';\r\nimport { AngularXmlEditorService } from './angular-xml-editor.service';\r\nimport { XmlEditorContext } from './code/xmlEditorContext.class';\r\nimport { Xml2html } from './code/xml-html-converter/xml2html.class';\r\nimport { Html2xml } from './code/xml-html-converter/html2xml.class';\r\nimport { DebugContext } from '@angular/core/src/view';\r\n\r\n@Component({\r\n  selector: 'axed-editor',\r\n  templateUrl: './angular-xml-editor.component.html',\r\n  styleUrls: ['./angular-xml-editor.component.scss'],\r\n  encapsulation: ViewEncapsulation.None, // to prevent the scss to rename the class names and not match the new generated xml dom\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => AngularXmlEditorComponent),\r\n      multi: true\r\n    }\r\n  ]\r\n})\r\nexport class AngularXmlEditorComponent implements ControlValueAccessor, OnChanges, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n  isDebugMode = false;\r\n\r\n  @Input('config')\r\n  get config(): XmlEditorConfig {\r\n    if (this.editorContext !== undefined && this.editorContext.config !== undefined) {\r\n      return this.editorContext && this.editorContext.config;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n  }\r\n\r\n  @Input('debugMode')\r\n  set debugMode(value: boolean) {\r\n    this.isDebugMode = value;\r\n  }\r\n\r\n  @ViewChild('editor')\r\n  textArea: ElementRef;\r\n  @ViewChild('editorWrapper')\r\n  editorWrapper: ElementRef;\r\n\r\n  @Output()\r\n  public valueChange = new EventEmitter();\r\n\r\n  // actualXmlCursor: XmlCursor = new XmlCursor();\r\n  domDummyNodeManager = new DomDummyNodeManager();\r\n\r\n  private onTouchedFunction: () => void;\r\n  private onChangeFunction: (value: string) => void;\r\n\r\n  constructor(private _renderer: Renderer2, private editorService: AngularXmlEditorService) {}\r\n\r\n  ngOnChanges() {}\r\n\r\n  ngOnDestroy(): void {}\r\n\r\n  onLostFocus() {\r\n    this.editorContext.saveSelection(); // save selection on lost focus\r\n    if (typeof this.onTouchedFunction === 'function') {\r\n      this.onTouchedFunction();\r\n    }\r\n    return;\r\n  }\r\n\r\n  onGotFocus() {\r\n    this.editorContext.restoreSelection();\r\n    this.textArea.nativeElement.focus(); // set focus to the text area\r\n  }\r\n\r\n  clicked() {}\r\n\r\n  mousedown() {}\r\n\r\n  mouseup(mouseEvent: MouseEvent) {\r\n    return this.editorContext.mouseUp(mouseEvent);\r\n  }\r\n\r\n  pasted(text: string): boolean {\r\n    return this.editorContext.pasted(text);\r\n  }\r\n\r\n  copied(): boolean {\r\n    return this.editorContext.copied();\r\n  }\r\n\r\n  keyDown(event: KeyboardEvent): boolean {\r\n    return this.editorContext.keyDown(event);\r\n  }\r\n\r\n  keyUp(event: KeyboardEvent): boolean {\r\n    return this.editorContext.keyUp(event);\r\n  }\r\n\r\n  // exec(): boolean {\r\n  //   let userSelection: Selection;\r\n  //   if (window.getSelection) {\r\n  //     userSelection = window.getSelection();\r\n  //     this.editorBreadCrumb.showSelection(userSelection);\r\n  //     this.actualXmlCursor.StartPos.SetCursor(userSelection.anchorNode, XMLCursorPositionen.CursorInsideTextNode, userSelection.anchorOffset);\r\n  //     this.commander.setCursorPos(this.actualXmlCursor.StartPos);\r\n  //   }\r\n\r\n  //   this.domDummyNodeManager.UpdateDummyNodes(this.actualXmlCursor.xmlDocumentRootNode, false);\r\n\r\n  //   return false;\r\n  // }\r\n\r\n  showXml(xml: string): void {\r\n    if (this.textArea && this.editorContext && this.editorContext.config && this.editorContext.config.rules) {\r\n      if (xml === undefined) {\r\n        return;\r\n      }\r\n\r\n      const xml2html = new Xml2html(this.editorContext.config.rules);\r\n      const html = xml2html.ToHtml(xml);\r\n      const normalizedValue = xml === null ? '' : html;\r\n      this._renderer.setProperty(this.textArea.nativeElement, 'innerHTML', normalizedValue);\r\n    }\r\n  }\r\n\r\n  /* START OF ControlValueAccessor  (see https://angular.io/api/forms/ControlValueAccessor ) */\r\n\r\n  /**\r\n   * Sets the function called when the control gets a change event\r\n   */\r\n  registerOnChange(func: any): void {\r\n    this.onChangeFunction = func;\r\n  }\r\n\r\n  /**\r\n   * Sets the function called when the control gets a touch event\r\n   */\r\n  registerOnTouched(func: any): void {\r\n    this.onTouchedFunction = func;\r\n  }\r\n\r\n  /**\r\n   * Write the new value to the element\r\n   */\r\n  writeValue(value: any): void {\r\n    if (this.editorContext && this.editorContext.config) {\r\n      if (value === null || value === undefined || value === '') {\r\n        value = undefined;\r\n      }\r\n\r\n      this.showXml(value);\r\n\r\n      if (value === undefined) {\r\n        this.editorContext.actualCursor.xmlDocumentRootNode = undefined;\r\n      } else {\r\n        const el = this.textArea.nativeElement as Element;\r\n        const node = el.firstChild as Element;\r\n        this.editorContext.actualCursor.xmlDocumentRootNode = node;\r\n        this.editorContext.actualCursor.StartPos.SetCursor(this.editorContext.actualCursor.xmlDocumentRootNode, XMLCursorPositions.CursorOnCompleteNode);\r\n        this.domDummyNodeManager.UpdateDummyNodes(this.editorContext.actualCursor.xmlDocumentRootNode);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Executed from the contenteditable section while the input property changes\r\n   * @param html html string from contenteditable\r\n   */\r\n  onContentChange(html: string): void {\r\n    if (typeof this.onChangeFunction === 'function') {\r\n      const html2xml = new Html2xml(this.editorContext.config.rules);\r\n      const xml = html2xml.ToXml(html);\r\n      const normalizedValue = xml === null ? '' : xml;\r\n      this.onChangeFunction(normalizedValue);\r\n    }\r\n    return;\r\n  }\r\n\r\n  /**\r\n   * sets the disabled state for this element\r\n   */\r\n  setDisabledState(isDisabled: boolean): void {\r\n    const div = this.textArea.nativeElement;\r\n    const action = isDisabled ? 'addClass' : 'removeClass';\r\n    this._renderer[action](div, 'disabled');\r\n  }\r\n\r\n  /* END OF ControlValueAccessor */\r\n}\r\n","export class XmlRuleElement {\r\n  public tagName: string;\r\n  public empty: boolean;\r\n  public floating: boolean;\r\n\r\n  public static Sorted(elements: XmlRuleElement[]): XmlRuleElement[] {\r\n    const result = elements.sort((e1, e2) => {\r\n      if (e1.tagName > e2.tagName) {\r\n        return 1;\r\n      }\r\n      if (e1.tagName < e2.tagName) {\r\n        return -1;\r\n      }\r\n      return 0;\r\n    });\r\n    return result;\r\n  }\r\n\r\n  public constructor(init?: Partial<XmlRuleElement>) {\r\n    Object.assign(this, init);\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlEditRuleCheckElements {\r\n  constructor(private xsdNodes: Map<string, Element>) {}\r\n\r\n  ElementsAllowedAtThisCursorPos(cursorPosToCheck: XmlCursorPos): string[] {\r\n    if (!cursorPosToCheck) {\r\n      return [];\r\n    }\r\n    const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);\r\n    const parentName = Xml2html.getTagNameFromNode(parentNode);\r\n    const xsdNode = this.xsdNodes.get(parentName);\r\n    if (xsdNode) {\r\n      const result = this.getSubElementNames(xsdNode, []);\r\n      return result;\r\n    } else {\r\n      // console.warn('element \"' + parentName + '\" not found');\r\n      return [];\r\n    }\r\n  }\r\n\r\n  getRelevantParentNodeForCursorPos(cursorPosToCheck: XmlCursorPos): Node {\r\n    if (cursorPosToCheck) {\r\n      let parentNode = cursorPosToCheck.ActualNode;\r\n\r\n      switch (parentNode.nodeType) {\r\n        case Node.COMMENT_NODE:\r\n        case Node.TEXT_NODE:\r\n          parentNode = parentNode.parentElement;\r\n          break;\r\n\r\n        case Node.ELEMENT_NODE:\r\n          switch (cursorPosToCheck.PosAtNode) {\r\n            case XMLCursorPositions.CursorInEmptyNode:\r\n            case XMLCursorPositions.CursorInsideTextNode:\r\n              break;\r\n\r\n            case XMLCursorPositions.CursorBehindNode:\r\n            case XMLCursorPositions.CursorInFrontOfNode:\r\n            case XMLCursorPositions.CursorOnCompleteNode:\r\n              parentNode = parentNode.parentElement;\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unhandled  cursorPosToCheck.PosAmNode \"${cursorPosToCheck.PosAtNode}\"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}\" `);\r\n          }\r\n          break;\r\n\r\n        default:\r\n          throw new Error(`unhandled  parentNode.nodeType \"${parentNode.nodeType}\"`);\r\n      }\r\n      return parentNode;\r\n    }\r\n  }\r\n\r\n  public getSubElementNames(xsdNode: Node, alreadyAddedElementNames: string[], depth: number = 0): string[] {\r\n    let elementNames: string[] = [];\r\n    let elementName: string;\r\n\r\n    if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n      const asElem = xsdNode as Element;\r\n      if (asElem) {\r\n        if (asElem.localName === 'element') {\r\n          elementName = asElem.getAttribute('name');\r\n        }\r\n      }\r\n    }\r\n\r\n    if (elementName) {\r\n      // console.warn('found: ' + JSON.stringify(elementName) + ' depth: ' + depth);\r\n      if (alreadyAddedElementNames.length !== 0) {\r\n        if (alreadyAddedElementNames.indexOf(elementName) !== -1) {\r\n          return elementNames; // element recursion detected\r\n        }\r\n        if (depth === 0) {\r\n          // is the parent element itself - skip!\r\n        } else {\r\n          elementNames = elementNames.concat(elementName);\r\n          return elementNames;\r\n        }\r\n      }\r\n      alreadyAddedElementNames.push(elementName);\r\n    }\r\n\r\n    const childNodes = Array.prototype.slice.call(xsdNode.childNodes) as Node[];\r\n\r\n    depth++;\r\n\r\n    childNodes.forEach(child => {\r\n      if (child.nodeType === Node.ELEMENT_NODE) {\r\n        const childElem = child as Element;\r\n        if (childElem) {\r\n          switch (childElem.localName) {\r\n            case 'complexType':\r\n            case 'sequence':\r\n            case 'choice':\r\n            case 'simpleContent':\r\n            case 'extension':\r\n              elementNames = elementNames.concat(this.getSubElementNames(child, alreadyAddedElementNames, depth));\r\n              break;\r\n\r\n            case 'element':\r\n              const refname = childElem.attributes.getNamedItem('ref');\r\n              if (refname) {\r\n                const referedNode = this.xsdNodes.get(refname.value);\r\n                if (referedNode) {\r\n                  elementNames = elementNames.concat(this.getSubElementNames(referedNode, alreadyAddedElementNames, depth));\r\n                } else {\r\n                  throw new Error(` refered element \"${refname}\" for element \"${childElem.outerHTML}\" not found`);\r\n                }\r\n              } else {\r\n                elementNames = elementNames.concat(this.getSubElementNames(child, alreadyAddedElementNames, depth));\r\n              }\r\n              break;\r\n\r\n            case 'attribute':\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unknown childElem.localname \"${childElem.localName}\"/${childElem.outerHTML}`);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return elementNames;\r\n  }\r\n}\r\n","import { Component, EventEmitter, Output, Renderer2, Input, AfterViewInit, OnChanges, OnDestroy } from '@angular/core';\r\nimport { XmlRuleElement } from '../../code/xml-rules-check/xmlRuleElement.class';\r\nimport { XmlCursorPos } from '../../code/cursor/xmlCursorPos.class';\r\nimport { XmlEditRuleCheckElements } from '../../code/xml-rules-check/xmlEditRuleCheckElements.class';\r\nimport { AngularXmlEditorService } from '../../angular-xml-editor.service';\r\nimport { Subscription } from 'rxjs';\r\nimport { XmlEditorContext } from '../../code/xmlEditorContext.class';\r\nimport { XmlEditorConfig } from '../../code/xmlEditorConfig';\r\nimport { Xml2html } from '../../code/xml-html-converter/xml2html.class';\r\n\r\n@Component({\r\n  selector: 'axed-toolbar',\r\n  templateUrl: './xml-editor-toolbar.component.html',\r\n  styleUrls: ['./xml-editor-toolbar.component.scss']\r\n})\r\nexport class XmlEditorToolbarComponent implements AfterViewInit, OnChanges, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n\r\n  @Input('config')\r\n  get config(): XmlEditorConfig {\r\n    if (this.editorContext !== undefined && this.editorContext.config !== undefined) {\r\n      return this.editorContext && this.editorContext.config;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n    this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(pos => {\r\n      this.elementGroups = this.GetElementGroupsForCursorPos(pos.StartPos);\r\n    });\r\n  }\r\n\r\n  elementGroups: ToolbarElementGroup[] = [];\r\n\r\n  actualCursorPosChangedSubscription: Subscription;\r\n\r\n  /** inserts an element at the actual cursor pos */\r\n  insertElement(element: XmlRuleElement) {\r\n    const html = new Xml2html(this.editorContext.config.rules).createNewElementHtml(element);\r\n    this.editorContext.domInsertHtml(html);\r\n  }\r\n\r\n  constructor(private editorService: AngularXmlEditorService) {}\r\n\r\n  ngAfterViewInit(): void {}\r\n  ngOnChanges(): void {}\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChangedSubscription.unsubscribe();\r\n  }\r\n\r\n  GetElementGroupsForCursorPos(pos: XmlCursorPos): ToolbarElementGroup[] {\r\n    const allowedElements = new XmlEditRuleCheckElements(this.editorContext.config.xmlSchema.xsdNodes).ElementsAllowedAtThisCursorPos(pos);\r\n\r\n    return this.GetAllElementGroups()\r\n      .map(g => {\r\n        return {\r\n          title: g.title,\r\n          elements: g.elements.filter(e => allowedElements.includes(e.tagName))\r\n        } as ToolbarElementGroup;\r\n      })\r\n      .filter(g => g.elements.length > 0);\r\n  }\r\n\r\n  GetAllElementGroups(): ToolbarElementGroup[] {\r\n    const unusedElements = XmlRuleElement.Sorted(\r\n      Array.from(this.editorContext.config.rules.ruleElements.values()).filter(elem =>\r\n        this.editorContext.config.elementGroups.some(group => !group.elementNames.includes(elem.tagName))\r\n      )\r\n    );\r\n\r\n    const otherElementsGroup = {\r\n      title: 'other',\r\n      elements: unusedElements\r\n    } as ToolbarElementGroup;\r\n\r\n    return this.editorContext.config.elementGroups\r\n      .map(g => {\r\n        return {\r\n          title: g.title,\r\n          elements: XmlRuleElement.Sorted(g.elementNames.map(elementName => this.editorContext.config.rules.ruleElements.get(elementName)).filter(e => e !== undefined))\r\n        } as ToolbarElementGroup;\r\n      })\r\n      .concat(otherElementsGroup)\r\n      .filter(g => g.elements.length !== 0);\r\n  }\r\n}\r\n\r\nexport interface ToolbarElementGroup {\r\n  title: string;\r\n  elements: XmlRuleElement[];\r\n}\r\n","export class XmlRuleAttribut {\r\n  public attribName: string;\r\n\r\n  public required: boolean;\r\n\r\n  /** when the values are from a given list **/\r\n  public fixedValues: string[];\r\n\r\n  public defaultValue: string;\r\n\r\n  public xsdRawNode: Node;\r\n\r\n  public typ: RuleAttributeTypes;\r\n\r\n  public constructor(init?: Partial<XmlRuleAttribut>) {\r\n    Object.assign(this, init);\r\n    this.typ = this.getTyp();\r\n  }\r\n\r\n  getTyp(): RuleAttributeTypes {\r\n    if (this.fixedValues && this.fixedValues.length > 0) {\r\n      return RuleAttributeTypes.Enum;\r\n    }\r\n    return RuleAttributeTypes.String;\r\n  }\r\n}\r\n\r\nexport enum RuleAttributeTypes {\r\n  String = 0,\r\n  Enum = 1,\r\n  Number = 2\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { XmlRuleAttribut } from './xmlRuleAttribut.class';\r\nimport { XmlSchema } from './xmlSchema.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlEditRuleCheckAttributes {\r\n  constructor(private xmlSchema: XmlSchema) {}\r\n\r\n  AttributesAllowedAtThisCursorPos(cursorPosToCheck: XmlCursorPos): XmlRuleAttribut[] {\r\n    if (!cursorPosToCheck) {\r\n      return [];\r\n    }\r\n    const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);\r\n    const parentName = Xml2html.getTagNameFromNode(parentNode);\r\n    return this.getAttributesForElementName(parentName);\r\n  }\r\n\r\n  getRelevantParentNodeForCursorPos(cursorPosToCheck: XmlCursorPos): Node {\r\n    if (cursorPosToCheck) {\r\n      let parentNode = cursorPosToCheck.ActualNode;\r\n\r\n      switch (parentNode.nodeType) {\r\n        case Node.COMMENT_NODE:\r\n        case Node.TEXT_NODE:\r\n          parentNode = parentNode.parentElement;\r\n          break;\r\n\r\n        case Node.ELEMENT_NODE:\r\n          switch (cursorPosToCheck.PosAtNode) {\r\n            case XMLCursorPositions.CursorInEmptyNode:\r\n            case XMLCursorPositions.CursorInsideTextNode:\r\n            case XMLCursorPositions.CursorOnCompleteNode:\r\n              break;\r\n\r\n            case XMLCursorPositions.CursorBehindNode:\r\n            case XMLCursorPositions.CursorInFrontOfNode:\r\n              parentNode = parentNode.parentElement;\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unhandled cursorPosToCheck.PosAmNode \"${cursorPosToCheck.PosAtNode}\"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}\" `);\r\n          }\r\n          break;\r\n\r\n        default:\r\n          throw new Error(`unhandled parentNode.nodeType \"${parentNode.nodeType}\"`);\r\n      }\r\n      return parentNode;\r\n    }\r\n  }\r\n\r\n  getAttributesForElementName(elementName: string): XmlRuleAttribut[] {\r\n    const xsdNode = this.xmlSchema.findXsdNodeForTagName(elementName);\r\n    return this.getAttributesForElement(xsdNode, new Set([xsdNode]));\r\n  }\r\n\r\n  getAttributesForElement(xsdNode: Node, alreadyAddedElements: Set<Node>): XmlRuleAttribut[] {\r\n    let attributes: XmlRuleAttribut[] = [];\r\n\r\n    if (xsdNode) {\r\n      alreadyAddedElements.add(xsdNode);\r\n\r\n      const childNodes = Array.prototype.slice.call(xsdNode.childNodes);\r\n\r\n      childNodes.forEach(child => {\r\n        if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n          const childElem = child as Element;\r\n          if (childElem) {\r\n            if (child.localName === 'attribute') {\r\n              // is attribute\r\n              attributes = attributes.concat([\r\n                new XmlRuleAttribut({\r\n                  attribName: childElem.attributes.getNamedItem('name').value,\r\n                  required: this.isRequiredAttribute(childElem),\r\n                  xsdRawNode: childElem,\r\n                  fixedValues: this.getFixedValues(childElem),\r\n                  defaultValue: this.getDefaultValue(childElem)\r\n                })\r\n              ]);\r\n            } else {\r\n              // no attribute\r\n              if (!alreadyAddedElements.has(child)) {\r\n                const subNodeAttributes = this.getAttributesForElement(child, alreadyAddedElements);\r\n                attributes = attributes.concat(subNodeAttributes);\r\n              } else {\r\n                // Element already added\r\n              }\r\n            }\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    return attributes;\r\n  }\r\n\r\n  /** the default value for this attribute */\r\n  private getDefaultValue(childElem: Element) {\r\n    const attrib = childElem.attributes.getNamedItem('default');\r\n    if (attrib !== null) {\r\n      return attrib.value;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /** is this attribute required? */\r\n  private isRequiredAttribute(childElem: Element) {\r\n    const attrib = childElem.attributes.getNamedItem('use');\r\n    const value = attrib !== null && attrib.value === 'required';\r\n    return value;\r\n  }\r\n\r\n  /** get the allowes values for this attribute */\r\n  private getFixedValues(xsdNode: Element, alreadyChecked: Node[] = []): string[] {\r\n    let values: string[] = [];\r\n\r\n    const childNodes = Array.prototype.slice.call(xsdNode.childNodes);\r\n    childNodes.forEach(child => {\r\n      if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n        const childElem = child as Element;\r\n        if (childElem) {\r\n          if (child.localName === 'enumeration') {\r\n            values = values.concat([childElem.attributes.getNamedItem('value').value]);\r\n          } else {\r\n            // no attribute\r\n            if (alreadyChecked.indexOf(child) === -1) {\r\n              const subNodeAttributes = this.getFixedValues(child, alreadyChecked);\r\n              values = values.concat(subNodeAttributes);\r\n            } else {\r\n              // Element already added\r\n            }\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return values;\r\n  }\r\n}\r\n","import { Component, OnInit, Input, OnDestroy } from '@angular/core';\r\nimport { XmlCursorPos } from '../../code/cursor/xmlCursorPos.class';\r\nimport { XmlEditRuleCheckAttributes } from '../../code/xml-rules-check/xmlEditRuleCheckAttributes.class';\r\nimport { XmlRuleAttribut, RuleAttributeTypes } from '../../code/xml-rules-check/xmlRuleAttribut.class';\r\nimport { AngularXmlEditorService } from '../../angular-xml-editor.service';\r\nimport { Subscription } from 'rxjs';\r\nimport { XmlEditorContext } from '../../code/xmlEditorContext.class';\r\nimport { Xml2htmlAttributeWorker } from '../../code/xml-html-converter/xml2htmlAttributeWorker.class';\r\nimport { Xml2html } from '../../code/xml-html-converter/xml2html.class';\r\n\r\n@Component({\r\n  selector: 'axed-attribute-editor',\r\n  templateUrl: './xml-editor-attribute-editor.component.html',\r\n  styleUrls: ['./xml-editor-attribute-editor.component.scss']\r\n})\r\nexport class XmlEditorAttributeEditorComponent implements OnInit, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n    this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(pos => {\r\n      this.attributes = this.GetAttributesForCursorPos(pos.StartPos);\r\n      this.elementName = this.GetElementNameForCursorPos(pos.StartPos);\r\n    });\r\n  }\r\n\r\n  actualCursorPosChangedSubscription: Subscription;\r\n\r\n  attribTypes = RuleAttributeTypes;\r\n\r\n  attributes: ToolbarAttributData[] = [];\r\n  elementName: string;\r\n  actualElement: Element;\r\n\r\n  constructor(private editorService: AngularXmlEditorService) {}\r\n\r\n  ngOnInit() {}\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChangedSubscription.unsubscribe();\r\n  }\r\n\r\n  attributeValueChanged(key: string, value: string) {\r\n    if (this.actualElement) {\r\n      const attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);\r\n      attribWorker.writeAttributeToHtml(this.actualElement, key, value);\r\n    }\r\n  }\r\n\r\n  GetElementNameForCursorPos(pos: XmlCursorPos): string {\r\n    const rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);\r\n    const parentNode = rulesCheck.getRelevantParentNodeForCursorPos(pos) as Element;\r\n    if (parentNode) {\r\n      return Xml2html.getTagNameFromNode(parentNode);\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  GetAttributesForCursorPos(pos: XmlCursorPos): ToolbarAttributData[] {\r\n    const attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);\r\n    const rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);\r\n    const parentNode = rulesCheck.getRelevantParentNodeForCursorPos(pos) as Element;\r\n    this.actualElement = parentNode;\r\n    if (parentNode) {\r\n      const allowedAttributes = rulesCheck.AttributesAllowedAtThisCursorPos(pos);\r\n      return allowedAttributes.map(a => {\r\n        return {\r\n          rules: a,\r\n          value: attribWorker.getAttributeValueFromHtml(parentNode, a.attribName)\r\n        } as ToolbarAttributData;\r\n      });\r\n    }\r\n    return [];\r\n  }\r\n}\r\n\r\nexport interface ToolbarAttributData {\r\n  rules: XmlRuleAttribut;\r\n  value: string;\r\n}\r\n","import { Component, OnInit, OnDestroy, Input } from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { XmlEditorDebugger } from '../../code/xmlEditorDebugger';\r\nimport { AngularXmlEditorService } from '../../angular-xml-editor.service';\r\nimport { XmlEditorContext } from '../../code/xmlEditorContext.class';\r\n\r\n@Component({\r\n  selector: 'axed-debug',\r\n  templateUrl: './xml-editor-debug.component.html',\r\n  styleUrls: ['./xml-editor-debug.component.scss']\r\n})\r\nexport class XmlEditorDebugComponent implements OnInit, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n    this.actualCursorPosChangedSubscription = this.editorContext.debugService.actualCursorPosChanged$.subscribe(pos => {\r\n      this.cursorPosInfo = pos.StartPos.getDebugDescription();\r\n    });\r\n    this.inputSelectionSubscription = this.editorContext.debugService.inputSelectionChanged$.subscribe(info => {\r\n      this.inputSelection = info;\r\n    });\r\n  }\r\n\r\n  cursorPosInfo: string;\r\n  inputSelection: string;\r\n\r\n  private actualCursorPosChangedSubscription: Subscription;\r\n  private inputSelectionSubscription: Subscription;\r\n\r\n  constructor(private editorService: AngularXmlEditorService) {}\r\n\r\n  ngOnInit() {}\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChangedSubscription.unsubscribe();\r\n    this.inputSelectionSubscription.unsubscribe();\r\n  }\r\n}\r\n","import { Component, OnInit } from '@angular/core';\r\n\r\n@Component({\r\n  selector: 'axed-dom-breakcrumb',\r\n  templateUrl: './dom-breakcrumb.component.html',\r\n  styleUrls: ['./dom-breakcrumb.component.css']\r\n})\r\nexport class DomBreakcrumbComponent implements OnInit {\r\n  nodes: string[] = [];\r\n\r\n  constructor() {}\r\n\r\n  ngOnInit() {}\r\n\r\n  showSelection(selection: Selection) {\r\n    if (selection === undefined) {\r\n      this.nodes = ['none'];\r\n    } else {\r\n      const collectNodes = [];\r\n      let node = selection.focusNode;\r\n      let reachedTop = node === undefined || node === null;\r\n      while (!reachedTop) {\r\n        switch (node.nodeType) {\r\n          case Node.ELEMENT_NODE: // element node\r\n            const asElement = node as Element;\r\n            if (asElement !== undefined) {\r\n              const name = asElement.getAttribute('data-tagname');\r\n              if (asElement.className === 'sws-xml-editor-textarea') {\r\n                reachedTop = true;\r\n              } else {\r\n                collectNodes.unshift(name);\r\n              }\r\n            }\r\n        }\r\n        node = node.parentElement;\r\n        if (node === undefined || node == null) {\r\n          reachedTop = true;\r\n        }\r\n      }\r\n      this.nodes = collectNodes;\r\n    }\r\n  }\r\n}\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { AngularXmlEditorComponent } from './angular-xml-editor.component';\r\nimport { XmlEditorToolbarComponent } from './components/xml-editor-toolbar/xml-editor-toolbar.component';\r\nimport { XmlEditorAttributeEditorComponent } from './components/xml-editor-attribute-editor/xml-editor-attribute-editor.component';\r\nimport { XmlEditorDebugComponent } from './components/xml-editor-debug/xml-editor-debug.component';\r\nimport { DomBreakcrumbComponent } from './components/dom-breakcrumb/dom-breakcrumb.component';\r\nimport { ReactiveFormsModule, FormsModule } from '@angular/forms';\r\n\r\n@NgModule({\r\n  imports: [CommonModule, FormsModule, ReactiveFormsModule],\r\n  declarations: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent],\r\n  exports: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent]\r\n})\r\nexport class AngularXmlEditorModule {}\r\n","export class XmlSchema {\r\n  public constructor(public xsdNodes: Map<string, Element>) {}\r\n\r\n  findXsdNodeForTagName(tagName: string): Node {\r\n    return this.xsdNodes.get(tagName);\r\n  }\r\n}\r\n","import { XmlSchema } from './xmlSchema.class';\r\n\r\nexport class XmlSchemaLoader {\r\n  public xmlSchema: XmlSchema;\r\n\r\n  public constructor(schemaContent: string) {\r\n    if (!schemaContent || schemaContent === '') {\r\n      return;\r\n    }\r\n    const domparser = new DOMParser();\r\n    const schemaDom = domparser.parseFromString(schemaContent, 'text/xml');\r\n    // const rawElements = Array.from(schemaDom.documentElement.childNodes) as Element[];\r\n    // this.xmlSchema = new XmlSchema(this.getXsdNodes(rawElements));\r\n\r\n    let result: Node[] = [];\r\n    const rawElementsAtRoot = Array.from(schemaDom.documentElement.childNodes) as Element[];\r\n    rawElementsAtRoot.forEach(e => {\r\n      const subChilds = this.getRawElements(e);\r\n      result = result.concat(subChilds);\r\n    });\r\n    this.xmlSchema = new XmlSchema(this.getXsdNodes(result as Element[]));\r\n  }\r\n\r\n  private getRawElements(node: Node): Node[] {\r\n    let result: Node[] = [];\r\n    if (this.isValidXsdNode(node)) {\r\n      result = result.concat(node);\r\n    }\r\n\r\n    const children = Array.from(node.childNodes) as Node[];\r\n    children.forEach(child => {\r\n      result = result.concat(this.getRawElements(child));\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  private isValidXsdNode(node: Node): boolean {\r\n    const allowedXsdTypes = ['element', 'group', 'complexType'];\r\n    const asElem = node as Element;\r\n\r\n    if (asElem) {\r\n      if (allowedXsdTypes.includes(asElem.localName)) {\r\n        if (asElem.attributes.getNamedItem('name')) {\r\n          // console.warn(asElem.attributes.getNamedItem('name').value);\r\n          return true;\r\n        } else {\r\n          return false;\r\n        }\r\n      } else {\r\n        return false;\r\n      }\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private getXsdNodes(rawElements: Element[]) {\r\n    // console.warn(rawElements.length);\r\n    return new Map(rawElements.map<[string, Element]>(n => [n.attributes.getNamedItem('name').value, n as Element]));\r\n  }\r\n}\r\n","import { XmlRuleElement } from './xmlRuleElement.class';\r\n\r\nexport class XmlRules {\r\n  public constructor(public ruleElements: Map<string, XmlRuleElement>) {}\r\n}\r\n","import { XmlRuleElement } from './xmlRuleElement.class';\r\nimport { XmlEditRuleCheckTextInsert } from './xmlEditRuleCheckTextInsert.class';\r\nimport { XmlRules } from './xmlRules.class';\r\nimport { XmlSchema } from './xmlSchema.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlRulesCreator {\r\n  public rules: XmlRules;\r\n\r\n  public constructor(private schema: XmlSchema, private _floatingElementNames: string[]) {\r\n    this.rules = new XmlRules(this.getAllElementRuleNodes(Array.from(this.schema.xsdNodes.values())));\r\n  }\r\n\r\n  private findXsdNodeForHtmlNode(node: Node): Node {\r\n    const tagName = Xml2html.getTagNameFromNode(node);\r\n    return this.schema.xsdNodes.get(tagName);\r\n  }\r\n\r\n  private getAllElementRuleNodes(xsdNodes: Element[]) {\r\n    return new Map(xsdNodes.map<[string, XmlRuleElement]>(xsdNode => [xsdNode.attributes.getNamedItem('name').value, this.getRuleElementForXsdNode(xsdNode)]));\r\n  }\r\n\r\n  private getRuleElementForXsdNode(xsdNode: Element): XmlRuleElement {\r\n    if (xsdNode) {\r\n      const tagName = xsdNode.attributes.getNamedItem('name').value;\r\n      return new XmlRuleElement({\r\n        tagName: tagName,\r\n        floating: this.isFloating(tagName),\r\n        empty: this.isEmpty(xsdNode)\r\n        // xsdRawNode: xsdNode,\r\n      });\r\n    } else {\r\n      return undefined;\r\n    }\r\n  }\r\n\r\n  private isEmpty(xsdNode: Node): boolean {\r\n    if (new XmlEditRuleCheckTextInsert(this.schema.xsdNodes).isTextAllowedInThisElement(xsdNode) === true) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  private isFloating(tagName: string): boolean {\r\n    return this._floatingElementNames.includes(tagName);\r\n  }\r\n}\r\n"],"names":[],"mappings":"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"}