highmark-markdown 1.0.183 → 1.0.185

package/src/node/html/division.js

@@ -1,15 +1,165 @@
 "use strict";
 
 import HTMLNode from "../../node/html";
+import PageNumberHTMLNode from "../../node/html/pageNumber";
+import PageNumberHTMLTransform from "../../transform/html/pageNumber";
+import IndexAnchorHTMLTransform from "../../transform/html/indexAnchor";
+import FootnotesListHTMLTransform from "../../transform/html/list/footnotes";
+
+import { DIVISION_RULE_NAME } from "../../ruleNames";
+import { groupHTMLNodes,
+         removeHTMLNodes,
+         addFootnoteHTMLNodes,
+         removeFootnoteHTMLNodes,
+         paginateGroupedHTMLNodes,
+         numberFootnoteLinkHTMLNodes,
+         removeFootnotesDirectiveHTMLNode,
+         removePageNumberDirectiveHTMLNode,
+         removeNestedFootnoteLinkHTMLNodes,
+         lineHTMLTransformsFromFootnoteHTMLTransforms,
+         footnoteItemHTMLTransformsFromLineHTMLTransforms } from "../../utilities/division";
 
 export default class DivisionHTMLNode extends HTMLNode {
-  className(context) { return this.outerNode.className(context); }
+  constructor(outerNode, parentNode, childNodes, domElement, divisionClassName) {
+    super(outerNode, parentNode, childNodes, domElement);
+
+    this.divisionClassName = divisionClassName;
+  }
+
+  getDivisionClassName() {
+    return this.divisionClassName;
+  }
+
+  className(context) {
+    const className = this.divisionClassName; ///
+
+    return className;
+  }
+
+  getRuleName() {
+    const ruleNme = DIVISION_RULE_NAME;
+
+    return ruleNme;
+  }
+
+  resolve(divisionHTMLNodes, context) {
+    const node = this;
+
+    removeNestedFootnoteLinkHTMLNodes(node);
+
+    const pageNumberDirectiveHTNLTransform = removePageNumberDirectiveHTMLNode(node),
+          footnotesDirectiveHTMLNode = removeFootnotesDirectiveHTMLNode(node),
+          footnoteHTMLTransforms = removeFootnoteHTMLNodes(node);
+
+    if (footnotesDirectiveHTMLNode !== null) {
+      addFootnoteHTMLNodes(footnoteHTMLTransforms, node, context);
+    }
+
+    this.paginate(pageNumberDirectiveHTNLTransform, divisionHTMLNodes, context);
+  }
+
+  paginate(pageNumberDirectiveHTNLTransform, divisionHTMLNodes, context) {
+    const node = this,  ///
+          outerNode = this.getOuterNode(),
+          pageNumbers = (pageNumberDirectiveHTNLTransform !== null),
+          identifierMap = {},
+          divisionClassName = outerNode.className(context);
+
+    const htmlNodes = removeHTMLNodes(node),
+          groupedHTMLNodesArray = groupHTMLNodes(htmlNodes),
+          paginatedHTMLNodesArray = paginateGroupedHTMLNodes(groupedHTMLNodesArray, context);
+
+    paginatedHTMLNodesArray.forEach((paginatedHTMLNodes) => {
+      let pageNumber;
+
+      ({ pageNumber } = context);
+
+      const divisionHTMLNode = DivisionHTMLNode.fromPaginatedHTMLNodesAndDivisionClassName(paginatedHTMLNodes, divisionClassName);
+
+      divisionHTMLNode.resolveFootnotes(identifierMap, context);
+
+      if (pageNumbers) {
+        const indexAnchorHTMLTransform = IndexAnchorHTMLTransform.fromPageNumber(pageNumber),
+              pageNumberHTMLTransform = PageNumberHTMLTransform.fromPageNumber(pageNumber);
+
+        indexAnchorHTMLTransform.prependToDivisionHTMLNode(divisionHTMLNode);
+
+        pageNumberHTMLTransform.appendToDivisionHTMLNode(divisionHTMLNode);
+      }
+
+      divisionHTMLNodes.push(divisionHTMLNode);
+
+      pageNumber++;
+
+      Object.assign(context, {
+        pageNumber
+      });
+    });
+  }
+
+  pageNumber() {
+    const pageNumber = this.fromFirstLastChildNode((firstLastChildNode) => {
+      let pageNumber = null;
+
+      const firstLastChildNodePageNumberHTMLNode = (firstLastChildNode instanceof PageNumberHTMLNode);
+
+      if (firstLastChildNodePageNumberHTMLNode) {
+        const pageNumberHTMLNode = firstLastChildNode;  ///
+
+        pageNumber = pageNumberHTMLNode.getPageNumber();
+      }
+
+      return pageNumber;
+    });
+
+    return pageNumber;
+  }
+
+  resolveFootnotes(identifierMap, context) {
+    const node = this,  ///
+          footnoteHTMLTransforms = removeFootnoteHTMLNodes(node),
+          footnoteHTMLTransformsLength = footnoteHTMLTransforms.length;
+
+    if (footnoteHTMLTransformsLength === 0) {
+      return;
+    }
+
+    const divisionHTMLNode = node,  ///
+          start = numberFootnoteLinkHTMLNodes(footnoteHTMLTransforms, identifierMap, node, context),
+          lineHTMLTransforms = lineHTMLTransformsFromFootnoteHTMLTransforms(footnoteHTMLTransforms),
+          footnoteItemHTMLTransforms = footnoteItemHTMLTransformsFromLineHTMLTransforms(lineHTMLTransforms, identifierMap, start),
+          footnotesListHTMLTransform = FootnotesListHTMLTransform.fromStartAndFootnoteItemHTMLTransforms(start, footnoteItemHTMLTransforms);
+
+    footnotesListHTMLTransform.appendToDivisionHTMLNode(divisionHTMLNode);
+  }
+
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  ///
+
+    return string;
+  }
 
   static tagName = "div";
 
