highmark-markdown 0.0.426 → 0.0.430

package/src/utilities/index.js

@@ -0,0 +1,335 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import PhraseMatcher from "../index/phraseMatcher";
+
+import { EMPTY_STRING, SINGLE_SPACE } from "../constants";
+import { forEach, mapValues, mapKeys } from "../utilities/object";
+
+const { compress } = arrayUtilities;
+
+export function indexMapFromDivisionMarkdownNodes(divisionMarkdownNodes, context) {
+  const indexMap = createIndexMap(divisionMarkdownNodes, context);
+
+  removeIgnoredWords(indexMap, context);
+
+  adjustProperNouns(indexMap, context);
+
+  adjustAcronyms(indexMap, context);
+
+  adjustMixedPlurals(indexMap, context);
+
+  adjustPluralPlurals(indexMap, context);
+
+  adjustSingularPlurals(indexMap, context);
+
+  compressPageNumbers(indexMap);
+
+  return indexMap;
+}
+
+function createIndexMap(divisionMarkdownNodes, context) {
+  const indexMap = {};
+
+  const { indexOptions } = context,
+        { phrases } = indexOptions,
+        phraseMatchers = phrases.map((phrase) => {
+          const phraseMatcher = PhraseMatcher.fromPhrase(phrase);
+
+          return phraseMatcher;
+        });
+
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    const pageNumber = divisionMarkdownNode.getPageNumber();
+
+    if (pageNumber !== null) {
+      const plainText = divisionMarkdownNode.asPlainText(context),
+            entries = entriesFromPlainTextAndPhraseMatchers(plainText, phraseMatchers);
+
+      entries.forEach((entry) => {
+        let pageNumbers = indexMap[entry] || null;
+
+        if (pageNumbers === null) {
+          pageNumbers = [];
+
+          indexMap[entry] = pageNumbers;
+        }
+
+        pageNumbers.push(pageNumber);
+      });
+    }
+  });
+
+  return indexMap;
+}
+
+function entriesFromPlainTextAndPhraseMatchers(plainText, phraseMatchers) {
+  let entries;
+
+  plainText = preparePlainText(plainText);  ///
+
+  phraseMatchers.forEach((phraseMatcher) => {
+    plainText = phraseMatcher.replace(plainText);
+  });
+
+  entries = plainText.split(SINGLE_SPACE);
+
+  entries = entries.map((entry) => {
+    entry = PhraseMatcher.revert(entry);  ///
+
+    return entry;
+  });
+
+  return entries;
+}
+
+function compressPageNumbers(indexMap) {
+  mapValues(indexMap, (entry, pageNumbers) => {
+    compress(pageNumbers, (pageNumberA, pageNumberB) => {
+      if (pageNumberA === pageNumberB) {
+        return true;
+      }
+    });
+
+    pageNumbers.sort();
+
+    return pageNumbers;
+  });
+}
+
+function removeIgnoredWords(indexMap, context) {
+  const { indexOptions } = context,
+        { ignoredWords } = indexOptions;
+
+  ignoredWords.forEach((ignoredWord) => {
+    delete indexMap[ignoredWord];
+  });
+}
+
+function adjustProperNouns(indexMap, context) {
+  const { indexOptions } = context,
+        { properNouns } = indexOptions;
+
+  const lowerCaseProperNouns = properNouns.map((properNoun) => {
+    const lowerCaseProperNoun = properNoun.toLowerCase();
+
+    return lowerCaseProperNoun;
+  });
+
+  mapKeys(indexMap, (entry) => {
+    const index = lowerCaseProperNouns.findIndex((lowerCaseProperNmae) => {
+      if (lowerCaseProperNmae === entry) {
+        return true;
+      }
+    });
+
+    if (index > -1) {
+      const properNoun = properNouns[index];
+
+      entry = properNoun;  ///
+    }
+
+    return entry;
+  });
+}
+
+function preparePlainText(plainText) {
+  plainText = plainText.toLowerCase();  ///
+
+  plainText = plainText.replace(/[^a-z ]/g, SINGLE_SPACE);
+
+  plainText = plainText.replace(/\s+/g, SINGLE_SPACE);
+
+  plainText = plainText.replace(/^\s+|\s+$/g, EMPTY_STRING);
+
+  return plainText;
+}
+
+function adjustAcronyms(indexMap, context) {
+  const { indexOptions } = context,
+        { acronyms } = indexOptions;
+
+  const lowerCaseAcronyms = acronyms.map((acronym) => {
+    const lowerCaseAcronym = acronym.toLowerCase();
+
+    return lowerCaseAcronym;
+  });
+
+  mapKeys(indexMap, (entry) => {
+    const index = lowerCaseAcronyms.findIndex((lowerCaseProperNmae) => {
+      if (lowerCaseProperNmae === entry) {
+        return true;
+      }
+    });
+
+    if (index > -1) {
+      const acronym = acronyms[index];
+
+      entry = acronym;  ///
+    }
+
+    return entry;
+  });
+}
+
+function adjustMixedPlurals(indexMap, context) {
+  const { indexOptions } = context,
+        { plurals } = indexOptions,
+        mixedPlurals = mixedPluralsFromPlurals(plurals);
+
+  forEach(indexMap, (entry, pageNumbers) => {
+    const entryPlural = isPlural(entry);
+
+    if (entryPlural) {
+      const singularEntry = entry.replace(/s$/, EMPTY_STRING),
+            mixedEntry = `${singularEntry}(s)`,
+            mixedPluralsIncludesMixedEntry = mixedPlurals.includes(mixedEntry),
+            entryMixedPlural = mixedPluralsIncludesMixedEntry; ///
+
+      if (entryMixedPlural) {
+        const pluralPageNumbers = pageNumbers,  ///
+              singularPageNumbers = indexMap[singularEntry] || [];
+
+        pageNumbers = [ ///
+          ...pluralPageNumbers,
+          ...singularPageNumbers
+        ];
+
+        delete indexMap[entry];
+        delete indexMap[singularEntry];
+
+        indexMap[mixedEntry] = pageNumbers;
+      }
+    }
+  });
+}
+
+function adjustPluralPlurals(indexMap, context) {
+  const { indexOptions } = context,
+        { plurals } = indexOptions,
+        pluralPlurals = pluralPluralsFromPlurals(plurals);
+
+  forEach(indexMap, (entry, pageNumbers) => {
+    const entryPlural = isPlural(entry);
+
+    if (entryPlural) {
+      const singularEntry = entry.replace(/s$/, EMPTY_STRING),
+            pluralPluralsIncludesEntry = pluralPlurals.includes(entry),
+            entryPluralPlural = pluralPluralsIncludesEntry; ///
+
+      if (entryPluralPlural) {
+        const pluralPageNumbers = pageNumbers,  ///
+              singularPageNumbers = indexMap[singularEntry] || [];
+
+        pageNumbers = [ ///
+          ...pluralPageNumbers,
+          ...singularPageNumbers
+        ];
+
+        delete indexMap[singularEntry];
+
+        indexMap[entry] = pageNumbers;
+      }
+    }
+  });
+}
+
+function adjustSingularPlurals(indexMap, context) {
+  const { indexOptions } = context,
+        { plurals } = indexOptions,
+        singularPlurals = singularPluralsFromPlurals(plurals);
+
+  forEach(indexMap, (entry, pageNumbers) => {
+    const entryPlural = isPlural(entry);
+
+    if (entryPlural) {
+      const singularEntry = entry.replace(/s$/, EMPTY_STRING),
+            singularPluralsIncludesSingularEntry = singularPlurals.includes(singularEntry),
+            entrySingularPlural = singularPluralsIncludesSingularEntry; ///
+
+      if (entrySingularPlural) {
+        const pluralPageNumbers = pageNumbers,  ///
+              singularPageNumbers = indexMap[singularEntry] || [];
+
+        pageNumbers = [ ///
+          ...pluralPageNumbers,
+          ...singularPageNumbers
+        ];
+
+        delete indexMap[entry];
+
+        indexMap[singularEntry] = pageNumbers;
+      }
+    }
+  });
+}
+
+function singularPluralsFromPlurals(plurals) {
+  const singularPlurals = plurals.reduce((singularPlurals, plural) => {
+    const pluralSingular = isSingular(plural);
+
+    if (pluralSingular) {
+      const singularPlural = plural;  ///
+
+      singularPlurals.push(singularPlural);
+    }
+
+    return singularPlurals;
+  }, []);
+
+  return singularPlurals;
+}
+
+function pluralPluralsFromPlurals(plurals) {
+  const pluralPlurals = plurals.reduce((pluralPlurals, plural) => {
+    const pluralPlural = isPlural(plural);
+
+    if (pluralPlural) {
+      const pluralPlural = plural;  ///
+
+      pluralPlurals.push(pluralPlural);
+    }
+
+    return pluralPlurals;
+  }, []);
+
+  return pluralPlurals;
+}
+
+function mixedPluralsFromPlurals(plurals) {
+  const mixedPlurals = plurals.reduce((mixedPlurals, plural) => {
+    const pluralMixed = isMixed(plural);
+
+    if (pluralMixed) {
+      const mixedPlural = plural;  ///
+
+      mixedPlurals.push(mixedPlural);
+    }
+
+    return mixedPlurals;
+  }, []);
+
+  return mixedPlurals;
+}
+
+function isSingular(text) {
+  const matches = /[^s)]$/.test(text),
+        pluralSingular = matches; ///
+
+  return pluralSingular;
+}
+
+function isPlural(text) {
+  const matches = /s$/.test(text),
+        plural = matches; ///
+
+  return plural;
+}
+
+function isMixed(text) {
+  const matches = /\(s\)$/.test(text),
+        plural = matches; ///
+
+  return plural;
+}

