highmark-markdown 1.0.183 → 1.0.185

package/src/node/html/pageNumber.js

@@ -2,45 +2,89 @@
 
 import HTMLNode from "../../node/html";
 
+import { EMPTY_STRING } from "../../constants";
+import { PAGE_NUMBER_RULE_NAME } from "../../ruleNames";
+
 export default class PageNumberHTMLNode extends HTMLNode {
-  getPageNumber() { return this.outerNode.getPageNumber(); }
+  constructor(outerNode, parentNode, childNodes, domElement, pageNumber) {
+    super(outerNode, parentNode, childNodes, domElement);
+
+    this.pageNumber = pageNumber;
+  }
+
+  getPageNumber() {
+    return this.pageNumber;
+  }
+
+  getRuleName() {
+    const ruleName = PAGE_NUMBER_RULE_NAME;
+
+    return ruleName;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    super.mount(parentDOMElement, siblingDOMElement, context);
 
-  createDOMElement(context) {
     let domElement;
 
-    const pageNumber = this.getPageNumber(),
-          content = pageNumber, ///
+    domElement = this.getDOMElement();
+
+    parentDOMElement = domElement;  ///
+
+    siblingDOMElement = null;
+
+    const content = this.pageNumber,  ///
           textNode = document.createTextNode(content);
 
-    domElement = super.createDOMElement(context)
+    domElement = textNode;  ///
+
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
+  }
 
-    const parentDOMElement = domElement;  ///
+  unmount(parentDOMElement, context) {
+    {
+      let domElement;
 
-    domElement = textNode; ///
+      domElement = this.getDOMElement();
 
-    parentDOMElement.appendChild(domElement);
+      const parentDOMElement = domElement,  ///
+            lastChild = domElement.lastChild
 
-    domElement = parentDOMElement;  ///
+      domElement = lastChild;  ///
 
-    return domElement;
+      parentDOMElement.removeChild(domElement);
+    }
+
+    super.unmount(parentDOMElement, context);
   }
 
   asPlainText(context) {
-    const pageNumber = this.getPageNumber(),
-          plainText = pageNumber; ///
+    const plainText = EMPTY_STRING;
 
     return plainText;
   }
 
   childNodesAsHTML(indent, context) {
-    const pageNumber = this.getPageNumber(),
-          childNodesHTML = `${pageNumber}
+    const childNodesHTML = `${this.pageNumber}
 `;
 
     return childNodesHTML;
   }
 
-  static fromNothing() { return HTMLNode.fromNothing(PageNumberHTMLNode); }
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  ///
+
+    return string;
+  }
+
+  static tagName = "span";
+
+  static className = "page-number";
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(PageNumberHTMLNode, outerNode); }
+  static fromPageNumber(pageNumber) {
+    const pageNumberHTMLNode = HTMLNode.fromNothing(PageNumberHTMLNode, pageNumber);
+
+    return pageNumberHTMLNode;
+  }
 }

package/src/node/html/reference.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+export default class ReferenceHTMLNode extends HTMLNode {
+  static tagName = "a";
+
+  static className = "reference";
+
+  static fromNothing() { return HTMLNode.fromNothing(ReferenceHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(ReferenceHTMLNode, outerNode); }
+}

package/src/node/html/text/comma.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import TextHTMLNode from "../../../node/html/text";
+
+import { COMMA } from "../../../constants";
+import { INDEX_TEXT_RULE_NAME } from "../../../ruleNames";
+
+export default class CommaTextHTMLNode extends TextHTMLNode {
+  getRuleName() {
+    const ruleName = INDEX_TEXT_RULE_NAME;
+
+    return ruleName;
+  }
+
+  text(context) {
+    const text = COMMA;
+
+    return text;
+  }
+
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  //.
+
+    return string;
+  }
+
+  static fromNothing() { return TextHTMLNode.fromNothing(CommaTextHTMLNode); }
+}

package/src/node/html/text/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import TextHTMLNode from "../../../node/html/text";
+
+import { INDEX_TEXT_RULE_NAME } from "../../../ruleNames";
+
+export default class IndexTextHTMLNode extends TextHTMLNode {
+  constructor(outerNode, parentNode, childNodes, domElement, wordOrPhrase) {
+    super(outerNode, parentNode, childNodes, domElement, wordOrPhrase);
+
+    this.wordOrPhrase = wordOrPhrase;
+  }
+
+  getWordOrPhrase() {
+    return this.wordOrPhrase;
+  }
+
+  getRuleName() {
+    const ruleName = INDEX_TEXT_RULE_NAME;
+
+    return ruleName;
+  }
+
+  text(context) {
+    const text = `${this.wordOrPhrase}
+`;
+
+    return text;
+  }
+
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  //.
+
+    return string;
+  }
+
+  static fromWordOrPhrase(wordOrPhrase) {
+    const indexTextHTMLNode = TextHTMLNode.fromNothing(IndexTextHTMLNode, wordOrPhrase);
+
+    return indexTextHTMLNode;
+  }
+}

package/src/node/html/text/stronglyEmphasised.js

@@ -29,33 +29,44 @@ export default class StronglyEmphasisedTextHTMLNode extends HTMLNode {
   }
 
   mount(parentDOMElement, siblingDOMElement, context) {
-    this.domElement = this.createDOMElement(context);
+    let domElement;
+
+    domElement = this.createDOMElement(context);
 
-    parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
+    this.setDOMElement(domElement);
 
-    const childDOMElement = this.createChildDOMElement(context),
-          domElement = childDOMElement; ///
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
 
-    parentDOMElement = this.domElement;
+    parentDOMElement = domElement; ///
 
     siblingDOMElement = null;
 
-    parentDOMElement.insertBefore(domElement, siblingDOMElement);
+    const childDOMElement = this.createChildDOMElement(context);
+
+    domElement = childDOMElement; ///
 
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
   }
 
   unmount(parentDOMElement, context) {
+    let domElement;
+
+    domElement = this.getDOMElement();
+
     {
-      const parentDOMElement = this.domElement,
-            firstChild = parentDOMElement.firstChild,
-            domElement = firstChild;  ///
+      const parentDOMElement = domElement, ///
+            firstChild = parentDOMElement.firstChild;
+
+      domElement = firstChild;  ///
 
       parentDOMElement.removeChild(domElement)
     }
 
-    parentDOMElement.removeChild(this.domElement);
+    domElement = this.getDOMElement();
+
+    parentDOMElement.removeChild(domElement);
 
-    this.domElement = null;
+    this.resetDOMElement();
   }
 
   childNodesAsHTML(indent, context) {

package/src/node/html/text.js

@@ -3,7 +3,7 @@
 import HTMLNode from "../../node/html";
 
 export default class TextHTMLNode extends HTMLNode {
-  text(content) { return this.outerNode.text(content); }
+  text(context) { return this.outerNode.text(context); }
 
   createDOMElement(context) {
     const text = this.text(context),
@@ -28,7 +28,7 @@ export default class TextHTMLNode extends HTMLNode {
     return plainText;
   }
 
-  static fromNothing(Class) { return HTMLNode.fromNothing(Class); }
+  static fromNothing(Class, ...remainingArguments) { return HTMLNode.fromNothing(Class, ...remainingArguments); }
 
-  static fromOuterNode(Class, outerNode) { return HTMLNode.fromOuterNode(Class, outerNode); }
+  static fromOuterNode(Class, outerNode, ...remainingArguments) { return HTMLNode.fromOuterNode(Class, outerNode, ...remainingArguments); }
 }

package/src/node/html/topmost.js

@@ -1,11 +1,93 @@
 "use strict";
 
 import HTMLNode from "../../node/html";
+import IndexHTMLTransform from "../../transform/html/index";
+import DivisionHTMLTransform from "../../transform/html/division";
+import ContentsListHTMLTransform from "../../transform/html/list/contents";
+import IndexDirectiveHTMLTransform from "../../transform/html/directive/index";
+import ContentsDirectiveHTMLTransform from "../../transform/html/directive/contents";
 
 import { HTML_RULE_NAME } from "../../ruleNames";
-import { divisionHTMLNodesFromNode } from "../../utilities/html";
+import { divisionHTMLNodesFromNode, indexDirectiveHTMLNodeFromNode, contentsDirectiveHTMLNodeFromNode } from "../../utilities/html";
 
 export default class TopmostHTMLNode extends HTMLNode {
+  resolve(context) {
+    this.paginate(context);
+
+    this.addContents(context);
+
+    this.addIndex(context);
+  }
+
+  paginate(context) {
+    let divisionHTMLNodes,
+        divisionHTMLTransforms;
+
+    divisionHTMLNodes = this.getDivisionHTMLNodes();
+
+    divisionHTMLTransforms = divisionHTMLTransformsFromDivisionHTMLNodes(divisionHTMLNodes);
+
+    divisionHTMLNodes = [];
+
+    let pageNumber;
+
+    pageNumber = 1;
+
+    Object.assign(context, {
+      pageNumber
+    });
+
+    divisionHTMLTransforms.forEach((divisionHTMLTransform) => {
+      divisionHTMLTransform.remove();
+
+      divisionHTMLTransform.resolve(divisionHTMLNodes, context);
+    });
+
+    delete context.pageNumber;
+
+    divisionHTMLTransforms = divisionHTMLTransformsFromDivisionHTMLNodes(divisionHTMLNodes);
+
+    const topmostHTMLNode = this; ///
+
+    divisionHTMLTransforms.forEach((divisionHTMLTransform) => {
+      divisionHTMLTransform.appendToTopmostHTMLNode(topmostHTMLNode);
+    });
+  }
+
+  addIndex(context) {
+    const node = this,  ///
+          indexDirectiveHTMLNode = indexDirectiveHTMLNodeFromNode(node);
+
+    if (indexDirectiveHTMLNode === null) {
+      return;
+    }
+
+    const divisionHTMLNodes = this.getDivisionHTMLNodes(),
+          indexDirectiveHTMLTransform = IndexDirectiveHTMLTransform.fromIndexDirectiveHTMLNode(indexDirectiveHTMLNode),
+          indexHTMLTransform = IndexHTMLTransform.fromIndexDirectiveHTMLTransformAndDivisionHTMLNodes(indexDirectiveHTMLTransform, divisionHTMLNodes, context);
+
+    (indexHTMLTransform !== null) ?
+      indexHTMLTransform.replaceIndexDirectiveHTMLTransform(indexDirectiveHTMLTransform) :
+        indexDirectiveHTMLTransform.remove();
+  }
+
+  addContents(context) {
+    const node = this,  ///
+          contentsDirectiveHTMLNode = contentsDirectiveHTMLNodeFromNode(node);
+
+    if (contentsDirectiveHTMLNode === null) {
+      return;
+    }
+
+    const topmostHTMLNode = this, ///
+          contentsDirectiveHTMLTransform = ContentsDirectiveHTMLTransform.fromContentsDirectiveHTMLNode(contentsDirectiveHTMLNode),
+          contentsListHTMLTransform = ContentsListHTMLTransform.fromContentsDirectiveHTMLTransformAndTopmostHTMLNode(contentsDirectiveHTMLTransform, topmostHTMLNode, context);
+
+    (contentsListHTMLTransform !== null) ?
+      contentsListHTMLTransform.replaceContentsDirectiveHTMLTransform(contentsDirectiveHTMLTransform) :
+        contentsDirectiveHTMLTransform.remove();
+  }
+
   adjustIndent(indent) {
     return indent;
   }
@@ -36,3 +118,13 @@ export default class TopmostHTMLNode extends HTMLNode {
 
   static fromNothing() { return HTMLNode.fromNothing(TopmostHTMLNode); }
 }
+
+function divisionHTMLTransformsFromDivisionHTMLNodes(divisionHTMLNodes) {
+  const divisionHTMLTransforms = divisionHTMLNodes.map((divisionHTMLNode) => {
+    const divisionHTMLTransform = DivisionHTMLTransform.fromDivisionHTMLNode(divisionHTMLNode);
+
+    return divisionHTMLTransform;
+  });
+
+  return divisionHTMLTransforms;
+}

package/src/node/html.js

@@ -21,6 +21,10 @@ class HTMLNode extends Node {
     this.domElement = domElement;
   }
 
+  resetDOMElement() {
+    this.domElement = null;
+  }
+
   getMarkdownNode() {
     const outerNode = this.getOuterNode(),
           markdownNode = outerNode; ///
@@ -28,7 +32,12 @@ class HTMLNode extends Node {
     return markdownNode;
   }
 
-  getRuleName() { return this.outerNode.getRuleName(); }
+  getRuleName() {
+    const markdownNode = this.getMarkdownNode(),
+          ruleName = markdownNode.getRuleName();
+
+    return ruleName;
+  }
 
   isTerminalNode() {
     const terminalNode = false;
@@ -74,6 +83,12 @@ class HTMLNode extends Node {
     return tagName;
   }
 
+  depth() {
+    const { depth = null } = this.constructor;
+
+    return depth;
+  }
+
   className(context) {
     const { className } = this.constructor;
 
@@ -248,18 +263,18 @@ ${childNodePlainText}`;
     return childNodesPlainText;
   }
 
-  static fromNothing(Class) {
+  static fromNothing(Class, ...remainingArguments) {
     if (Class === undefined) {
       Class = HTMLNode; ///
     }
 
     const domElement = null,
-          node = Node.fromNothing(Class, domElement);
+          node = Node.fromNothing(Class, domElement, ...remainingArguments);
 
     return node;
   }
 
-  static fromOuterNode(Class, outerNode) {
+  static fromOuterNode(Class, outerNode, ...remainingArguments) {
     if (outerNode === undefined) {
       outerNode = Class;  ///
 
@@ -267,7 +282,20 @@ ${childNodePlainText}`;
     }
 
     const domElement = null,
-          node = Node.fromOuterNode(Class, outerNode, domElement);
+          node = Node.fromOuterNode(Class, outerNode, domElement, ...remainingArguments);
+
+    return node;
+  }
+
+  static fromChildNodes(Class, childNodes, ...remainingArguments) {
+    if (childNodes === undefined) {
+      childNodes = Class;  ///
+
+      Class = HTMLNode; ///
+    }
+
+    const domElement = null,
+          node = Node.fromChildNodes(Class, childNodes, domElement, ...remainingArguments);
 
     return node;
   }
@@ -275,4 +303,4 @@ ${childNodePlainText}`;
 
 Object.assign(HTMLNode.prototype, nodeMixins);
 
-export default HTMLNode;
+export default HTMLNode;