highmark-markdown 0.0.204 → 0.0.209

package/src/style/selector.js

@@ -0,0 +1,126 @@
+"use strict";
+
+import ruleNames from "../ruleNames";
+import elementMap from "../elementMap";
+
+import { nodeQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+import { remainingContentFromNodeTokensAndOffset } from "../utilities/content";
+
+const { DIVISION_RULE_NAME,
+        STRONG_TEXT_RULE_NAME,
+        ORDERED_LIST_RULE_NAME,
+        UNORDERED_LIST_RULE_NAME,
+        ORDERED_LIST_ITEM_RULE_NAME,
+        UNORDERED_LIST_ITEM_RULE_NAME,
+        STRONGLY_EMPHASISED_TEXT_RULE_NAME } = ruleNames,
+      { tagName: strongTextTagName } = elementMap[STRONG_TEXT_RULE_NAME],
+      { tagName: orderedListTagName } = elementMap[ORDERED_LIST_RULE_NAME],
+      { tagName: unorderedListTagName } = elementMap[UNORDERED_LIST_RULE_NAME];
+
+const ruleNameValues = Object.values(ruleNames),
+      ruleNameTerminalNodeQuery = nodeQuery("/selector/@rule-name");
+
+export default class Selector {
+  constructor(content, whitespace) {
+    this.content = content;
+    this.whitespace = whitespace;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  hasWhitespace() {
+    return this.whitespace;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    let selector = null;
+
+    const content = contentFromNodeAndTokens(node, tokens);
+
+    if (content !== null) {
+      const whitespace = whitespaceFromNode(node);
+
+      selector = new Selector(content, whitespace);
+    }
+
+    return selector;
+  }
+}
+
+function whitespaceFromNode(node) {
+  const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node),
+        whitespace = (ruleNameTerminalNode !== null);
+
+  return whitespace;
+}
+
+function contentFromNodeAndTokens(node, tokens) {
+  let content;
+
+  const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node);
+
+  if (ruleNameTerminalNode !== null) {
+    content = EMPTY_STRING;
+
+    const ruleNameTerminalNodeContent = ruleNameTerminalNode.getContent(),
+          ruleName = ruleNameTerminalNodeContent, ///
+          ruleNameValuesIncludesRuleName = ruleNameValues.includes(ruleName);
+
+    if (ruleNameValuesIncludesRuleName) {
+      const { tagName, className } = elementMap[ruleName];
+
+      if (tagName !== null) {
+        content = `${content}${tagName}`;
+      }
+
+      switch (ruleName) {
+        case DIVISION_RULE_NAME: {
+          content = null;
+
+          break;
+        }
+
+        case ORDERED_LIST_ITEM_RULE_NAME: {
+          content = `${orderedListTagName} > ${content}`;
+
+          break;
+        }
+
+        case UNORDERED_LIST_ITEM_RULE_NAME: {
+          content = `${unorderedListTagName} > ${content}`;
+
+          break;
+        }
+
+        case STRONGLY_EMPHASISED_TEXT_RULE_NAME: {
+          content = `${content} > ${strongTextTagName}`;
+
+          break;
+        }
+      }
+
+      if (className !== null) {
+        content = `${content}.${className}`;
+      }
+
+      if (ruleName === DIVISION_RULE_NAME) {
+        content = null;
+      } else {
+        const offset = 1,
+              remainingContent = remainingContentFromNodeTokensAndOffset(node, tokens, offset);
+
+        content = `${content}${remainingContent}`;
+      }
+    }
+  } else {
+    const offset = 0,
+          remainingContent = remainingContentFromNodeTokensAndOffset(node, tokens, offset);
+
+    content = remainingContent; ///
+  }
+
+  return content;
+}

package/src/style/selectors.js