-  static className = null;
+  static fromNothing() {
+    const divisionClassName = null,
+          divisionHTMLNode = HTMLNode.fromNothing(DivisionHTMLNode, divisionClassName);
+
+    return divisionHTMLNode;
+  }
+
+  static fromOuterNode(outerNode) {
+    const divisionClassName = null,
+          divisionHTMLNode = HTMLNode.fromOuterNode(DivisionHTMLNode, outerNode, divisionClassName);
+
+    return divisionHTMLNode;
+  }
 
-  static fromNothing() { return HTMLNode.fromNothing(DivisionHTMLNode); }
+  static fromPaginatedHTMLNodesAndDivisionClassName(paginatedHTMLNodes, divisionClassName) {
+    const childNodes = paginatedHTMLNodes,  ///
+          divisionHTMLNode = HTMLNode.fromChildNodes(DivisionHTMLNode, childNodes, divisionClassName);
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(DivisionHTMLNode, outerNode); }
+    return divisionHTMLNode;
+  }
 }

package/src/node/html/footnote.js

@@ -3,13 +3,7 @@
 import HTMLNode from "../../node/html";
 
 export default class FootnoteHTMLNode extends HTMLNode {
-  mount(parentDOMElement, siblingDOMElement, context) {
-    ///
-  }
-
-  unmount(parentDOMElement, context) {
-    ///
-  }
+  identifier(context) { return this.outerNode.identifier(context); }
 
   static fromNothing() { return HTMLNode.fromNothing(FootnoteHTMLNode); }
 

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

@@ -2,12 +2,88 @@
 
 import HTMLNode from "../../../node/html";
 
+import { INDEX_HEADING_RULE_NAME } from "../../../ruleNames";
+
 export default class IndexHeadingHTMLNode extends HTMLNode {
+  constructor(outerNode, parentNode, childNodes, domElement, letter) {
+    super(outerNode, parentNode, childNodes, domElement);
+
+    this.letter = letter;
+  }
+
+  getLetter() {
+    return this.letter;
+  }
+
+  getRuleName() {
+    const ruleName = INDEX_HEADING_RULE_NAME;
+
+    return ruleName;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    let domElement;
+
+    domElement = this.createDOMElement(context);
+
+    this.setDOMElement(domElement);
+
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
+
+    parentDOMElement = domElement; ///
+
+    siblingDOMElement = null;
+
+    const content = this.letter,  ///
+          textNode = document.createTextNode(content);
+
+    domElement = textNode;  ///
+
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
+  }
+
+  unmount(parentDOMElement, context) {
+    let domElement;
+
+    {
+      domElement = this.getDOMElement();
+
+      const parentDOMElement = domElement,  ///
+            firstChild = domElement.firstChild
+
+      domElement = firstChild;  ///
+
+      parentDOMElement.removeChild(domElement);
+    }
+
+    domElement = this.getDOMElement();
+
+    parentDOMElement.removeChild(domElement);
+
+    this.resetDOMElement();
+  }
+
+  childNodesAsHTML(indent, context) {
+    const childNodesHTML = `${this.letter}
+`;
+
+    return childNodesHTML;
+  }
+
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  ///
+
+    return string;
+  }
+
   static tagName = "h3";
 
   static className = "index";
 
-  static fromNothing() { return HTMLNode.fromNothing(IndexHeadingHTMLNode); }
+  static fromLetter(letter) {
+    const indexHeadingHTMLNode = HTMLNode.fromNothing(IndexHeadingHTMLNode, letter);
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(IndexHeadingHTMLNode, outerNode); }
+    return indexHeadingHTMLNode;
+  }
 }