package/src/utilities/object.js

@@ -0,0 +1,50 @@
+"use strict";
+
+export function forEach(object, callback) {
+  const keys = Object.keys(object);
+
+  keys.forEach((key) => {
+    const value = object[key];
+
+    callback(key, value);
+  });
+}
+
+export function filter(object, callback) {
+  const keys = Object.keys(object);
+
+  keys.forEach((key) => {
+    const value = object[key],
+          result = callback(key, value);
+
+    if (!result) {
+      delete object[key];
+    }
+  });
+}
+
+export function mapKeys(object, callback) {
+  const keys = Object.keys(object);
+
+  keys.forEach((key) => {
+    const value = object[key];
+
+    delete object[key];
+
+    key = callback(key, value); ///
+
+    object[key] = value;
+  });
+}
+
+export function mapValues(object, callback) {
+  const keys = Object.keys(object);
+
+  keys.forEach((key) => {
+    let value = object[key];
+
+    value = callback(key, value); ///
+
+    object[key] = value;
+  });
+}

package/src/utilities/processing.js

@@ -15,6 +15,8 @@ export function postprocess(divisionMarkdownNode, context) {
 
   createContents(divisionMarkdownNodes, context);
 
+  createIndex(divisionMarkdownNodes, context);
+
   return divisionMarkdownNodes;
 }
 
