highmark-markdown 1.0.183 → 1.0.185

package/src/transform/html.js

@@ -0,0 +1,78 @@
+"use strict";
+
+export default class HTMLTransform {
+  constructor(htmlNode) {
+    this.htmlNode = htmlNode;
+  }
+
+  getHTMLNode() {
+    return this.htmlNode;
+  }
+
+  appendTo(parentHTMLNode) {
+    const childNode = this.htmlNode, ///
+          parentNode = parentHTMLNode;  ///
+
+    parentNode.appendChildNode(childNode);
+  }
+
+  prependTo(parentHTMLNode) {
+    const childNode = this.htmlNode, ///
+        parentNode = parentHTMLNode;  ///
+
+    parentNode.prependChildNode(childNode);
+  }
+
+  addAfter(exitingHTMLNode) {
+    const childNode = exitingHTMLNode,  ///
+          parentNode = childNode.getParentNode(),
+          index = parentNode.indexOfChildNode(childNode),
+          startIndex = index + 1,
+          addedChildNode = this.htmlNode;  ///
+
+    parentNode.addChildNode(addedChildNode, startIndex);
+  }
+
+  replace(replacedHTMLNode) {
+    const parentNode = replacedHTMLNode.getParentNode(),
+          replacedChildNode = replacedHTMLNode, ///
+          replacementChildNode = this.htmlNode,  ///
+          replacementChildNodes = [
+            replacementChildNode
+          ];
+
+    parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);
+  }
+
+  remove() {
+    const childNode = this.htmlNode, ///
+          parentNode = childNode.getParentNode();
+
+    parentNode.removeChildNode(childNode);
+  }
+
+  expand(Class, ascendantNode) {
+    if (ascendantNode === undefined) {
+      ascendantNode = Class;  ///
+
+      Class = HTMLTransform;  ///
+    }
+
+    const htmlNode = ascendantNode, ///
+          transform = new Class(htmlNode);
+
+    return transform;
+  }
+
+  static fromHTMLNode(Class, htmlNode, ...remainingArguments) {
+    if (htmlNode === undefined) {
+      htmlNode = Class; ///
+
+      Class = HTMLTransform;  ///
+    }
+
+    const htmlTransform = new Class(htmlNode, ...remainingArguments);
+
+    return htmlTransform;
+  }
+}

package/src/transform/markdown/directive/embed.js

@@ -1,18 +1,17 @@
 "use strict";
 
-import { Transform } from "occam-dom";
+import MarkdownTransform from "../../../transform/markdown";
 