@@ -0,0 +1,121 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Selector from "./selector";
+
+import { nodesQuery } from "../utilities/query";
+
+const selectorNonTerminalNodesQuery = nodesQuery("/selectors/selector");
+
+const { first } = arrayUtilities;
+
+export default class Selectors {
+  constructor(content, whitespace) {
+    this.content = content;
+    this.whitespace = whitespace;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  hasWhitespace() {
+    return this.whitespace;
+  }
+
+  combine(selectors, outermost = false) {
+    if (selectors !== null) {
+      const outerSelectors = this,  ///
+            innerSelectors = selectors, ///
+            outerSelectorsContent = outerSelectors.getContent(),
+            innerSelectorsContent = innerSelectors.getContent(),
+            outerSelectorsWhitespace = outerSelectors.hasWhitespace(),
+            innerSelectorsWhitespace = innerSelectors.hasWhitespace();
+
+      selectors = null;
+
+      if (outermost && !innerSelectorsWhitespace) {
+        ///
+      } else {
+        if ((outerSelectorsContent !== null) && (innerSelectorsContent !== null)) {
+          const content = `${outerSelectorsContent}${innerSelectorsContent}`,
+                whitespace = outerSelectorsWhitespace;
+
+          selectors = Selectors.fromContentAndWhitespace(content, whitespace);
+        }
+      }
+    }
+
+    return selectors;
+  }
+
+  asCSS() {
+    const css = this.content; ///
+
+    return css;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const selectors = selectorsFromNodeAndTokens(node, tokens);
+
+    return selectors;
+  }
+
+  static fromSelectorsString(selectorsString) {
+    const content = selectorsString,
+          whitespace = false,
+          selectors = new Selectors(content, whitespace);
+
+    return selectors;
+  }
+
+  static fromContentAndWhitespace(content, whitespace) {
+    const selectors = new Selectors(content, whitespace);
+
+    return selectors;
+  }
+}
+
+function selectorsFromNodeAndTokens(node, tokens) {
+  let selectors = null;
+
+  const selectorNonTerminalNodes = selectorNonTerminalNodesQuery(node),
+        selectorArray = selectorNonTerminalNodes.reduce((selectorArray, selectorNonTerminalNode) => {
+          const node = selectorNonTerminalNode,  ///
+                selector = Selector.fromNodeAndTokens(node, tokens);
+
+          if (selector !== null) {
+            selectorArray.push(selector);
+          }
+
+          return selectorArray;
+        }, []),
+        selectorsArrayLength = selectorArray.length;
+
+  if (selectorsArrayLength > 0) {
+    const firstSelector = first(selectorArray),
+          selector = firstSelector, ///
+          content = selectorArray.reduce((content, selector) => {
+            const selectorContent = selector.getContent(),
+                  selectorWhitespace = selector.hasWhitespace();
+
+            if (content === null) {
+              content = selectorWhitespace ?
+                         ` ${selectorContent}` :
+                           `${selectorContent}`;
+            } else {
+              content = selectorWhitespace ?
+                         `${content} ${selectorContent}` :
+                           `${content}${selectorContent}`;
+            }
+
+            return content;
+          }, null),
+          whitespace = selector.hasWhitespace();
+
+    selectors = new Selectors(content, whitespace);
+  }
+
+  return selectors;
+}

package/src/style/selectorsList.js

@@ -0,0 +1,95 @@
+"use strict";
+
+import Selectors from "./selectors";
+
+import { EMPTY_STRING } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const selectorsNonTerminalNodesQuery = nodesQuery("/selectorsList/selectors"),
+      selectorsListNonTerminalNodeQuery = nodeQuery("/ruleSet/selectorsList");
+
+export default class SelectorsList {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  reduceSelectors(callback, initialValue) { return this.array.reduce(callback, initialValue); }
+
+  forEachSelectors(callback) { this.array.forEach(callback); }
+
+  combine(selectorsList, outermost = false) {
+    const outerSelectorsList = SelectorsList.fromArray(this.array), ///
+          innerSelectorsList = selectorsList, ///
+          array = outerSelectorsList.reduceSelectors((array, outerSelectors) => {
+                  innerSelectorsList.forEachSelectors((innerSelectors) => {
+                    const selectors = outerSelectors.combine(innerSelectors, outermost);
+
+                    if (selectors !== null) {
+                      array.push(selectors);
+                    }
+                  });
+
+            return array;
+          }, []);
+
+    selectorsList = SelectorsList.fromArray(array);
+
+    return selectorsList;
+  }
+
+  asCSS() {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength();
+
+    if (length > 0) {
+      css = this.array.reduce((css, selectors) => {
+        const selectorsCSS = selectors.asCSS();
+
+        css = (css === null) ?
+                selectorsCSS : ///
+                  `${css},
+${selectorsCSS}`;
+
+        return css;
+      }, null);
+    }
+
+    return css;
+  }
+
+  static fromArray(array) {
+    const selectorsList = new SelectorsList(array);
+
+    return selectorsList;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const selectorsListNonTerminalNode = selectorsListNonTerminalNodeQuery(node);
+
+    node = selectorsListNonTerminalNode;  ///
+
+    const selectorsNonTerminalNodes = selectorsNonTerminalNodesQuery(node),
+          array = selectorsNonTerminalNodes.map((selectorsNonTerminalNode) => {
+            const node = selectorsNonTerminalNode,  ///
+                  selectors = Selectors.fromNodeAndTokens(node, tokens);
+
+            return selectors;
+          }),
+          selectorsList = new SelectorsList(array);
+
+    return selectorsList;
+  }
+
+  static fromSelectorsString(selectorsString) {
+    const selectors = Selectors.fromSelectorsString(selectorsString),
+          array = [
+            selectors
+          ],
+          selectorsList = new SelectorsList(array);
+
+    return selectorsList;
+  }
+}

package/src/styleElement/markdown/default.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import defaultMarkdownStyle from "../../defaultMarkdownStyle";
+import MarkdownStyleElement from "../../styleElement/markdown";
+
+export default class DefaultMarkdownStyleElement extends MarkdownStyleElement {
+  update(defaultMarkdownStyle) {
+    const markdownStyle = defaultMarkdownStyle; ///
+
+    super.update(markdownStyle)
+  }
+
+  reset() {
+    this.update(defaultMarkdownStyle)
+  }
+
+  static fromSelectorsString(Class, selectorsString) {
+    if (selectorsString === undefined) {
+      selectorsString = Class; ///
+
+      Class = DefaultMarkdownStyleElement;  ///
+    }
+
+    const defaultMarkdownStyleElement = MarkdownStyleElement.fromSelectorsString(Class, selectorsString);
+
+    defaultMarkdownStyleElement.reset();
+  }
+}

package/src/styleElement/markdown.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import StyleElement from "../styleElement";
+import SelectorsList from "../style/selectorsList";
+
+import { EMPTY_STRING } from "../constants";
+import { createDOMElement } from "../styleElement";
+import { cssFromMarkdownStyleAndSelectorsList } from "../utilities/css";
+
+export default class MarkdownStyleElement extends StyleElement {
+  constructor(domElement, selectorsList) {
+    super(domElement);
+
+    this.selectorsList = selectorsList;
+  }
+
+  getSelectorsList() {
+    return this.selectorsList;
+  }
+
+  update(markdownStyle = null) {
+    const css = cssFromMarkdownStyleAndSelectorsList(markdownStyle, this.selectorsList);
+
+    this.setCSS(css);
+
+    return css;
+  }
+
+  reset() {
+    const markdownStyle = EMPTY_STRING;
+
+    this.update(markdownStyle)
+  }
+
+  static fromSelectorsString(Class, selectorString) {
+    if (selectorString === undefined) {
+      selectorString = Class; ///
+
+      Class = MarkdownStyleElement; ///
+    }
+
+    const domElement = createDOMElement(),
+          selectorsList = SelectorsList.fromSelectorsString(selectorString),
+          markdownStyleElement = new Class(domElement, selectorsList);
+
+    return markdownStyleElement;
+  }
+}

package/src/styleElement.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import { HEAD, STYLE } from "./constants";
+
+export default class StyleElement {
+  constructor(domElement) {
+    this.domElement = domElement;
+  }
+
+  getDOMElement() {
+    return this.domElement;
+  }
+
+  setDOMElement(domElement) {
+    this.domElement = domElement;
+  }
+
+  getInnerHTML() {  return this.domElement.innerHTML; }
+
+  setInnerHTML(innerHTML) { this.domElement.innerHTML = innerHTML; }
+
+  setCSS(css) {
+    const innerHTML = `
+${css}
+`;
+
+    this.setInnerHTML(innerHTML);
+  }
+
+  remove() { this.domElement.remove(); }
+
+  static fromNothing() {
+    const domElement = createDOMElement(),
+          styleElement = new StyleElement(domElement);
+
+    return styleElement;
+  }
+}
+
+export function createDOMElement() {
+  const headDOMElement = document.querySelector(HEAD),
+        styleDOMElement = document.createElement(STYLE);
+
+  headDOMElement.appendChild(styleDOMElement);
+
+  const domElement = styleDOMElement; ///
+
+  return domElement;
+}

package/src/utilities/content.js

@@ -67,6 +67,33 @@ export function contentFromMarkdownNodes(markdownNodes, context, leftTrimmed, ri
   return content;
 }
 
+export function contentFromNodeAndTokens(node, tokens, offset = 0) {
+  const firstSignificantToken = node.getFirstSignificantToken(),
+        lastSignificantToken = node.getLastSignificantToken(),
+        firstToken = firstSignificantToken, ///
+        lastToken = lastSignificantToken, ///
+        firstTokenIndex = tokens.indexOf(firstToken) + offset,  ///
+        lastTokenIndex = tokens.indexOf(lastToken);
+
+  let content = EMPTY_STRING;
+
+  for (let index = firstTokenIndex; index <= lastTokenIndex; index++) {
+    const token = tokens[index],
+          tokenContent = token.getContent();
+
+    content += tokenContent;
+  }
+
+  return content;
+}
+
+export function remainingContentFromNodeTokensAndOffset(node, tokens, offset) {
+  const content = contentFromNodeAndTokens(node, tokens, offset),
+        remainingContent = content; ///
+
+  return remainingContent;
+}
+
 function tokenContentFromToken(token) {
   let tokenContent = token.getContent();
 

package/src/utilities/css.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import Division from "../style/division";
+import SelectorsList from "../style/selectorsList";
+import MarkdownStyleLexer from "../markdownStyle/lexer";
+import MarkdownStyleParser from "../markdownStyle/parser";
+
+import { EMPTY_STRING } from "../constants";
+
+const markdownStyleLexer = MarkdownStyleLexer.fromNothing(),
+      markdownStyleParser = MarkdownStyleParser.fromNothing();
+
+export function cssFromMarkdownStyleAndSelectorsList(markdownStyle, selectorsList) {
+  let css = EMPTY_STRING;
+
+  const lexer = markdownStyleLexer, ///
+        parser =  markdownStyleParser,  ///
+        content = markdownStyle, ///
+        tokens = lexer.tokenise(content),
+        node = parser.parse(tokens);
+
+  if (node !== null) {
+    const division = Division.fromNodeTokensAndSelectorsList(node, tokens, selectorsList);
+
+    css = division.asCSS();
+  }
+
+  return css;
+}
+
+export function cssFromMarkdownStyleAndSelectorString(markdownStyle, selectorString) {
+  const selectorsList = SelectorsList.fromSelectorsString(selectorString),
+        css = cssFromMarkdownStyleAndSelectorsList(markdownStyle, selectorsList);
+
+  return css;
+}
+
+export default {
+  cssFromMarkdownStyleAndSelectorsList,
+  cssFromMarkdownStyleAndSelectorString
+};

package/src/utilities/entries.js

@@ -0,0 +1,23 @@
+"use strict";
+
+export function ruleNamesExpressionFromElementMap(elementMap) {
+  const ruleNames = Object.keys(elementMap);
+
+  ruleNames.reverse();
+
+  const ruleNamesExpression = ruleNames.reduce((ruleNamesExpression, ruleName) => {
+          const { tagName } = elementMap[ruleName];
+
+          if (tagName !== null) {
+            ruleNamesExpression = (ruleNamesExpression === null) ?
+                                    ruleName :
+                                     `${ruleNamesExpression}|${ruleName}`;
+          }
+
+          return ruleNamesExpression;
+        }, null);
+
+  return ruleNamesExpression
+}
+
+

package/src/utilities/query.js

@@ -11,6 +11,35 @@ const linkMarkdownNodesQuery = Query.fromExpression(`//link`),
       footnoteMarkdownNodesQuery = Query.fromExpression(`//footnote`),
       referenceMarkdownNodesQuery = Query.fromExpression(`//reference`);
 
+export function nodeQuery(expression) {
+  const query = Query.fromExpression(expression);
+
+  return function(node) {
+    const nodes = query.execute(node),
+      nodesLength = nodes.length;
+
+    if (nodesLength > 0) {
+      const firstNode = first(nodes);
+
+      node = firstNode; ///
+    } else {
+      node = null;
+    }
+
+    return node;
+  }
+}
+
+export function nodesQuery(expression) {
+  const query = Query.fromExpression(expression);
+
+  return function(node) {
+    const nodes = query.execute(node);
+
+    return nodes;
+  }
+}
+
 export function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
   nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);