package/src/node/html/heading/primary.js

@@ -1,15 +1,17 @@
 "use strict";
 
-import HTMLNode from "../../../node/html";
+import HeadingHTMLNode from "../../../node/html/heading";
+
+export default class PrimaryHeadingHTMLNode extends HeadingHTMLNode {
+  static depth = 1;
 
-export default class PrimaryHeadingHTMLNode extends HTMLNode {
   static lines = 3;
 
   static tagName = "h1";
 
   static className = null;
 
-  static fromNothing() { return HTMLNode.fromNothing(PrimaryHeadingHTMLNode); }
+  static fromNothing() { return HeadingHTMLNode.fromNothing(PrimaryHeadingHTMLNode); }
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(PrimaryHeadingHTMLNode, outerNode); }
+  static fromOuterNode(outerNode) { return HeadingHTMLNode.fromOuterNode(PrimaryHeadingHTMLNode, outerNode); }
 }

package/src/node/html/heading/quaternary.js

@@ -1,15 +1,17 @@
 "use strict";
 
-import HTMLNode from "../../../node/html";
+import HeadingHTMLNode from "../../../node/html/heading";
+
+export default class QuaternaryHeadingHTMLNode extends HeadingHTMLNode {
+  static depth = 4;
 
-export default class QuaternaryHeadingHTMLNode extends HTMLNode {
   static lines = 2;
 
   static tagName = "h4";
 
   static className = null;
 
-  static fromNothing() { return HTMLNode.fromNothing(QuaternaryHeadingHTMLNode); }
+  static fromNothing() { return HeadingHTMLNode.fromNothing(QuaternaryHeadingHTMLNode); }
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(QuaternaryHeadingHTMLNode, outerNode); }
+  static fromOuterNode(outerNode) { return HeadingHTMLNode.fromOuterNode(QuaternaryHeadingHTMLNode, outerNode); }
 }

package/src/node/html/heading/secondary.js

@@ -1,15 +1,17 @@
 "use strict";
 
