highmark-markdown 0.0.434 → 0.0.436

package/src/index/list.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import { stringUtilities } from "necessary";
+
+import IndexItem from "../index/item";
+
+import { indexMapFromDivisionMarkdownNodes } from "../utilities/index";
+
+const { strcmp } = stringUtilities;
+
+export default class IndexList {
+  constructor(indexItems) {
+    this.indexItems = indexItems;
+  }
+
+  getIndexItems() {
+    return this.indexItems;
+  }
+
+  reduceIndexItemByLetter(letter, callback) {
+    const indexItems = this.indexItems.filter((indexItem) => {
+      const indexItemMatchesLetter = indexItem.matchLetter(letter);
+
+      if (indexItemMatchesLetter) {
+        return true;
+      }
+    });
+
+    const result = indexItems.map(callback);
+
+    return result;
+  }
+
+  static fromDivisionMarkdownNodes(divisionMarkdownNodes, context) {
+    const indexMap = indexMapFromDivisionMarkdownNodes(divisionMarkdownNodes, context),
+          indexItems = indexItemsFromIndexMap(indexMap),
+          indexList = new IndexList(indexItems);
+
+    return indexList;
+  }
+}
+
+function indexItemsFromIndexMap(indexMap) {
+  const wordsOrPhrases = Object.keys(indexMap); ///
+
+  wordsOrPhrases.sort((wordOrPhraseA, wordOrPhraseB) => {
+    const lowerCaseWordOrPhraseA = wordOrPhraseA.toLowerCase(),
+          lowerCaseWordOrPhraseB = wordOrPhraseB.toLowerCase(),
+          difference = strcmp(lowerCaseWordOrPhraseB, lowerCaseWordOrPhraseA);
+
+    return difference;
+  });
+
+  const indexItems = wordsOrPhrases.map((wordOrPhrase, index) => {
+    const pageNumbers = indexMap[wordOrPhrase],
+          indexItem = IndexItem.fromWordOrPhraseAndPageNumbers(wordOrPhrase, pageNumbers);
+
+    return indexItem;
+  })
+
+  return indexItems;
+}

package/src/index/{phraseMatcher.js → match.js}

@@ -2,7 +2,7 @@
 
 import { UNDERSCORE, GLOBAL_FLAG, SINGLE_SPACE } from "../constants";
 
