highmark-markdown 1.0.7 → 1.0.10

package/src/node/markdown/hyperlink.js

@@ -63,31 +63,62 @@ class HyperlinkLinkMarkdownNode extends MarkdownNode {
     return attributeValue;
   }
 
-  childNodesAsHTML(indent, context) {
-    let childNodesHTML;
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.domElement = this.createDOMElement(context);
+
+    if (siblingDOMElement !== null) {
+      siblingDOMElement = siblingDOMElement.nextSibling;  ///
+    }
+
+    parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
+
+    siblingDOMElement = this.domElement;  ///
+
+    return siblingDOMElement;
+  }
+
+  createDOMElement(context) {
+    let content;
 
     const inlineText = this.inlineText(context);
 
     if (inlineText !== null) {
-      childNodesHTML = inlineText;  ///
+      content = inlineText; ///
     } else {
-      const content = this.content(context);
-
-      childNodesHTML = content; ///
+      content = this.content(context);
     }
 
-    return childNodesHTML;
+    let domElement;
+
+    const textNode = document.createTextNode(content);
+
+    domElement = super.createDOMElement(context);
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
   }
 
-  createChildNodeDOMElements(context) {
-    const inlineText = this.inlineText(context),
-          content = (inlineText !== null) ?
-                      inlineText :
-                        this.content(context),
-          textNode = document.createTextNode(content),
-          domElement = textNode;  ///
+  childNodesAsHTML(indent, context) {
+    let content;
+
+    const inlineText = this.inlineText(context);
 
-    this.addDOMElement(domElement);
+    if (inlineText !== null) {
+      content = inlineText;  ///
+    } else {
+      content = this.content(context);
+    }
+
+    const childNodesHTML = content; ///
+
+    return childNodesHTML;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(HyperlinkLinkMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/image.js

@@ -57,8 +57,6 @@ export default class ImageMarkdownNode extends MarkdownNode {
       domElement.setAttribute(attributeName, attributeValue);
     });
 
-    this.setDOMElement(domElement);
-
     return domElement;
   }
 

package/src/node/markdown/indexLink.js

@@ -23,6 +23,25 @@ export default class IndexLinkMarkdownNode extends MarkdownNode {
     return attributeValue;
   }
 
+  createDOMElement(context) {
+    let domElement;
+
+    const content = this.content(context),
+          textNode = document.createTextNode(content);
+
+    domElement = super.createDOMElement(context);
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
+  }
+
   asHTML(indent, context) {
     const childNodesHTML = this.childNodesAsHTML(indent, context),
           startingTag = this.startingTag(context),

package/src/node/markdown/inlineListing.js

@@ -6,25 +6,35 @@ import contentMixins from "../../mixins/content";
 import { removeBackticks } from "../../utilities/string";
 
 class InlineListingMarkdownNode extends MarkdownNode {
-  childNodesAsHTML(indent, context) {
-    let content = this.content(context);
+  createDOMElement(context) {
+    let domElement,
+        content = this.content(context);
 
     content = removeBackticks(content); ///
 
-    const childNodesHTML = content; ///
+    const textNode = document.createTextNode(content);
 
-    return childNodesHTML;
+    domElement = super.createDOMElement(context);
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
   }
 
-  createChildNodeDOMElements(context) {
+  childNodesAsHTML(indent, context) {
     let content = this.content(context);
 
     content = removeBackticks(content); ///
 
-    const textNode = document.createTextNode(content),
-          domElement = textNode; ///
+    const childNodesHTML = content; ///
 
-    this.addDOMElement(domElement);
+    return childNodesHTML;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(InlineListingMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/inlineText.js

@@ -16,8 +16,6 @@ class InlineTextMarkdownNode extends MarkdownNode {
           textNode = document.createTextNode(content),
           domElement = textNode;  ///
 
-    this.setDOMElement(domElement);
-
     return domElement;
   }
 

package/src/node/markdown/line.js

@@ -28,18 +28,32 @@ export default class LineMarkdownNode extends MarkdownNode {
     return html;
   }
 
-  createDOMElement(context) {
-    const tagName = this.tagName(context),
-          className = this.className(context),
-          domElement = document.createElement(tagName);
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.domElement = this.createDOMElement(context);
 
-    Object.assign(domElement, {
-      className
-    });
+    if (siblingDOMElement !== null) {
+      siblingDOMElement = siblingDOMElement.nextSibling;  ///
+    }
+
+    parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
+
+    siblingDOMElement = this.domElement;  ///
+
+    return siblingDOMElement;
+  }
+
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          childNodes = this.getChildNodes(),
+          domElements = domElementsFromChildNodes(childNodes, context),
+          parentDOMElement = domElement,  ///
+          childNodeDOMElements = domElements; ///
 
-    this.setDOMElement(domElement);
+    childNodeDOMElements.forEach((childNodeDOMElement) => {
+      const domElement = childNodeDOMElement; ///
 
-    this.createChildNodeDOMElements(context);
+      parentDOMElement.appendChild(domElement);
+    });
 
     return domElement;
   }
@@ -58,19 +72,5 @@ export default class LineMarkdownNode extends MarkdownNode {
     return plainText;
   }
 
-  createChildNodeDOMElements(context) {
-    const domElement = this.getDOMElement(),
-          childNodes = this.getChildNodes(),
-          domElements = domElementsFromChildNodes(childNodes, context),
-          parentDOMElement = domElement,  ///
-          childNodeDOMElements = domElements; ///
-
-    childNodeDOMElements.forEach((childNodeDOMElement) => {
-      const domElement = childNodeDOMElement; ///
-
-      parentDOMElement.appendChild(domElement);
-    });
-  }
-
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(LineMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/strongText.js

@@ -1,12 +1,48 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import MarkdownNode from "../../node/markdown";
 import contentMixins from "../../mixins/content";
 
+const { second } = arrayUtilities;
+
 class StrongTextMarkdownNode extends MarkdownNode {
+  inlineText(context) {
+    const indent = null,
+      childNodes = this.getChildNodes(),
+      secondChildNode = second(childNodes),
+      inlineTextMarkdownNode = secondChildNode, ///
+      inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
+      inlineText = inlineTextMarkdownNodeHTML;  ///
+
+    return inlineText;
+  }
+
+  createDOMElement(context) {
+    const inlineText = this.inlineText(context),
+      content = inlineText; ///
+
+    let domElement;
+
+    const textNode = document.createTextNode(content);
+
+    domElement = super.createDOMElement(context);
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(StrongTextMarkdownNode, ruleName, childNodes, opacity); }
 }
 
 Object.assign(StrongTextMarkdownNode.prototype, contentMixins);
 
-export default StrongTextMarkdownNode;
+export default StrongTextMarkdownNode;

package/src/node/markdown/stronglyEmphasisedText.js

@@ -1,36 +1,58 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import elementMap from "../../elementMap";
 import MarkdownNode from "../../node/markdown";
 import contentMixins from "../../mixins/content";
 
 import { STRONG_TEXT_RULE_NAME } from "../../ruleNames";
 
-const { tagName } = elementMap[STRONG_TEXT_RULE_NAME];
+const { second } = arrayUtilities,
+      { tagName } = elementMap[STRONG_TEXT_RULE_NAME];
 
 class StronglyEmphasisedTextMarkdownNode extends MarkdownNode {
-  asHTML(indent, context) {
-    let html = super.asHTML(indent, context);
+  inlineText(context) {
+    const indent = null,
+          childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          inlineTextMarkdownNode = secondChildNode, ///
+          inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
+          inlineText = inlineTextMarkdownNodeHTML;  ///
+
+    return inlineText;
+  }
 
-    const childNodesHTML = html,  ///
-          startingTag = `<${tagName}>`,
-          closingTag = `</${tagName}>`;
+  createDOMElement(context) {
+    let domElement;
 
-    html = `${startingTag}${childNodesHTML}${closingTag}`;
+    domElement = document.createElement(tagName);
 
-    return html;
+    const parentDOMElement = domElement,  ///
+          childDOMElement = this.createChildDOMElement(context);
+
+    domElement = childDOMElement; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
   }
 
-  createDOMElement(context) {
+  createChildDOMElement(context) {
+    const inlineText = this.inlineText(context),
+          content = inlineText; ///
+
     let domElement;
 
-    domElement = document.createElement(tagName);
+    const textNode = document.createTextNode(content);
 
-    this.setDOMElement(domElement);
+    domElement = super.createDOMElement(context);
 
     const parentDOMElement = domElement;  ///
 
-    domElement = super.createDOMElement(context);
+    domElement = textNode; ///
 
     parentDOMElement.appendChild(domElement);
 
@@ -39,9 +61,21 @@ class StronglyEmphasisedTextMarkdownNode extends MarkdownNode {
     return domElement;
   }
 
+  asHTML(indent, context) {
+    let html = super.asHTML(indent, context);
+
+    const childNodesHTML = html,  ///
+          startingTag = `<${tagName}>`,
+          closingTag = `</${tagName}>`;
+
+    html = `${startingTag}${childNodesHTML}${closingTag}`;
+
+    return html;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(StronglyEmphasisedTextMarkdownNode, ruleName, childNodes, opacity); }
 }
 
 Object.assign(StronglyEmphasisedTextMarkdownNode.prototype, contentMixins);
 
-export default StronglyEmphasisedTextMarkdownNode;
+export default StronglyEmphasisedTextMarkdownNode;

package/src/node/markdown/subDivision.js

@@ -31,13 +31,6 @@ export default class SubDivisionMarkdownNode extends MarkdownNode {
     }
   }
 
-  getDOMElement() {
-    const secondMarkdownNode = this.getSecondMarkdownNode(),
-          domElement = secondMarkdownNode.getDOMElement();
-
-    return domElement;
-  }
-
   lines(context) {
     const secondMarkdownNode = this.getSecondMarkdownNode(),
           lines = secondMarkdownNode.lines(context);
@@ -59,15 +52,6 @@ export default class SubDivisionMarkdownNode extends MarkdownNode {
     return plainText;
   }
 
-  createDOMElement(context) {
-    const secondMarkdownNode = this.getSecondMarkdownNode(),
-          domElement = null;
-
-    secondMarkdownNode.createDOMElement(context);
-
-    return domElement;
-  }
-
   getSecondMarkdownNode() {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),

package/src/node/markdown/tableBodyCell.js

@@ -16,14 +16,5 @@ export default class TableBodyCellMarkdownNode extends MarkdownNode {
     return childNodesHTML;
   }
 
-  createChildNodeDOMElements(context) {
-    const domElement = this.getDOMElement(),
-          childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          tableCellMarkdownNode = firstChildNode; ///
-
-    tableCellMarkdownNode.createChildNodeDOMElements(domElement, context);
-  }
-
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(TableBodyCellMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/tableCell.js

@@ -17,19 +17,5 @@ export default class TableCellMarkdownNode extends MarkdownNode {
     return childNodesHTML;
   }
 
-  createChildNodeDOMElements(domElement, context) {
-    const childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          lineMarkdownNode = firstChildNode;  ///
-
-    lineMarkdownNode.createDOMElement(context);
-
-    const parentDOMElement = domElement;  ///
-
-    domElement = lineMarkdownNode.getDOMElement();
-
-    parentDOMElement.appendChild(domElement)
-  }
-
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(TableCellMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/tableHeadCell.js

@@ -16,14 +16,5 @@ export default class TableHeadCellMarkdownNode extends MarkdownNode {
     return childNodesHTML;
   }
 
-  createChildNodeDOMElements(context) {
-    const domElement = this.getDOMElement(),
-          childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          tableCellMarkdownNode = firstChildNode; ///
-
-    tableCellMarkdownNode.createChildNodeDOMElements(domElement, context);
-  }
-
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(TableHeadCellMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/verticalSpace.js

@@ -5,21 +5,19 @@ import MarkdownNode from "../../node/markdown";
 import { CARRIAGE_RETURN } from "../../constants";
 
 export default class VerticalSpaceMarkdownNode extends MarkdownNode {
-  asHTML(indent, context) {
-    const html = CARRIAGE_RETURN;  ///
-
-    return html;
-  }
-
   createDOMElement(context) {
     const content = CARRIAGE_RETURN, ///
           textNode = document.createTextNode(content),
           domElement = textNode;  ///
 
-    this.setDOMElement(domElement);
-
     return domElement;
   }
 
+  asHTML(indent, context) {
+    const html = CARRIAGE_RETURN;  ///
+
+    return html;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(VerticalSpaceMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown.js

@@ -131,6 +131,80 @@ class MarkdownNode extends NonTerminalNode {
     return lines;
   }
 
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.domElement = this.createDOMElement(context);
+
+    if (this.domElement !== null) {
+      if (siblingDOMElement !== null) {
+        siblingDOMElement = siblingDOMElement.nextSibling;  ///
+      }
+
+      parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
+
+      parentDOMElement = this.domElement; ///
+    }
+
+    siblingDOMElement = null;
+
+    this.childNodes.forEach((childNode) => {
+      const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
+
+      if (childNodeMarkdownNode) {
+        const markdownNode = childNode; ///
+
+        siblingDOMElement = markdownNode.mount(parentDOMElement, siblingDOMElement, context);
+      }
+    });
+
+    if (this.domElement !== null) {
+      siblingDOMElement = this.domElement;
+    }
+
+    return siblingDOMElement;
+  }
+
+  unmount(parentDOMElement, context) {
+    if (this.domElement !== null) {
+      parentDOMElement.removeChild(this.domElement);
+
+      parentDOMElement = this.domElement; ///
+
+      this.domElement = null;
+
+      return;
+    }
+
+    this.childNodes.forEach((childNode) => {
+      childNode.unmount(parentDOMElement, context);
+    });
+  }
+
+  createDOMElement(context) {
+    let domElement = null;
+
+    const tagName = this.tagName(context);
+
+    if (tagName !== null) {
+      domElement = document.createElement(tagName);
+
+      const className = this.className(context),
+            attributeName = this.attributeName(context),
+            attributeValue = this.attributeValue(context);
+
+      if (className !== null) {
+        Object.assign(domElement, {
+          className
+        });
+      }
+
+      if ((attributeName !== null) && (attributeValue !== null)) {
+        domElement.setAttribute(attributeName, attributeValue);
+      }
+    }
+
+    return domElement;
+  }
+
   asHTML(indent, context) {
     let html = null;
 
@@ -199,36 +273,6 @@ ${childNodesHTML}${indent}${closingTag}
     return childNodesHTML;
   }
 
-  createDOMElement(context) {
-    let domElement = null;
-
-    const tagName = this.tagName(context);
-
-    if (tagName !== null) {
-      domElement = document.createElement(tagName);
-
-      const className = this.className(context),
-            attributeName = this.attributeName(context),
-            attributeValue = this.attributeValue(context);
-
-      if (className !== null) {
-        Object.assign(domElement, {
-          className
-        });
-      }
-
-      if ((attributeName !== null) && (attributeValue !== null)) {
-        domElement.setAttribute(attributeName, attributeValue);
-      }
-
-      this.setDOMElement(domElement);
-
-      this.createChildNodeDOMElements(context);
-    }
-
-    return domElement;
-  }
-
   childNodesAsPlainText(context) {
     const childNodes = this.getChildNodes(),
           childNodesPlainText = childNodes.reduce((childNodesPlainText, childNode) => {
@@ -252,26 +296,6 @@ ${markdownNodePlainText}`;
     return childNodesPlainText;
   }
 
-  createChildNodeDOMElements(context) {
-    const childNodes = this.getChildNodes();
-
-    childNodes.forEach((childNode) => {
-      const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
-
-      if (childNodeMarkdownNode) {
-        const markdownNode = childNode; ///
-
-        markdownNode.createDOMElement(context);
-
-        const domElement = markdownNode.getDOMElement();
-
-        if (domElement !== null) {
-          this.addDOMElement(domElement);
-        }
-      }
-    });
-  }
-
   clone(...remainingArguments) { return super.clone(this.domElement, ...remainingArguments); }
 
   static fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity, ...remainingArguments) {

package/src/utilities/childNodes.js

@@ -131,9 +131,7 @@ export function domElementsFromChildNodes(childNodes, context) {
           domElements.push(domElement);
         }
 
-        markdownNode.createDOMElement(context);
-
-        const domElement = markdownNode.getDOMElement();
+        const domElement = markdownNode.createDOMElement(context);
 
         domElements.push(domElement);
       }