-import HTMLNode from "../../../node/html";
+import HeadingHTMLNode from "../../../node/html/heading";
+
+export default class SecondaryHeadingHTMLNode extends HeadingHTMLNode {
+  static depth = 2;
 
-export default class SecondaryHeadingHTMLNode extends HTMLNode {
   static lines = 2.5;
 
   static tagName = "h2";
 
   static className = null;
 
-  static fromNothing() { return HTMLNode.fromNothing(SecondaryHeadingHTMLNode); }
+  static fromNothing() { return HeadingHTMLNode.fromNothing(SecondaryHeadingHTMLNode); }
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(SecondaryHeadingHTMLNode, outerNode); }
+  static fromOuterNode(outerNode) { return HeadingHTMLNode.fromOuterNode(SecondaryHeadingHTMLNode, outerNode); }
 }

package/src/node/html/heading/tertiary.js

@@ -1,15 +1,17 @@
 "use strict";
 
-import HTMLNode from "../../../node/html";
+import HeadingHTMLNode from "../../../node/html/heading";
+
+export default class TertiaryHeadingHTMLNode extends HeadingHTMLNode {
+  static depth = 3;
 
-export default class TertiaryHeadingHTMLNode extends HTMLNode {
   static lines = 2.25;
 
   static tagName = "h3";
 
   static className = null;
 
-  static fromNothing() { return HTMLNode.fromNothing(TertiaryHeadingHTMLNode); }
+  static fromNothing() { return HeadingHTMLNode.fromNothing(TertiaryHeadingHTMLNode); }
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(TertiaryHeadingHTMLNode, outerNode); }
+  static fromOuterNode(outerNode) { return HeadingHTMLNode.fromOuterNode(TertiaryHeadingHTMLNode, outerNode); }
 }

package/src/node/html/heading.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+import AnchorHTMLNode from "../../node/html/anchor";
+
+import { CONTENTS_PREPEND } from "../../prepends";
+import { removeLeadingWhitespace, replaceSpacesWithHyphens, removeNonAlphabeticCharacters } from "../../utilities/string";
+
+export default class HeadingHTMLNode extends HTMLNode {
+  getLineHTMLNode() {
+    const lineHTMLNode = this.fromFirstChildNode((firstChildNode) => {
+      const lineHTMLNode = firstChildNode; ///
+
+      return lineHTMLNode;
+    });
+
+    return lineHTMLNode;
+  }
+
+  identifier(context) {
+    const plainText = this.childNodesAsPlainText(context),
+          identifier = identifierFromPlainText(plainText);
+
+    return identifier;
+  }
+
+  anchor(context) {
+    const prepend = CONTENTS_PREPEND,
+          identifier = this.identifier(context),
+          anchorHTMLNode = AnchorHTMLNode.fromPrependAndIdentifier(prepend, identifier),
+          childNode = anchorHTMLNode; ///
+
+    this.prependChildNode(childNode);
+  }
+
+  static tagName = "h1";
+
+  static fromNothing(Class) { return HTMLNode.fromNothing(Class); }
+
+  static fromOuterNode(Class, outerNode) { return HTMLNode.fromOuterNode(Class, outerNode); }
+}
+
+function identifierFromPlainText(plainText) {
+  let string;
+
+  string = plainText; ///
+
+  string = string.toLowerCase();
+
+  string = removeLeadingWhitespace(string);
+
+  string = replaceSpacesWithHyphens(string);
+
+  string = removeNonAlphabeticCharacters(string);
+
+  const identifier = string;  ///
+
+  return identifier;
+}

package/src/node/html/image.js

@@ -4,7 +4,6 @@ import HTMLNode from "../../node/html";
 
 import { EMPTY_STRING } from "../../constants";
 import { ALT_ATTRIBUTE_NAME, SRC_ATTRIBUTE_NAME } from "../../attributeNames";