@@ -36,6 +38,16 @@ function paginate(divisionMarkdownNodes, context) {
   return divisionMarkdownNodes;
 }
 
+function createIndex(divisionMarkdownNodes, context) {
+  divisionMarkdownNodes.some((divisionMarkdownNode) => {
+    const indexCreated = divisionMarkdownNode.createIndex(divisionMarkdownNodes, context);
+
+    if (indexCreated) {
+      return true;
+    }
+  });
+}
+
 function createContents(divisionMarkdownNodes, context) {
   divisionMarkdownNodes.some((divisionMarkdownNode) => {
     const contentsCreated = divisionMarkdownNode.createContents(divisionMarkdownNodes, context);

package/src/utilities/query.js

@@ -6,16 +6,17 @@ import { arrayUtilities } from "necessary";
 const { first, push } = arrayUtilities;
 
 const footnoteMarkdownNodeQuery = Query.fromExpression("/subDivision/footnote"),
+      indexDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/indexDirective"),
       ignoreDirectiveMarkdownNodeQuery = Query.fromExpression("/division/subDivision/directives/ignoreDirective"),
       contentsDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/contentsDirective"),
       footnotesDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/footnotesDirective"),
       pageNumberDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/pageNumber"),  ///
-      linkMarkdownNodesQuery = Query.fromExpression("//link"),
       headingMarkdownNodesQuery = Query.fromExpression("/division/subDivision/primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"),
       subDivisionMarkdownNodesQuery = Query.fromExpression("/division/subDivision"),
+      footnoteLinkMarkdownNodesQuery = Query.fromExpression("//footnoteLink"),
       embedDirectiveMarkdownNodesQuery = Query.fromExpression("/subDivision/directives/embedDirective"),
       includeDirectiveMarkdownNodesQuery = Query.fromExpression("/subDivision/directives/includeDirective"),
-      linkFootnoteOrFootnotesDirectiveMarkdownNodesQuery = Query.fromExpression("//link|footnote|footnotesDirective");
+      footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodesQuery = Query.fromExpression("//footnote|footnoteLink|footnotesDirective");
 
 export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
@@ -52,6 +53,12 @@ export function footnoteMarkdownNodeFromNode(node) {
   return footnoteMarkdownNode;
 }
 
+export function indexDirectiveMarkdownNodeFromNode(node) {
+  const indexDirectiveMarkdownNode = nodeFromNodeAndQuery(node, indexDirectiveMarkdownNodeQuery);
+
+  return indexDirectiveMarkdownNode;
+}
+
 export function ignoreDirectiveMarkdownNodeFromNode(node) {
   const ignoreDirectiveMarkdownNode = nodeFromNodeAndQuery(node, ignoreDirectiveMarkdownNodeQuery);
 
@@ -76,12 +83,6 @@ export function pageNumberDirectiveMarkdownNodeFromNode(node) {
   return pageNumberDirectiveMarkdownNode;
 }
 
-export function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
-  nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);
-
-  return linkMarkdownNodes;
-}
-
 export function headingMarkdownNodesFromNode(node, headingMarkdownNodes = []) {
   nodesFromNodeAndQuery(node, headingMarkdownNodesQuery, headingMarkdownNodes);
 
@@ -94,6 +95,12 @@ export function subDivisionMarkdownNodesFromNode(node, subDivisionMarkdownNodes
   return subDivisionMarkdownNodes;
 }
 
+export function footnoteLinkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, footnoteLinkMarkdownNodesQuery, linkMarkdownNodes);
+
+  return linkMarkdownNodes;
+}
+
 export function embedDirectiveMarkdownNodesFromNode(node, embedDirectiveMarkdownNodes = []) {
   nodesFromNodeAndQuery(node, embedDirectiveMarkdownNodesQuery, embedDirectiveMarkdownNodes);
 
@@ -106,24 +113,25 @@ export function includeDirectiveMarkdownNodesFromNode(node, includeDirectiveMark
   return includeDirectiveMarkdownNodes;
 }
 
-export function linkFootnoteOrFootnotesDirectiveMarkdownNodesFromNode(node, linkFootnoteOrFootnotesDirectiveMarkdownNodes = []) {
-  nodesFromNodeAndQuery(node, linkFootnoteOrFootnotesDirectiveMarkdownNodesQuery, linkFootnoteOrFootnotesDirectiveMarkdownNodes);
+export function footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodesFromNode(node, footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodesQuery, footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodes);
 
-  return linkFootnoteOrFootnotesDirectiveMarkdownNodes;
+  return footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodes;
 }
 
 export default {
   footnoteMarkdownNodeFromNode,
+  indexDirectiveMarkdownNodeFromNode,
   ignoreDirectiveMarkdownNodeFromNode,
   contentsDirectiveMarkdownNodeFromNode,
   footnotesDirectiveMarkdownNodeFromNode,
   pageNumberDirectiveMarkdownNodeFromNode,
-  linkMarkdownNodesFromNode,
   headingMarkdownNodesFromNode,
   subDivisionMarkdownNodesFromNode,
+  footnoteLinkMarkdownNodesFromNode,
   embedDirectiveMarkdownNodesFromNode,
   includeDirectiveMarkdownNodesFromNode,
-  linkFootnoteOrFootnotesDirectiveMarkdownNodesFromNode
+  footnoteFootnoteLinkOrFootnotesDirectiveMarkdownNodesFromNode
 };
 
 function nodeFromNodeAndQuery(node, query) {

package/src/utilities/replacement.js

@@ -6,6 +6,12 @@ export function appendNode(appendedNode, parentNode) {
   parentNode.appendChildNode(appendedChildNode);
 }
 
+export function prependNode(prependedNode, parentNode) {
+  const prependedChildNode = prependedNode;  ///
+
+  parentNode.prependChildNode(prependedChildNode);
+}
+
 export function removeNode(removedNode, parentNode) {
   const removedChildNode = removedNode; ///
 
@@ -48,6 +54,15 @@ export function appendTokens(appendedTokens, parentNode, tokens) {
   tokens.splice(start, deleteCount, ...appendedTokens);
 }
 
+export function prependTokens(prependedTokens, parentNode, tokens) {
+  const node = parentNode, ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...prependedTokens);
+}
+
 export function removeTokens(removedNode, tokens) {
   const node = removedNode,  ///
         firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
@@ -85,3 +100,69 @@ export function addTokensAfter(existingNode, addedTokens, tokens) {
 
   tokens.splice(start, deleteCount, ...addedTokens);
 }
+
+export function overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset = 0) {
+  const node = clonedNode;  ///
+
+  overwriteNodeTokens(node, clonedTokens, tokens, offset);
+}
+
+export function clonedTokensFromNodeAndTokens(node, tokens) {
+  const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex,  ///
+        end = lastSignificantTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);  ///
+
+  const clonedTokens = tokens.map((token) => {  ///
+    const clonedToken = token.clone();
+
+    return clonedToken;
+  });
+
+  return clonedTokens;
+}
+
+function overwriteNodeTokens(node, clonedTokens, tokens, offset) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset);
+  }
+}
+
+function overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset) {
+  let index,
+      significantToken;
+
+  significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken !== null) {
+    index = tokens.indexOf(significantToken);
+
+    index -= offset;
+
+    const clonedToken = clonedTokens[index];
+
+    significantToken = clonedToken;  ///
+
+    terminalNode.setSignificantToken(significantToken);
+  }
+}
+
+function overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset) {
+  const childNodes = nonTerminalNode.getChildNodes();
+
+  childNodes.forEach((childNode) => {
+    const clonedNode = childNode; ///
+
+    overwriteNodeTokens(clonedNode, clonedTokens, tokens, offset);
+  });
+}