-export default class PhraseMatcher {
+export default class IndexMatch {
   constructor(regularExpression, replacement) {
     this.regularExpression = regularExpression;
     this.replacement = replacement;
@@ -22,17 +22,17 @@ export default class PhraseMatcher {
     return plainText;
   }
 
-  static revert(entry) {
-    entry = entry.replace(/_/g, SINGLE_SPACE);
+  static revert(wordOrPhrase) {
+    wordOrPhrase = wordOrPhrase.replace(/_/g, SINGLE_SPACE);
 
-    return entry;
+    return wordOrPhrase;
   }
 
   static fromPhrase(phrase) {
     const regularExpression = new RegExp(phrase, GLOBAL_FLAG),
           replacement = phrase.replace(/\s/g, UNDERSCORE),
-          phraseMatcher = new PhraseMatcher(regularExpression, replacement);
+          indexMatch = new IndexMatch(regularExpression, replacement);
 
-    return phraseMatcher;
+    return indexMatch;
   }
 }

package/src/letters.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const letters = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z"
+];
+
+export default letters;

package/src/markdown/bnf.js

@@ -260,10 +260,13 @@ const bnf = `
     footnotesItem           ::=  anchor paragraph ;
 
 
+    indexHeading            ::=  line ;
+    
+    
     indexList               ::=  indexItem+ ;
 
 
-    indexItem               ::=  line... indexLink ( comma indexLink )* ;
+    indexItem               ::=  line... comma indexLink ( comma indexLink )* ;
 
 
     indexLink               ::=  [number] ;    

package/src/node/markdown/division.js

@@ -3,8 +3,8 @@
 import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
+import IndexReplacement from "../../replacement/index";
 import FootnoteReplacement from "../../replacement/footnote";
-import IndexListReplacement from "../../replacement/indexList";
 import ContentsListReplacement from "../../replacement/contentsList";
 import FootnotesListReplacement from "../../replacement/footnotesList";
 import FootnoteSubDivisionReplacement from "../../replacement/subDivision/footnote";
@@ -139,10 +139,10 @@ export default class DivisionMarkdownNode extends MarkdownNode {
 
     if (indexDirectiveSubDivisionReplacement !== null) {
       const divisionMarkdownNode = this,  ///
-            indexListReplacement = IndexListReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
+            indexReplacement = IndexReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
 
-      if (indexListReplacement !== null) {
-        indexListReplacement.replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
+      if (indexReplacement !== null) {
+        indexReplacement.replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
 
         indexCreated = true;
       }

package/src/node/markdown/footnotesList.js

@@ -31,22 +31,15 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
   clone() { return super.clone(this.start); }
 
   static fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start) {
-    let footnotesListMarkdownNode = null;
-
-    const footnotesItemReplacementsLength = footnotesItemReplacements.length;
-
-    if (footnotesItemReplacementsLength > 0) {
-      const ruleName = FOOTNOTES_LIST_RULE_NAME,
-            childNodes = footnotesItemReplacements.map((footnotesItemReplacement) => {
-              const footnotesItemReplacementMode = footnotesItemReplacement.getFootnotesItemMarkdownNode(),
-                    childNode = footnotesItemReplacementMode; ///
-
-              return childNode;
-            }),
-            opacity = null;
-
-      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
-    }
+    const ruleName = FOOTNOTES_LIST_RULE_NAME,
+          childNodes = footnotesItemReplacements.map((footnotesItemReplacement) => {
+            const footnotesItemReplacementMode = footnotesItemReplacement.getFootnotesItemMarkdownNode(),
+                  childNode = footnotesItemReplacementMode; ///
+
+            return childNode;
+          }),
+          opacity = null,
+          footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
 
     return footnotesListMarkdownNode;
   }

package/src/node/markdown/indexHeading.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class IndexHeadingMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexHeadingMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/indexItem.js

@@ -3,5 +3,25 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class IndexItemMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    indent = this.adjustIndent(indent);
+
+    const childNodesHTML = this.childNodesAsHTML(indent, context),
+          startingTag = this.startingTag(context),
+          closingTag = this.closingTag(context),
+          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
+`;
+
+    return html;
+  }
+
+  childNodesAsHTML(indent, context) {
+    indent = null;
+
+    const childNodesHTML = super.childNodesAsHTML(indent, context);
+
+    return childNodesHTML;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexItemMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/indexLink.js

@@ -24,13 +24,10 @@ export default class IndexLinkMarkdownNode extends MarkdownNode {
   }
 
   asHTML(indent, context) {
-    indent = this.adjustIndent(indent);
-
     const childNodesHTML = this.childNodesAsHTML(indent, context),
           startingTag = this.startingTag(context),
           closingTag = this.closingTag(context),
-          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
-`;
+          html = `${startingTag}${childNodesHTML}${closingTag}`;
 
     return html;
   }

package/src/node/markdown/indexList.js

@@ -12,22 +12,15 @@ export default class IndexListMarkdownNode extends MarkdownNode {
   }
 
   static fromIndexItemReplacements(indexItemReplacements) {
-    let indexListMarkdownNode = null;
-
-    const indexItemReplacementsLength = indexItemReplacements.length;
-
-    if (indexItemReplacementsLength > 0) {
-      const ruleName = INDEX_LIST_RULE_NAME,
-            childNodes = indexItemReplacements.map((indexItemReplacement) => {
-              const indexItemReplacementNode = indexItemReplacement.getIndexItemMarkdownNode(),
-                    childNode = indexItemReplacementNode;  ///
-
-              return childNode;
-            }),
-            opacity = null;
-
-      indexListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexListMarkdownNode, ruleName, childNodes, opacity);
-    }
+    const ruleName = INDEX_LIST_RULE_NAME,
+          childNodes = indexItemReplacements.map((indexItemReplacement) => {
+            const indexItemReplacementNode = indexItemReplacement.getIndexItemMarkdownNode(),
+                  childNode = indexItemReplacementNode;  ///
+
+            return childNode;
+          }),
+          opacity = null,
+          indexListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexListMarkdownNode, ruleName, childNodes, opacity);
 
     return indexListMarkdownNode;
   }

package/src/node/markdown/line.js

@@ -21,8 +21,9 @@ export default class LineMarkdownNode extends MarkdownNode {
     const childNodesHTML = this.childNodesAsHTML(indent, context),
           startingTag = this.startingTag(context),
           closingTag = this.closingTag(context),
-          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
-`;
+          html = (indent !== null) ?
+                  `${indent}${startingTag}${childNodesHTML}${closingTag}
+`:                  `${startingTag}${childNodesHTML}${closingTag}`;
 
     return html;
   }

package/src/nodeMap.js

@@ -27,6 +27,7 @@ import InlineTextMarkdownNode from "./node/markdown/inlineText";
 import StrongTextMarkdownNode from "./node/markdown/strongText";
 import SubDivisionMarkdownNode from "./node/markdown/subDivision";
 import OrderedListMarkdownNode from "./node/markdown/orderedList";
+import IndexHeadingMarkdownNode from "./node/markdown/indexHeading";
 import BlockListingMarkdownNode from "./node/markdown/blockListing";
 import TableHeadRowMarkdownNode from "./node/markdown/tableHeadRow";
 import TableBodyRowMarkdownNode from "./node/markdown/tableBodyRow";
@@ -87,11 +88,12 @@ import { LINE_RULE_NAME,
          STRONG_TEXT_RULE_NAME,
          SUB_DIVISION_RULE_NAME,
          ORDERED_LIST_RULE_NAME,
-         FOOTNOTE_LINK_RULE_NAME,
+         INDEX_HEADING_RULE_NAME,
          BLOCK_LISTING_RULE_NAME,
          CONTENTS_LINK_RULE_NAME,
          CONTENTS_ITEM_RULE_NAME,
          CONTENTS_LIST_RULE_NAME,
+         FOOTNOTE_LINK_RULE_NAME,
          TABLE_HEAD_ROW_RULE_NAME,
          TABLE_BODY_ROW_RULE_NAME,
          INLINE_LISTING_RULE_NAME,
@@ -148,6 +150,7 @@ const nodeMap = {
   [STRONG_TEXT_RULE_NAME]: StrongTextMarkdownNode,
   [SUB_DIVISION_RULE_NAME]: SubDivisionMarkdownNode,
   [ORDERED_LIST_RULE_NAME]: OrderedListMarkdownNode,
+  [INDEX_HEADING_RULE_NAME]: IndexHeadingMarkdownNode,
   [BLOCK_LISTING_RULE_NAME]: BlockListingMarkdownNode,
   [CONTENTS_LINK_RULE_NAME]: ContentsLinkMarkdownNode,
   [CONTENTS_ITEM_RULE_NAME]: ContentsItemMarkdownNode,

package/src/replacement/footnotesList.js

@@ -44,10 +44,11 @@ export default class FootnotesListReplacement extends Replacement {
       }
     });
 
-    const footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start);
+    const footnotesItemReplacementsLength = footnotesItemReplacements.length;
 
-    if (footnotesListMarkdownNode !== null) {
-      const node = footnotesListMarkdownNode, ///
+    if (footnotesItemReplacementsLength > 0) {
+      const footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start),
+            node = footnotesListMarkdownNode, ///
             tokens = [];
 
       footnotesItemReplacements.forEach((footnotesItemReplacement) => {

package/src/replacement/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import letters from "../letters";
+import IndexList from "../index/list";
+import IndexListReplacement from "../replacement/indexList";
+import IndexHeadingReplacement from "./indexHeading";
+
+import { replaceNodes, replaceTokens } from "../utilities/replacement";
+
+export default class IndexReplacement extends Replacement {
+  constructor(node, tokens, nodes) {
+    super(node, tokens);
+
+    this.nodes = nodes;
+  }
+
+  getNodes() {
+    return this.nodes;
+  }
+
+  replace(replacedNode, parentNode, context) {
+    let tokens;
+
+    tokens = this.getTokens();
+
+    const replacementNodes = this.nodes,  ///
+          replacementTokens = tokens; ///
+
+    ({ tokens } = context);
+
+    replaceNodes(replacementNodes, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
+  }
+
+  replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = indexDirectiveSubDivisionReplacement.getSubDivisionMarkdownNode(),
+          replacedNode = subDivisionMarkdownNode, ///
+          parentNode = divisionMarkdownNode;  ///
+
+    this.replace(replacedNode, parentNode, context)
+  }
+
+  static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+    let indexReplacement = null;
+
+    const indexList = IndexList.fromDivisionMarkdownNodes(divisionMarkdownNodes, context),
+          indexReplacements = [];
+
+    letters.forEach((letter) => {
+      const indexListReplacement = IndexListReplacement.fromIndexListAndLetter(indexList, letter, context);
+
+      if (indexListReplacement !== null) {
+        let indexReplacement;
+
+        const indexHeadingReplacement = IndexHeadingReplacement.fromLetter(letter, context);
+
+        indexReplacement = indexHeadingReplacement; ///
+
+        indexReplacements.push(indexReplacement);
+
+        indexReplacement = indexListReplacement;  ///
+
+        indexReplacements.push(indexReplacement);
+      }
+    });
+
+    const indexListReplacementsLength = indexReplacements.length;
+
+    if (indexListReplacementsLength > 0) {
+      const node = null,
+            nodes = [],
+            tokens = [];
+
+      indexReplacements.forEach((indexReplacement) => {
+        const node = indexReplacement.getNode();
+
+        indexReplacement.getTokens(tokens);
+
+        nodes.push(node);
+      });
+
+      indexReplacement = Replacement.fromNodeAndTokens(IndexReplacement, node, tokens, nodes);
+    }
+
+    return indexReplacement;
+  }
+}

package/src/replacement/indexHeading.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import { INDEX_HEADING_RULE_NAME } from "../ruleNames";
+
+export default class IndexHeadingReplacement extends Replacement {
+  static fromLetter(letter, context) {
+    const { nodeFromTokens, tokensFromContent } = context,  ///
+          startRuleName = INDEX_HEADING_RULE_NAME,
+          content = `${letter}`,
+          tokens = tokensFromContent(content),
+          node = nodeFromTokens(tokens, startRuleName),
+          indexHeadingReplacement = Replacement.fromNodeAndTokens(IndexHeadingReplacement, node, tokens);
+
+    return indexHeadingReplacement;
+  }
+}

package/src/replacement/indexItem.js

@@ -13,11 +13,12 @@ export default class IndexItemReplacement extends Replacement {
     return indexItemMarkdownNode;
   }
 
-  static fromEntryAndPageNumbers(entry, pageNumbers, context) {
+  static fromIndexItem(indexItem, context) {
     const { nodeFromTokens, tokensFromContent } = context,
-          entryContent = entry, ///
+          wordOrPhrase = indexItem.getWordOrPhrase(),
+          pageNumbers = indexItem.getPageNumbers(),
           pageNumbersContent = pageNumbers.join(COMMA),
-          content = `${entryContent} ${pageNumbersContent}`,
+          content = `${wordOrPhrase},${pageNumbersContent}`,
           startRuleName = INDEX_ITEM_RULE_NAME,
           tokens = tokensFromContent(content),
           node = nodeFromTokens(tokens, startRuleName),

package/src/replacement/indexList.js

@@ -1,36 +1,23 @@
 "use strict";
 
 import Replacement from "../replacement";
-
 import IndexItemReplacement from "../replacement/indexItem";
 import IndexListMarkdownNode from "../node/markdown/indexList";
 
-import { indexMapFromDivisionMarkdownNodes } from "../utilities/index";
-
 export default class IndexListReplacement extends Replacement {
-  replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
-    const subDivisionMarkdownNode = indexDirectiveSubDivisionReplacement.getSubDivisionMarkdownNode(),
-          replacedNode = subDivisionMarkdownNode, ///
-          parentNode = divisionMarkdownNode;  ///
-
-    super.replace(replacedNode, parentNode, context)
-  }
-
-  static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+  static fromIndexListAndLetter(indexList, letter, context) {
     let indexListReplacement = null;
 
-    const indexMap = indexMapFromDivisionMarkdownNodes(divisionMarkdownNodes, context),
-          entries = Object.keys(indexMap), ///
-          indexItemReplacements = entries.map((entry) => {
-            const pageNumbers = indexMap[entry],
-                  indexItemReplacement = IndexItemReplacement.fromEntryAndPageNumbers(entry, pageNumbers, context);
+    const indexItemReplacements = indexList.reduceIndexItemByLetter(letter, (indexItem) => {
+            const indexItemReplacement = IndexItemReplacement.fromIndexItem(indexItem, context);
 
             return indexItemReplacement;
           }),
-          indexListMarkdownNode = IndexListMarkdownNode.fromIndexItemReplacements(indexItemReplacements);
+          indexItemReplacementsLength = indexItemReplacements.length;
 
-    if (indexListMarkdownNode !== null) {
-      const node = indexListMarkdownNode, ///
+    if (indexItemReplacementsLength > 0) {
+      const indexListMarkdownNode = IndexListMarkdownNode.fromIndexItemReplacements(indexItemReplacements),
+            node = indexListMarkdownNode, ///
             tokens = [];
 
       indexItemReplacements.forEach((indexItemReplacement) => {

package/src/replacement.js

@@ -6,7 +6,6 @@ import { appendNode,
          prependNode,
          removeNode,
          replaceNode,
-         replaceNodes,
          addNodesAfter,
          appendTokens,
          prependTokens,
@@ -110,17 +109,6 @@ export default class Replacement {
     replaceTokens(replacementTokens, replacedNode, tokens);
   }
 
-  replaceEx(replacedNode, parentNode, context) {
-    const { tokens } = context,
-          replacementChildNodes = this.getChildNodes(), ///
-          replacementTokens = this.tokens,  ///
-          replacementNodes = replacementChildNodes; ///
-
-    replaceNodes(replacementNodes, replacedNode, parentNode);
-
-    replaceTokens(replacementTokens, replacedNode, tokens);
-  }
-
   removeFrom(removedNode, parentNode, context) {
     const { tokens } = context;
 

package/src/ruleNames.js

@@ -27,6 +27,7 @@ export const INLINE_TEXT_RULE_NAME = "inlineText";
 export const STRONG_TEXT_RULE_NAME = "strongText";
 export const SUB_DIVISION_RULE_NAME = "subDivision";
 export const ORDERED_LIST_RULE_NAME = "orderedList";
+export const INDEX_HEADING_RULE_NAME = "indexHeading";
 export const BLOCK_LISTING_RULE_NAME = "blockListing";
 export const CONTENTS_LINK_RULE_NAME = "contentsLink";
 export const CONTENTS_ITEM_RULE_NAME = "contentsItem";
@@ -88,6 +89,7 @@ const ruleNames = {
   STRONG_TEXT_RULE_NAME,
   SUB_DIVISION_RULE_NAME,
   ORDERED_LIST_RULE_NAME,
+  INDEX_HEADING_RULE_NAME,
   BLOCK_LISTING_RULE_NAME,
   CONTENTS_LINK_RULE_NAME,
   CONTENTS_ITEM_RULE_NAME,