-import {IMAGE_RULE_NAME} from "../../ruleNames";
 
 export default class ImageHTMLNode extends HTMLNode {
   src(context) { return this.outerNode.src(context); }
@@ -61,15 +60,19 @@ export default class ImageHTMLNode extends HTMLNode {
   }
 
   mount(parentDOMElement, siblingDOMElement, context) {
-    this.domElement = this.createDOMElement(context);
+    const domElement = this.createDOMElement(context);
 
-    parentDOMElement.insertBefore(this.domElement, siblingDOMElement)
+    this.setDOMElement(domElement);
+
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
   }
 
   unmount(parentDOMElement, context) {
-    parentDOMElement.removeChild(this.domElement);
+    const domElement = this.getDOMElement();
+
+    parentDOMElement.removeChild(domElement);
 
-    this.domElement = null;
+    this.resetDOMElement();
   }
 
   createDOMElement(context) {

package/src/node/html/item/contents.js

@@ -2,12 +2,35 @@
 
 import HTMLNode from "../../../node/html";
 
+import { CONTENTS_ITEM_RULE_NAME } from "../../../ruleNames";
+
 export default class ContentsItemHTMLNode extends HTMLNode {
+  getRuleName() {
+    const ruleName = CONTENTS_ITEM_RULE_NAME;
+
+    return ruleName;
+  }
+
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  ///
+
+    return string;
+  }
+
   static tagName = "li";
 
   static className = "contents";
 
-  static fromNothing() { return HTMLNode.fromNothing(ContentsItemHTMLNode); }
+  static fromHTMLTransforms(htmlTransforms) {
+    const htmlNodes = htmlTransforms.map((htmlTransform) => {
+            const htmlNode = htmlTransform.getHTMLNode();
+
+            return htmlNode;
+          }),
+          childNodes = htmlNodes, ///
+          contentsItemHTMLNode = HTMLNode.fromChildNodes(ContentsItemHTMLNode, childNodes);
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(ContentsItemHTMLNode, outerNode); }
+    return contentsItemHTMLNode;
+  }
 }

package/src/node/html/item/footnote.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+import AnchorHTMLNode from "../../../node/html/anchor";
+
+import { FOOTNOTE_PREPEND } from "../../../prepends";
+import { FOOTNOTE_ITEM_RULE_NAME } from "../../../ruleNames";
+
+export default class FootnoteItemHTMLNode extends HTMLNode {
+  getRuleName() {
+    const ruleName = FOOTNOTE_ITEM_RULE_NAME; ///
+
+    return ruleName;
+  }
+
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  ///
+
+    return string;
+  }
+
+  static tagName = "li";
+
+  static className = "footnote";
+
+  static fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier) {
+    const prepend = FOOTNOTE_PREPEND,
+          anchorHTMLNode = AnchorHTMLNode.fromPrependAndIdentifier(prepend, identifier),
+          lineHTMLNode = lineHTMLTransform.getLineHTMLNode(),
+          childNodes = [
+            anchorHTMLNode,
+            lineHTMLNode
+          ],
+          footnoteItemHTMLNode = HTMLNode.fromChildNodes(FootnoteItemHTMLNode, childNodes);
+
+    return footnoteItemHTMLNode;
+  }
+}

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

@@ -1,33 +1,52 @@
 "use strict";
 
 import HTMLNode from "../../../node/html";
+import IndexTextHTMLNode from "../../../node/html/text/index";
+import IndexLinkHTMLNode from "../../../node/html/link/index";
 
