highmark-markdown 1.0.173 → 1.0.174

package/src/node/html/topmost.js

@@ -1,20 +1,69 @@
 "use strict";
 
+import { nodeUtilities} from "occam-dom";
+import { arrayUtilities } from "necessary";
+
+import queries from "../../queries";
 import HTMLNode from "../../node/html";
+import htmlNodeMap from "../../map/node/html";
 
-export default class TopmostHTMLNode extends HTMLNode {
-  asHTML(context) {
-    let html;
+const { push } = arrayUtilities,
+      { topmostNodeFromOuterNodes } = nodeUtilities;
 
-    const indent = null,
-          childNodesHTML = this.childNodesAsHTML(indent, context);
+export default class TopmostHTMLNode extends HTMLNode {
+  adjustIndent(indent) {
+    return indent;
+  }
 
-    html = childNodesHTML;  ///
+  asString() {
+    const { tagName } = this.constructor,
+          string = tagName; ///
 
-    return html;
+    return string;
   }
 
+  static tagName = "html";
+
+  static className = null;
+
   static fromNothing() { return HTMLNode.fromNothing(TopmostHTMLNode); }
 
-  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(TopmostHTMLNode, outerNode); }
+  static fromTopmostMarkdownNode(topmostMarkdownNode) {
+
+  }
+
+  static fromDivisionMarkdownNode(divisionMarkdownNode) {
+    const node = divisionMarkdownNode,  ///
+          nodes = nodesFromNodeAndQueries(node, queries),
+          topmostHTMLNode = topmostNodeFromOuterNodes(ClassFromOuterNode, nodes);
+
+    return topmostHTMLNode;
+  }
+}
+
+function ClassFromOuterNode(outerNode) {
+  let Class;
+
+  if (outerNode === null) {
+    Class = TopmostHTMLNode;  ///
+  } else {
+    const nonTerminalNode = outerNode,  ///
+      ruleName = nonTerminalNode.getRuleName();
+
+    Class = htmlNodeMap[ruleName] || HTMLNode;
+  }
+
+  return Class;
+}
+
+function nodesFromNodeAndQueries(node, queries) {
+  const nodes = [];
+
+  queries.forEach((query) => {
+    const queryNodes = query.execute(node);
+
+    push(nodes, queryNodes);
+  });
+
+  return nodes;
 }

package/src/node/html.js

@@ -2,42 +2,68 @@
 
 import { Node } from "occam-dom";
 
-import elementMap from "../elementMap";
+import nodeMixins from "../mixins/node";
 
 import { EMPTY_STRING, DOUBLE_SPACE } from "../constants";
 
-export default class HTMLNode extends Node {
-  getRuleName() {
-    let ruleName;
+class HTMLNode extends Node {
+  constructor(outerNode, parentNode, childNodes, domElement) {
+    super(outerNode, parentNode, childNodes);
 
-    const outerNode = this.getOuterNode(),
-          nonTerminalNode = outerNode;  ///
+    this.domElement = domElement;
+  }
 
-    ruleName = nonTerminalNode.getRuleName();
+  getDOMElement() {
+    return this.domElement;
+  }
 
-    return ruleName;
+  setDOMElement(domElement) {
+    this.domElement = domElement;
   }
 
-  tagName(context) {
-    let tagName;
+  getMarkdownNode() {
+    const outerNode = this.getOuterNode(),
+          markdownNode = outerNode; ///
 
-    const ruleName = this.getRuleName();
+    return markdownNode;
+  }
 
-    const element = elementMap[ruleName];
+  getRuleName() { return this.outerNode.getRuleName(); }
 
-    ({ tagName } = element);
+  adjustIndent(indent) {
+    indent = (indent === null) ?
+               EMPTY_STRING :
+                `${DOUBLE_SPACE}${indent}`;
 
-    return tagName;
+    return indent;
   }
 
-  className(context) {
-    let className;
+  lines(context) {
+    let lines;
+
+    ({ lines = null } = this.constructor);
+
+    if (lines === null) {
+      lines = this.reduceChildNode((lines, childNode) => {
+        const childNodeLines = childNode.lines(context);
+
+        lines += childNodeLines;
+
+        return lines;
+      }, 0);
+    }
 
-    const ruleName = this.getRuleName();
+    return lines;
+  }
 
-    const element = elementMap[ruleName];
+  tagName(context) {
+    const { tagName } = this.constructor;
 
-    ({ className } = element);
+    return tagName;
+  }
+
+  className(context) {
+    const { className } = this.constructor;
 
     return className;
   }
@@ -93,12 +119,56 @@ export default class HTMLNode extends Node {
     return attributeValue;
   }
 
-  adjustIndent(indent) {
-    indent = (indent === null) ?
-               EMPTY_STRING :
-                `${DOUBLE_SPACE}${indent}`;
+  createDOMElement(context) {
+    let domElement;
 
-    return indent;
+    const tagName = this.tagName(context);
+
+    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;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.domElement = this.createDOMElement(context);
+
+    parentDOMElement.insertBefore(this.domElement, siblingDOMElement)
+
+    parentDOMElement = this.domElement; ///
+
+    siblingDOMElement = null;
+
+    this.childNodes.forEach((childNode) => {
+      childNode.mount(parentDOMElement, siblingDOMElement, context);
+    });
+  }
+
+  unmount(parentDOMElement, context) {
+    {
+      const parentDOMElement = this.domElement; ///
+
+      this.childNodes.forEach((childNode) => {
+        childNode.unmount(parentDOMElement, context);
+      });
+    }
+
+    parentDOMElement.removeChild(this.domElement);
+
+    this.domElement = null;
   }
 
   asHTML(indent, context) {
@@ -110,61 +180,69 @@ export default class HTMLNode extends Node {
 
     let html;
 
-    const tagName = this.tagName(context);
+    indent = this.adjustIndent(indent);
 
-    if (tagName === null) {
-      const childNodesHTML = this.childNodesAsHTML(indent, context);
+    const childNodesHTML = this.childNodesAsHTML(indent, context);
 
-      html = childNodesHTML;  ///
-    } else {
-      indent = this.adjustIndent(indent);
-
-      const childNodesHTML = this.childNodesAsHTML(indent, context);
+    if (childNodesHTML !== EMPTY_STRING) {
+      const startingTag = this.startingTag(context),
+            closingTag = this.closingTag(context);
 
-      if (childNodesHTML !== null) {
-        const startingTag = this.startingTag(context),
-              closingTag = this.closingTag(context);
-
-        html = (indent === null) ?
-                `${startingTag}${childNodesHTML}${closingTag}` :
-                  `${indent}${startingTag}
+      html = `${indent}${startingTag}
 ${childNodesHTML}${indent}${closingTag}
 `;
-      } else {
-        const selfClosingTag = this.selfClosingTag(context);
+    } else {
+      const selfClosingTag = this.selfClosingTag(context);
 
-        html = (indent === null) ?
-                 selfClosingTag :  ///
-                  `${indent}${selfClosingTag}
+      html = `${indent}${selfClosingTag}
 `;
-      }
     }
 
     return html;
   }
 
+  asPlainText(context) {
+    let plainText;
+
+    const childNodesPlainText = this.childNodesAsPlainText(context);
+
+    plainText = childNodesPlainText;  ///
+
+    return plainText;
+  }
+
   childNodesAsHTML(indent, context) {
     const childNodesHTML = this.reduceChildNode((childNodesHTML, childNode) => {
       const childNodeHTML = childNode.asHTML(indent, context);
 
-      if (childNodeHTML !== null) {
-        childNodesHTML = (childNodesHTML === null) ?
-                           childNodeHTML :  ///
-                            `${childNodesHTML}${childNodeHTML}`;
-      }
+      childNodesHTML = `${childNodesHTML}${childNodeHTML}`;
 
       return childNodesHTML;
-    }, null);
+    }, EMPTY_STRING);
 
     return childNodesHTML;
   }
 
+  childNodesAsPlainText(context) {
+    const childNodesPlainText = this.reduceChildNode((childNodesPlainText, childNode) => {
+      const childNodePlainText = childNode.asPlainText(context);
+
+      childNodesPlainText = `${childNodesPlainText}
+${childNodePlainText}`;
+
+      return childNodesPlainText;
+    }, EMPTY_STRING);
+
+    return childNodesPlainText;
+  }
+
   static fromNothing(Class) {
     if (Class === undefined) {
       Class = HTMLNode; ///
     }
 
-    const node = Node.fromNothing(Class);
+    const domElement = null,
+          node = Node.fromNothing(Class, domElement);
 
     return node;
   }
@@ -176,8 +254,13 @@ ${childNodesHTML}${indent}${closingTag}
       Class = HTMLNode; ///
     }
 
-    const node = Node.fromOuterNode(Class, outerNode);
+    const domElement = null,
+          node = Node.fromOuterNode(Class, outerNode, domElement);
 
     return node;
   }
 }
+
+Object.assign(HTMLNode.prototype, nodeMixins);
+
+export default HTMLNode;

package/src/node/markdown/anchor.js

@@ -6,7 +6,6 @@ import MarkdownNode from "../../node/markdown";
 
 import { EMPTY_STRING } from "../../constants";
 import { ANCHOR_RULE_NAME } from "../../ruleNames";
-import { ID_ATTRIBUTE_NAME } from "../../attributeNames";
 
 export default class AnchorMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, opacity, precedence, domElement, prepend, identifier) {
@@ -24,30 +23,11 @@ export default class AnchorMarkdownNode extends MarkdownNode {
     return this.identifier;
   }
 
-  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;
-  }
-
-  content(context) {
-    const content = EMPTY_STRING;
-
-    return content;
-  }
+  // content(context) {
+  //   const content = EMPTY_STRING;
+  //
+  //   return content;
+  // }
 
   clone() { return super.clone(this.prepend, this.identifier); }
 

package/src/node/markdown/{table.js → blockEnd.js}

@@ -2,6 +2,6 @@
 
 import MarkdownNode from "../../node/markdown";
 
-export default class TableMarkdownNode extends MarkdownNode {
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(TableMarkdownNode, ruleName, childNodes, opacity); }
+export default class BlockEndMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(BlockEndMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/blockListing.js

@@ -4,19 +4,13 @@ import MarkdownNode from "../../node/markdown";
 
 export default class BlockListingMarkdownNode extends MarkdownNode {
   className(context) {
-    let className = super.className(context);
+    const className = this.fromFirstChildNode((firstChildNode) => {
+      const blockStartMarkdownNode = firstChildNode, ///
+            className = blockStartMarkdownNode.className(context);
 
-    const blockListingStartMarkdownNodeClassName = this.fromFirstChildNode((firstChildNode) => {
-      const blockListingStartMarkdownNode = firstChildNode, ///
-            blockListingStartMarkdownNodeClassName = blockListingStartMarkdownNode.className(context);
-
-      return blockListingStartMarkdownNodeClassName;
+      return className;
     });
 
-    if (blockListingStartMarkdownNodeClassName !== null) {
-      className = `${className} ${blockListingStartMarkdownNodeClassName}`;
-    }
-
     return className;
   }
 

package/src/node/markdown/{blockListingStart.js → blockStart.js}

@@ -3,15 +3,15 @@
 import MarkdownNode from "../../node/markdown";
 import ClassNameMarkdownNode from "./className";
 
-export default class BlockListingStartMarkdownNode extends MarkdownNode {
+export default class BlockStartMarkdownNode extends MarkdownNode {
   className(context) {
     const className = this.fromSecondChildNode((secondChildNode) => {
       let className = null;
 
-      const secondChildNodeClassNameMarkdownNode = (secondChildNode instanceof ClassNameMarkdownNode)
+      const secondChildNodeClassNameMarkdownNode = (secondChildNode instanceof ClassNameMarkdownNode);
 
       if (secondChildNodeClassNameMarkdownNode) {
-        const classNameMarkdownNode = secondChildNode; ///
+        const classNameMarkdownNode = secondChildNode;  ///
 
         className = classNameMarkdownNode.className(context);
       }
@@ -22,7 +22,5 @@ export default class BlockListingStartMarkdownNode extends MarkdownNode {
     return className;
   }
 
-  static lines = 2;
-
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(BlockListingStartMarkdownNode, ruleName, childNodes, opacity); }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(BlockStartMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/className.js

@@ -6,8 +6,8 @@ export default class ClassNameMarkdownNode extends MarkdownNode {
   className(context) {
     const className = this.fromSecondChildNode((secondChildNode) => {
       const identifierTerminalNode = secondChildNode, ///
-            identifierTerminalNodeContent = identifierTerminalNode.getContent(),
-            className = identifierTerminalNodeContent; ///
+            content = identifierTerminalNode.getContent(),
+            className = content;  ///
 
       return className;
     });

package/src/node/markdown/contentsItem.js

@@ -5,11 +5,11 @@ import MarkdownNode from "../../node/markdown";
 import { CONTENTS_ITEM_RULE_NAME } from "../../ruleNames";
 
 export default class ContentsItemMarkdownNode extends MarkdownNode {
-  static fromReplacements(replacements) {
+  static fromReplacements(transforms) {
     const ruleName = CONTENTS_ITEM_RULE_NAME,
-          childNodes = replacements.map((replacement) => {
-            const replacementNode = replacement.getNode(),
-                  childNode = replacementNode;  ///
+          childNodes = transforms.map((transform) => {
+            const transformNode = transform.getNode(),
+                  childNode = transformNode;  ///
 
             return childNode;
           }),

package/src/node/markdown/contentsList.js

@@ -5,12 +5,6 @@ import MarkdownNode from "../../node/markdown";
 import { CONTENTS_LIST_RULE_NAME } from "../../ruleNames";
 
 export default class ContentsListMarkdownNode extends MarkdownNode {
-  asPlainText(context) {
-    const plainText = null;
-
-    return plainText;
-  }
-
   static fromContentsItemReplacements(contentsItemReplacements) {
     const ruleName = CONTENTS_LIST_RULE_NAME,
           childNodes = contentsItemReplacements.map((contentsItemReplacement) => {

package/src/node/markdown/directive/embee.js

@@ -1,12 +1,12 @@
 "use strict";
 
-import PathMarkdownNode from "../path";
-import DirectiveMarkdownNode from "../../../node/markdown/directive";
-import EmbedDirectiveReplacement from "../../../replacement/embedDirective";
+import MarkdownNode from "../../../node/markdown";
+import PathMarkdownNode from "../../../node/markdown/path";
+import EmbedDirectiveTransform from "../../../transform/embedDirective";
 
-export default class EmbedDirectiveMarkdownNode extends DirectiveMarkdownNode {
+export default class EmbedDirectiveMarkdownNode extends MarkdownNode {
   resolve(context) {
-    let embedDirectiveReplacement = null;
+    let embedDirectiveTransform = null;
 
     const filePath = this.filePath(context);
 
@@ -25,11 +25,11 @@ export default class EmbedDirectiveMarkdownNode extends DirectiveMarkdownNode {
         const divisionMarkdownNode = importedNode,  ///
               tokens = importedTokens;  ///
 
-        embedDirectiveReplacement = EmbedDirectiveReplacement.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
+        embedDirectiveTransform = EmbedDirectiveTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
       }
     }
 
-    return embedDirectiveReplacement;
+    return embedDirectiveTransform;
   }
 
   filePath(context) {
@@ -40,9 +40,9 @@ export default class EmbedDirectiveMarkdownNode extends DirectiveMarkdownNode {
 
       if (firstLastChildNodePathMarkdownNode) {
         const pathMarkdownNode = firstLastChildNode, ///
-              pathMarkdownNodeContent = pathMarkdownNode.getContent();
+              pathMarkdownNodePath = pathMarkdownNode.path(context);
 
-        filePath = pathMarkdownNodeContent; ///
+        filePath = pathMarkdownNodePath; ///
       }
 
       return filePath;
@@ -51,5 +51,5 @@ export default class EmbedDirectiveMarkdownNode extends DirectiveMarkdownNode {
     return filePath;
   }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return DirectiveMarkdownNode.fromRuleNameChildNodesAndOpacity(EmbedDirectiveMarkdownNode, ruleName, childNodes, opacity); }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(EmbedDirectiveMarkdownNode, ruleName, childNodes, opacity); }
 }

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

@@ -1,12 +1,12 @@
 "use strict";
 
-import PathMarkdownNode from "../path";
-import DirectiveMarkdownNode from "../../../node/markdown/directive";
-import IncludeDirectiveReplacement from "../../../replacement/includeDirective";
+import MarkdownNode from "../../../node/markdown";
+import PathMarkdownNode from "../../../node/markdown/path";
+import IncludeDirectiveTransform from "../../../transform/includeDirective";
 
-export default class IncludeDirectiveMarkdownNode extends DirectiveMarkdownNode {
+export default class IncludeDirectiveMarkdownNode extends MarkdownNode {
   resolve(context) {
-    let includeDirectiveReplacement = null;
+    let includeDirectiveTransform = null;
 
     const filePath = this.filePath(context);
 
@@ -30,11 +30,11 @@ export default class IncludeDirectiveMarkdownNode extends DirectiveMarkdownNode
 
         divisionMarkdownNode.setDivisionClassName(divisionClassName);
 
-        includeDirectiveReplacement = IncludeDirectiveReplacement.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
+        includeDirectiveTransform = IncludeDirectiveTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
       }
     }
 
-    return includeDirectiveReplacement;
+    return includeDirectiveTransform;
   }
 
   filePath(context) {
@@ -45,9 +45,9 @@ export default class IncludeDirectiveMarkdownNode extends DirectiveMarkdownNode
 
       if (firstLastChildNodePathMarkdownNode) {
         const pathMarkdownNode = firstLastChildNode, ///
-              pathMarkdownNodeContent = pathMarkdownNode.getContent();
+              pathMarkdownNodePath = pathMarkdownNode.path(context);
 
-        filePath = pathMarkdownNodeContent; ///
+        filePath = pathMarkdownNodePath; ///
       }
 
       return filePath;
@@ -56,5 +56,5 @@ export default class IncludeDirectiveMarkdownNode extends DirectiveMarkdownNode
     return filePath;
   }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return DirectiveMarkdownNode.fromRuleNameChildNodesAndOpacity(IncludeDirectiveMarkdownNode, ruleName, childNodes, opacity); }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IncludeDirectiveMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/directive/pageNumber.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import DirectiveMarkdownNode from "../../../node/markdown/directive";
+import MarkdownNode from "../../../node/markdown";
 
-export default class PageNumberDirectiveMarkdownNode extends DirectiveMarkdownNode {
-  constructor(ruleName, childNodes, precedence, opacity, domElement, pageNumber) {
-    super(ruleName, childNodes, precedence, opacity, domElement);
+export default class PageNumberDirectiveMarkdownNode extends MarkdownNode {
+  constructor(ruleName, childNodes, precedence, opacity, pageNumber) {
+    super(ruleName, childNodes, precedence, opacity);
 
     this.pageNumber = pageNumber;
   }
@@ -17,36 +17,17 @@ export default class PageNumberDirectiveMarkdownNode extends DirectiveMarkdownNo
     this.pageNumber = pageNumber;
   }
 
-  content(context) {
-    const content = this.pageNumber;
-
-    return content;
-  }
-
-  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;
-  }
+  // content(context) {
+  //   const content = this.pageNumber;
+  //
+  //   return content;
+  // }
 
   clone() { return super.clone(this.pageNumber); }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
     const pageNumber = null,
-          pageNumberDirectiveMarkdownNode = DirectiveMarkdownNode.fromRuleNameChildNodesAndOpacity(PageNumberDirectiveMarkdownNode, ruleName, childNodes, opacity, pageNumber);
+          pageNumberDirectiveMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(PageNumberDirectiveMarkdownNode, ruleName, childNodes, opacity, pageNumber);
 
     return pageNumberDirectiveMarkdownNode;
   }