-export default class EmbedDirectiveMarkdownTransform extends Transform {
-  addAfterSubDivisionMarkdownNode(subDivisionMarkdownNode, divisionMarkdownNode, context) {
-    const existingNode = subDivisionMarkdownNode, ///
-          parentNode = divisionMarkdownNode;  ///
+export default class EmbedDirectiveMarkdownTransform extends MarkdownTransform {
+  addAfterSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
+    const existingNode = subDivisionMarkdownNode;  ///
 
-    super.addAfter(existingNode, parentNode, context);
+    super.addAfter(existingNode, context);
   }
 
   static fromSubDivisionMarkdownNodeAndTokens(subDivisionMarkdownNode, tokens) {
     const node = subDivisionMarkdownNode,  ///
-          embedDirectiveMarkdownTransform = Transform.fromNodeAndTokens(EmbedDirectiveMarkdownTransform, node, tokens);
+          embedDirectiveMarkdownTransform = MarkdownTransform.fromNodeAndTokens(EmbedDirectiveMarkdownTransform, node, tokens);
 
     return embedDirectiveMarkdownTransform;
   }

package/src/transform/markdown/directive/ignore.js

@@ -1,18 +1,12 @@
 "use strict";
 
-import { Transform } from "occam-dom";
-
-export default class IgnoreDirectiveMarkdownTransform extends Transform {
-  removeFromTopmostMarkdownNode(topmostMarkdownNode, context) {
-    const parentNode = topmostMarkdownNode; ///
-
-    super.removeFrom(parentNode, context);
-  }
+import MarkdownTransform from "../../../transform/markdown";
 
+export default class IgnoreDirectiveMarkdownTransform extends MarkdownTransform {
   static fromDivisionMarkdownNode(divisionMarkdownNode) {
     const node = divisionMarkdownNode,  ///
           tokens = null,
-          ignoredDirectiveMarkdownTransform = Transform.fromNodeAndTokens(IgnoreDirectiveMarkdownTransform, node, tokens);
+          ignoredDirectiveMarkdownTransform = MarkdownTransform.fromNodeAndTokens(IgnoreDirectiveMarkdownTransform, node, tokens);
 
     return ignoredDirectiveMarkdownTransform;
   }

package/src/transform/markdown/directive/include.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { Transform } from "occam-dom";
+import MarkdownTransform from "../../../transform/markdown";
 
-export default class IncludeDirectiveMarkdownTransform extends Transform {
+export default class IncludeDirectiveMarkdownTransform extends MarkdownTransform {
   getDivisionMarkdownNode() {
     const node = this.getNode(),
           divisionMarkdownNode = node;  ///
@@ -22,7 +22,7 @@ export default class IncludeDirectiveMarkdownTransform extends Transform {
 
   static fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens) {
     const node = divisionMarkdownNode,  ///
-          includeDirectiveMarkdownTransform = Transform.fromNodeAndTokens(IncludeDirectiveMarkdownTransform, node, tokens);
+          includeDirectiveMarkdownTransform = MarkdownTransform.fromNodeAndTokens(IncludeDirectiveMarkdownTransform, node, tokens);
 
     return includeDirectiveMarkdownTransform;
   }

package/src/transform/markdown/subDivision.js

@@ -1,25 +1,13 @@
 "use strict";
 
-import { Transform } from "occam-dom";
-
-export default class SubDivisionMarkdownTransform extends Transform {
-  constructor(node, tokens, subDivisionMarkdownNode) {
-    super(node, tokens);
-
-    this.subDivisionMarkdownNode = subDivisionMarkdownNode;
-  }
-
-  removeFromDivisionMarkdownNode(divisionMarkdownNode, context) {
-    const parentNode = divisionMarkdownNode; ///
-
-    super.removeFrom(parentNode, context);
-  }
+import MarkdownTransform from "../../transform/markdown";
 
+export default class SubdivisionMarkdownTransform extends MarkdownTransform {
   static fromSubDivisionMarkdownNode(subDivisionMarkdownNode) {
-    const node = subDivisionMarkdownNode, ///
+    const node = subDivisionMarkdownNode,  ///
           tokens = null,
-          subDivisionMarkdownTransform = Transform.fromNodeAndTokens(SubDivisionMarkdownTransform, node, tokens);
+          embedDirectiveMarkdownTransform = MarkdownTransform.fromNodeAndTokens(SubdivisionMarkdownTransform, node, tokens);
 
-    return subDivisionMarkdownTransform;
+    return embedDirectiveMarkdownTransform;
   }
 }

package/src/transform/markdown.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { Transform } from "occam-dom";
+
+export default class MarkdownTransform extends Transform {
+  static fromNode(Class, node, ...remainingArguments) { return Transform.fromNode(Class, node, ...remainingArguments); }
+
+  static fromNodeAndTokens(Class, node, tokens, ...remainingArguments) { return Transform.fromNodeAndTokens(Class, node, tokens, ...remainingArguments); }
+}

package/src/utilities/contents.js

@@ -4,11 +4,11 @@ import { arrayUtilities } from "necessary";
 
 const { first, last } = arrayUtilities;
 
-export function nestNodes(nodes) {
+export function nestHTMLNodes(htmlNodes) {
   const nestedNodesStack = NestedNodeStack.fromNothing();
 
-  nodes.forEach((node) => {
-    const depth = node.getDepth();
+  htmlNodes.forEach((htmlNode) => {
+    const depth = htmlNode.depth();
 
     let nestedNodesStackDepth = nestedNodesStack.getDepth()
 
@@ -20,7 +20,7 @@ export function nestNodes(nodes) {
       nestedNodesStackDepth = nestedNodesStack.decrement();
     }
 
-    const nestedNode = NestedNode.fromNode(node);
+    const nestedNode = NestedNode.fromHTMLNode(htmlNode);
 
     nestedNodesStack.addNestedNode(nestedNode);
   });
@@ -31,13 +31,13 @@ export function nestNodes(nodes) {
 }
 
 class NestedNode {
-  constructor(node, childNestedNodes) {
-    this.node = node;
+  constructor(htmlNode, childNestedNodes) {
+    this.htmlNode = htmlNode;
     this.childNestedNodes = childNestedNodes;
   }
 
-  getNode() {
-    return this.node;
+  getHTMLNode() {
+    return this.htmlNode;
   }
 
   getChildNestedNodes() {
@@ -50,17 +50,17 @@ class NestedNode {
     this.childNestedNodes.push(childNestedNode);
   }
 
-  static fromNode(node) {
+  static fromHTMLNode(htmlNode) {
     const childNestedNodes = [],
-          nestedNode = new NestedNode(node, childNestedNodes);
+          nestedNode = new NestedNode(htmlNode, childNestedNodes);
 
     return nestedNode;
   }
 
   static fromNothing() {
-    const node = null,
+    const htmlNode = null,
           childNestedNodes = [],
-          nestedNode = new NestedNode(node, childNestedNodes);
+          nestedNode = new NestedNode(htmlNode, childNestedNodes);
 
     return nestedNode;
   }

package/src/utilities/division.js

@@ -0,0 +1,256 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import HTMLTransform from "../transform/html";
+import FootnoteHTMLNode from "../node/html/footnote";
+import LineHTMLTransform from "../transform/html/line";
+import FootnoteHTMLTransform from "../transform/html/footnote";
+import FootnoteItemHTMLTransform from "../transform/html/item/footnote";
+import FootnoteLinkHTMLTransform from "../transform/html/link/footnote";
+import NestedFootnoteLinkHTMLTransform from "../transform/html/link/nestedFootnote";
+import FootnotesDirectiveHTMLTransform from "../transform/html/directive/footnotes";
+import PageNumberDirectiveHTMLTransform from "../transform/html/directive/pageNumber";
+
+import { DEFAULT_MAXIMUM_PAGE_LINES } from "../constants";
+import { htmlNodesFromNode,
+         footnoteHTMLNodesFromNode,
+         footnoteLinkHTMLNodesFromNode,
+         footnotesDirectiveHTMLNodeFromNode,
+         nestedFootnoteLinkHTMLNodesFromNode,
+         pageNumberDirectiveHTMLNodeFromNode } from "../utilities/html";
+
+const { backwardsForEach } = arrayUtilities;
+
+export function groupHTMLNodes(htmlNodes) {
+  const groupedHTMLNodesArray = [];
+
+  let groupedHTMLNodes = [];
+
+  htmlNodes.forEach((htmlNode) => {
+    const htmlNodeFootnoteHTMLNode = (htmlNode instanceof FootnoteHTMLNode);
+
+    if (!htmlNodeFootnoteHTMLNode) {
+      const groupedHTMLNodeLength = groupedHTMLNodes.length;
+
+      if (groupedHTMLNodeLength > 0) {
+        groupedHTMLNodesArray.push(groupedHTMLNodes);
+
+        groupedHTMLNodes = [];
+      }
+    }
+
+    const groupedHTMLNode = htmlNode; ///
+
+    groupedHTMLNodes.push(groupedHTMLNode);
+  });
+
+  const groupedHTMLNodeLength = groupedHTMLNodes.length;
+
+  if (groupedHTMLNodeLength) {
+    groupedHTMLNodesArray.push(groupedHTMLNodes);
+  }
+
+  return groupedHTMLNodesArray;
+}
+
+export function removeHTMLNodes(node) {
+  const htmlNodes = htmlNodesFromNode(node);
+
+  htmlNodes.forEach((htmlNode) => {
+    const htmlTransform = HTMLTransform.fromHTMLNode(htmlNode);
+
+    htmlTransform.remove();
+  });
+
+  return htmlNodes;
+}
+
+export function addFootnoteHTMLNodes(footnoteHTMLTransforms, node, context) {
+  const footnoteLinkHTMLNodes = footnoteLinkHTMLNodesFromNode(node),
+        footnoteLinkHTMLTransforms = footnoteLinkHTMLTransformsFromFootnoteLinkHTMLNodes(footnoteLinkHTMLNodes);
+
+  backwardsForEach(footnoteLinkHTMLTransforms, (footnoteLinkHTMLTransform) => {
+    const identifier = footnoteLinkHTMLTransform.identifier(context),
+          footnoteHTMLTransform = footnoteHTMLTransforms.find((footnoteHTMLTransform) => {
+            const identifierMatches = footnoteHTMLTransform.matchIdentifier(identifier, context);
+
+            if (identifierMatches) {
+              return true;
+            }
+          }) || null;
+
+    if (footnoteHTMLTransform !== null) {
+      footnoteHTMLTransform.addAfterFootnoteLinkHTMLTransform(footnoteLinkHTMLTransform);
+    }
+  });
+}
+
+export function removeFootnoteHTMLNodes(node) {
+  const footnoteHTMLNodes = footnoteHTMLNodesFromNode(node),
+        footnoteHTMLTransforms = footnoteHTMLTransformsFromFootnoteHTMLNodes(footnoteHTMLNodes);
+
+  footnoteHTMLTransforms.forEach((footnoteHTMLTransform) => {
+    footnoteHTMLTransform.remove();
+  });
+
+  return footnoteHTMLTransforms;
+}
+
+export function paginateGroupedHTMLNodes(groupedHTMLNodesArray, context) {
+  const paginatedHTMLNodesArray = [];
+
+  const { maximumPageLines = DEFAULT_MAXIMUM_PAGE_LINES } = context;
+
+  let pageLines = 0,
+      paginatedHTMLNodes = [];
+
+  groupedHTMLNodesArray.forEach((groupedHTMLNodes) => {
+    const groupLines = groupedHTMLNodes.reduce((groupLines, groupedHTMLNode) => {
+      const lines = groupedHTMLNode.lines(context);
+
+      groupLines += lines;
+
+      return groupLines;
+    }, 0);
+
+    const paginatedHTMLNodesLength = paginatedHTMLNodes.length;
+
+    if (paginatedHTMLNodesLength > 0) {
+      if (pageLines + groupLines > maximumPageLines) {
+        paginatedHTMLNodesArray.push(paginatedHTMLNodes);
+
+        pageLines = 0;
+
+        paginatedHTMLNodes = [];
+      }
+    }
+
+    paginatedHTMLNodes.push(...groupedHTMLNodes);
+
+    pageLines += groupLines;
+  });
+
+  const paginatedHTMLNodesLength = paginatedHTMLNodes.length;
+
+  if (paginatedHTMLNodesLength) {
+    paginatedHTMLNodesArray.push(paginatedHTMLNodes);
+  }
+
+  return paginatedHTMLNodesArray;
+}
+
+export function numberFootnoteLinkHTMLNodes(footnoteHTMLTransforms, identifierMap, node, context) {
+  const footnoteLinkHTMLNodes = footnoteLinkHTMLNodesFromNode(node),
+        identifiers = Object.keys(identifierMap),
+        identifiersLength = identifiers.length,
+        start = identifiersLength + 1;
+
+  footnoteHTMLTransforms.forEach((footnoteHTMLTransform, index) => {
+    const identifier = footnoteHTMLTransform.identifier(context),
+          number = start + index;
+
+    identifierMap[identifier] = number;
+  });
+
+  footnoteLinkHTMLNodes.forEach((footnoteLinkHTMLNode) => {
+    const identifier = footnoteLinkHTMLNode.identifier(context),
+          number = identifierMap[identifier];
+
+    footnoteLinkHTMLNode.setNumber(number);
+  })
+
+  return start;
+}
+
+export function removeFootnotesDirectiveHTMLNode(node) {
+  const footnotesDirectiveHTMLNode = footnotesDirectiveHTMLNodeFromNode(node);
+
+  if (footnotesDirectiveHTMLNode !== null) {
+    const footnotesDirectiveHTMLTransform = FootnotesDirectiveHTMLTransform.fromFootnotesDirectiveHTMLNode(footnotesDirectiveHTMLNode);
+
+    footnotesDirectiveHTMLTransform.remove();
+  }
+
+  return footnotesDirectiveHTMLNode;
+}
+
+export function removePageNumberDirectiveHTMLNode(node) {
+  let pageNumberDirectiveHTNLTransform = null;
+
+  const pageNumberDirectiveHTMLNode = pageNumberDirectiveHTMLNodeFromNode(node);
+
+  if (pageNumberDirectiveHTMLNode !== null) {
+    pageNumberDirectiveHTNLTransform = PageNumberDirectiveHTMLTransform.fromPageNumberDirectiveHTMLNode(pageNumberDirectiveHTMLNode);
+
+    pageNumberDirectiveHTNLTransform.remove();
+  }
+
+  return pageNumberDirectiveHTNLTransform;
+}
+
+export function removeNestedFootnoteLinkHTMLNodes(node) {
+  const nestedFootnoteLinkHTMLNodes = nestedFootnoteLinkHTMLNodesFromNode(node),
+        nestedFootnoteLinkHTMLTransforms = nestedFootnoteLinkHTMLTransformsFromNestedFootnoteLinkHTMLNodes(nestedFootnoteLinkHTMLNodes);
+
+  nestedFootnoteLinkHTMLTransforms.forEach((nestedFootnoteLinkHTMLTransform) => {
+    nestedFootnoteLinkHTMLTransform.remove();
+  });
+}
+
+export function lineHTMLTransformsFromFootnoteHTMLTransforms(footnoteHTMLTransforms) {
+  const lineHTMLTransforms = footnoteHTMLTransforms.map((footnoteHTMLTransform) => {
+    const lineHTMLTransform = LineHTMLTransform.fromFootnoteHTMLTransform(footnoteHTMLTransform);
+
+    return lineHTMLTransform;
+  });
+
+  return lineHTMLTransforms;
+}
+
+export function footnoteItemHTMLTransformsFromLineHTMLTransforms(lineHTMLTransforms, identifierMap, start) {
+  const numbers = Object.values(identifierMap),
+        identifiers = Object.keys(identifierMap),
+        footnoteItemHTMLTransforms = lineHTMLTransforms.map((lineHTMLTransform, index) => {
+          const number = start + index;
+
+          index = numbers.indexOf(number);
+
+          const identifier = identifiers[index],
+                footnoteItemHTMLTransform = FootnoteItemHTMLTransform.fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier);
+
+          return footnoteItemHTMLTransform;
+        });
+
+  return footnoteItemHTMLTransforms;
+}
+
+function footnoteHTMLTransformsFromFootnoteHTMLNodes(footnoteHTMLNodes) {
+  const footnoteHTMLTransforms = footnoteHTMLNodes.map((footnoteHTMLNode) => {
+    const footnoteHTMLTransform = FootnoteHTMLTransform.fromFootnoteHTMLNode(footnoteHTMLNode);
+
+    return footnoteHTMLTransform;
+  });
+
+  return footnoteHTMLTransforms;
+}
+
+function footnoteLinkHTMLTransformsFromFootnoteLinkHTMLNodes(footnoteLinkHTMLNodes) {
+  const footnoteLinkHTMLTransforms = footnoteLinkHTMLNodes.map((footnoteLinkHTMLNode) => {
+    const footnoteLinkHTMLTransform = FootnoteLinkHTMLTransform.fromFootnoteLinkHTMLNode(footnoteLinkHTMLNode);
+
+    return footnoteLinkHTMLTransform;
+  });
+
+  return footnoteLinkHTMLTransforms;
+}
+
+function nestedFootnoteLinkHTMLTransformsFromNestedFootnoteLinkHTMLNodes(nestedFootnoteLinkHTMLNodes) {
+  const nestedFootnoteLinkHTMLTransforms = nestedFootnoteLinkHTMLNodes.map((nestedFootnoteLinkHTMLNode) => {
+    const nestedFootnoteLinkHTMLTransform = NestedFootnoteLinkHTMLTransform.fromNestedFootnoteLinkHTMLNode(nestedFootnoteLinkHTMLNode);
+
+    return nestedFootnoteLinkHTMLTransform;
+  });
+
+  return nestedFootnoteLinkHTMLTransforms;
+}

package/src/utilities/footnotes.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import FootnotesListMarkdownNode from "../node/markdown/list/footnotes";
+import FootnotesListHTMLNode from "../node/html/list/footnotes";
 
 export function renumberFootnoteLinkMarkdownNodes(divisionMarkdownNode, footnoteReplacementMap, context) {
   const node = divisionMarkdownNode,  ///
@@ -17,14 +17,14 @@ export function renumberFootnoteLinkMarkdownNodes(divisionMarkdownNode, footnote
   });
 }
 
-export function footnotesListMarkdownNodeFromFootnotesListDOMElement(footnotesListDOMElement) {
+export function footnotesListHTMLNodeFromFootnotesListDOMElement(footnotesListDOMElement) {
   const domElement = footnotesListDOMElement, ///
-        footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDOMElement(domElement);
+        footnotesListHTMLNode = FootnotesListHTMLNode.fromDOMElement(domElement);
 
-  return footnotesListMarkdownNode;
+  return footnotesListHTMLNode;
 }
 
 export default {
   renumberFootnoteLinkMarkdownNodes,
-  footnotesListMarkdownNodeFromFootnotesListDOMElement
+  footnotesListHTMLNodeFromFootnotesListDOMElement
 };