-export default class IndexItemHTMLNode extends HTMLNode {
-  asHTML(indent, context) {
-    indent = this.adjustIndent(indent);
+import { INDEX_ITEM_RULE_NAME } from "../../../ruleNames";
+import CommaTextHTMLNode from "../text/comma";
 
-    const childNodesHTML = this.childNodesAsHTML(indent, context),
-          startingTag = this.startingTag(context),
-          closingTag = this.closingTag(context),
-          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
-`;
+export default class IndexItemHTMLNode extends HTMLNode {
+  getRuleName() {
+    const ruleName = INDEX_ITEM_RULE_NAME;
 
-    return html;
+    return ruleName;
   }
 
-  childNodesAsHTML(indent, context) {
-    indent = null;
-
-    const childNodesHTML = super.childNodesAsHTML(indent, context);
+  asString() {
+    const ruleName = this.getRuleName(),
+          string = ruleName;  ///
 
-    return childNodesHTML;
+    return string;
   }
 
   static tagName = "li";
 
   static className = "index";
 
-  static fromNothing() { return HTMLNode.fromNothing(IndexItemHTMLNode); }
+  static fromIndexItem(indexItem) {
+    const wordOrPhrase = indexItem.getWordOrPhrase(),
+          pageNumbers = indexItem.getPageNumbers(),
+          indexSpanHTMLNode = IndexTextHTMLNode.fromWordOrPhrase(wordOrPhrase),
+          childNodes = [
+            indexSpanHTMLNode
+          ];
+
+    pageNumbers.forEach((pageNumber) => {
+      const indexLinkHTMLNOde = IndexLinkHTMLNode.fromPageNumber(pageNumber);
+
+      childNodes.push(indexLinkHTMLNOde);
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(IndexItemHTMLNode, outerNode); }
+      const commaTextHTMLNode = CommaTextHTMLNode.fromNothing();
+
+      childNodes.push(commaTextHTMLNode);
+    });
+
+    childNodes.pop();
+
+    const indexItemHTMLNode = HTMLNode.fromChildNodes(IndexItemHTMLNode, childNodes);
+
+    return indexItemHTMLNode;
+  }
 }

package/src/node/html/line.js

@@ -3,12 +3,41 @@
 import HTMLNode from "../../node/html";
 import PlainTextHTMLNode from "./text/plain";
 
-import { EMPTY_STRING } from "../../constants";
+import { assignIndexes, deleteIndexes } from "../../utilities/whitespace";
+import { EMPTY_STRING, DEFAULT_MAXIMUM_LINE_CHARACTERS } from "../../constants";
 
 export default class LineHTMLNode extends HTMLNode {
+  lines(context) {
+    const { maximumLineCharacters = DEFAULT_MAXIMUM_LINE_CHARACTERS } = context,
+          plainText = this.asPlainText(context),
+          plainTextLength = plainText.length,
+          characters = plainTextLength, ///
+          lines = (characters / maximumLineCharacters) + 1;
+
+    return lines;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    const node = this;  ///
+
+    assignIndexes(node, context);
+
+    super.mount(parentDOMElement, siblingDOMElement, context);
+
+    deleteIndexes(context);
+  }
+
+  unmount(parentDOMElement, context) {
+    super.unmount(parentDOMElement, context);
+  }
+
   childNodesAsHTML(indent, context) {
     let childNodesHTML;
 
+    const node = this;  ///
+
+    assignIndexes(node, context);
+
     let previousChildNode = null;
 
     childNodesHTML = this.reduceChildNode((childNodesHTML, childNode) => {
@@ -39,11 +68,19 @@ export default class LineHTMLNode extends HTMLNode {
 `;
     }
 
+    deleteIndexes(context);
+
     return childNodesHTML;
   }
 
   childNodesAsPlainText(context) {
-    const childNodesPlainText = this.reduceChildNode((childNodesPlainText, childNode) => {
+    let childNodesPlainText;
+
+    const node = this;  ///
+
+    assignIndexes(node, context)
+
+    childNodesPlainText = this.reduceChildNode((childNodesPlainText, childNode) => {
       const childNodePlainText = childNode.asPlainText(context);
 
       childNodesPlainText = `${childNodesPlainText}${childNodePlainText}`;
@@ -51,6 +88,8 @@ export default class LineHTMLNode extends HTMLNode {
       return childNodesPlainText;
     }, EMPTY_STRING);
 
+    deleteIndexes(context);
+
     return childNodesPlainText;
   }