highmark-markdown 0.0.206 → 0.0.209

package/src/markdownStyle/entries.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import elementMap from "../elementMap";
+
+import { ruleNamesExpressionFromElementMap } from "../utilities/entries";
+
+const ruleNamesExpression = ruleNamesExpressionFromElementMap(elementMap);
+
+const entries = [
+  {
+    "escaped": "^\\\\[^\\s]"
+  },
+  {
+    "rule-name": `^(?:${ruleNamesExpression})`
+  },
+  {
+    "number": "^(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?"
+  },
+  {
+    "colour": "^#(?:[0-9a-fA-F]{6}|[0-9a-fA-F]{3})"
+  },
+  {
+    "unit": "^(?:deg|%)"
+  },
+  {
+    "name": "^[_a-zA-Z0-9]+"
+  },
+  {
+    "bracket": "^(?:\\{|\\})"
+  },
+  {
+    "special": "^(?:,|:|;|-|\\.|\\(|\\)|\\[|\\])"
+  },
+  {
+    "unassigned": "^[^\\s]+"
+  }
+];
+
+export default entries;

package/src/markdownStyle/lexer.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { CommonLexer } from "occam-lexers";
+import { WhitespaceToken,
+         EndOfLineNonSignificantToken,
+         CStyleSingleLineCommentToken,
+         DoublyQuotedStringLiteralToken,
+         EndOfLineCommentSignificantToken,
+         CStyleEndOfMultiLineCommentToken,
+         CStyleStartOfMultiLineCommentToken,
+         CStyleMiddleOfMultiLineCommentToken } from "occam-lexers";
+
+import entries from "./entries";
+
+export default class MarkdownStyleLexer extends CommonLexer {
+  static entries = entries;
+
+  static EndOfLineToken = EndOfLineNonSignificantToken;
+
+  static WhitespaceToken = WhitespaceToken;
+
+  static EndOfLineCommentToken = EndOfLineCommentSignificantToken;  ///
+
+  static SingleLineCommentToken = CStyleSingleLineCommentToken; ///
+
+  static RegularExpressionToken = null;
+
+  static EndOfMultiLineCommentToken = CStyleEndOfMultiLineCommentToken; ///
+
+  static StartOfMultiLineCommentToken = CStyleStartOfMultiLineCommentToken; ///
+
+  static MiddleOfMultiLineCommentToken = CStyleMiddleOfMultiLineCommentToken; ///
+
+  static SinglyQuotedStringLiteralToken = null;
+
+  static DoublyQuotedStringLiteralToken = DoublyQuotedStringLiteralToken;
+
+  static fromNothing() { return CommonLexer.fromNothing(MarkdownStyleLexer); }
+
+  static fromRules(rules) { return CommonLexer.fromRules(MarkdownStyleLexer, rules); }
+
+  static fromEntries(entries) { return CommonLexer.fromEntries(MarkdownStyleLexer, entries); }
+}

package/src/markdownStyle/parser.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { CommonParser } from "occam-parsers";
+
+import bnf from "./bnf";
+
+export default class MarkdownStyleParser extends CommonParser {
+  static bnf = bnf;
+
+  static fromNothing() { return CommonParser.fromNothing(MarkdownStyleParser); }
+
+  static fromBNF(bnf) { return CommonParser.fromBNF(MarkdownStyleParser, bnf); }
+
+  static fromRules(rules) { return CommonParser.fromRules(MarkdownStyleParser, rules); }
+}

package/src/style/declaration.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { COLOUR } from "../constants";
+import { nodeQuery } from "../utilities/query";
+import { contentFromNodeAndTokens } from "../utilities/content";
+
+const nameNonTerminalNodeQuery = nodeQuery("/*/name"),
+      valuesNonTerminalNodeQuery = nodeQuery("/*/values");
+
+export default class Declaration {
+  constructor(name, values) {
+    this.name = name;
+    this.values = values;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getValues() {
+    return this.values;
+  }
+
+  asCSS() {
+    const name = this.name.replace(/colour/g, COLOUR),
+          css = `  ${name}: ${this.values};`;
+
+    return css;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const nameNonTerminalNode = nameNonTerminalNodeQuery(node),
+          valuesNonTerminalNode = valuesNonTerminalNodeQuery(node),
+          nameNonTerminalNodeContent = contentFromNodeAndTokens(nameNonTerminalNode, tokens),
+          valuesNonTerminalNodesContent = contentFromNodeAndTokens(valuesNonTerminalNode, tokens),
+          name = nameNonTerminalNodeContent, ///
+          values = valuesNonTerminalNodesContent, ///
+          declaration = new Declaration(name, values);
+
+    return declaration;
+  }
+}

package/src/style/declarations.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import Declaration from "./declaration";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const declarationNonTerminalNodesQuery = nodesQuery("/*/declaration");
+
+export default class Declarations {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  asCSS(selectorsList) {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength(),
+          selectorsListLength = selectorsList.getLength();
+
+    if ((length > 0) && (selectorsListLength > 0)) {
+      const declarationsCSS = this.array.reduce((declarationsCSS, declaration) => {
+              const declarationCSS = declaration.asCSS();
+
+              declarationsCSS = (declarationsCSS === null) ?
+                                  declarationCSS : ///
+                                    `${declarationsCSS}
+${declarationCSS}`;
+
+              return declarationsCSS;
+            }, null),
+            selectorsListCSS = selectorsList.asCSS();
+
+      css = `${selectorsListCSS} {
+${declarationsCSS}
+}
+`;
+    }
+
+    return css;
+  }
+
+  static fromNothing() {
+    const array = [],
+          declarations = new Declarations(array);
+
+    return declarations;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const declarationNonTerminalNodes = declarationNonTerminalNodesQuery(node),
+          array = declarationNonTerminalNodes.map((declarationNonTerminalNode) => {
+            const node = declarationNonTerminalNode, ///
+                  declaration = Declaration.fromNodeAndTokens(node, tokens);
+
+            return declaration;
+          }),
+          declarations = new Declarations(array);
+
+    return declarations;
+  }
+}

package/src/style/division.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import RuleSets from "./ruleSets";
+import Declarations from "./declarations";
+
+import { EMPTY_STRING } from "../constants";
+
+export default class Division {
+  constructor(ruleSets, declarations, selectorsList) {
+    this.ruleSets = ruleSets;
+    this.declarations = declarations;
+    this.selectorsList = selectorsList;
+  }
+
+  getRuleSets() {
+    return this.ruleSets;
+  }
+
+  getDeclarations() {
+    return this.declarations;
+  }
+
+  getSelectorsList() {
+    return this.selectorsList;
+  }
+
+  asCSS() {
+    const outermost = true,
+          ruleSetsCSS = this.ruleSets.asCSS(this.selectorsList, outermost),
+          declarationsCSS = this.declarations.asCSS(this.selectorsList, outermost),
+          css = (declarationsCSS === EMPTY_STRING) ?
+                  ruleSetsCSS : ///
+                    `${declarationsCSS}
+${ruleSetsCSS}`;
+
+    return css;
+  }
+
+  static fromNodeTokensAndSelectorsList(node, tokens, selectorsList) {
+    const ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
+          declarations = Declarations.fromNodeAndTokens(node, tokens),
+          division = new Division(ruleSets, declarations, selectorsList);
+
+    return division;
+  }
+}

package/src/style/ruleSet.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import Declarations from "./declarations";
+import SelectorsList from "./selectorsList";
+
+import { EMPTY_STRING } from "../constants";
+
+export default class RuleSet {
+  constructor(ruleSets, declarations, selectorsList) {
+    this.ruleSets = ruleSets;
+    this.declarations = declarations;
+    this.selectorsList = selectorsList;
+  }
+
+  getRuleSets() {
+    return this.ruleSets;
+  }
+
+  getDeclarations() {
+    return this.declarations;
+  }
+
+  getSelectorsList() {
+    return this.selectorsList;
+  }
+
+  asCSS(selectorsList, outermost = false) {
+    selectorsList = selectorsList.combine(this.selectorsList, outermost);  ///
+
+    const declarationsCSS = this.declarations.asCSS(selectorsList),
+          ruleSetsCSS = this.ruleSets.asCSS(selectorsList),
+          css = (declarationsCSS === EMPTY_STRING) ?
+                  ruleSetsCSS : ///
+                    `${declarationsCSS}
+${ruleSetsCSS}`;
+
+    return css;
+  }
+
+  static fromRuleSetsNodeAndTokens(RuleSets, node, tokens) {
+    const ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
+          declarations = Declarations.fromNodeAndTokens(node, tokens),
+          selectorsList = SelectorsList.fromNodeAndTokens(node, tokens),
+          ruleSet = new RuleSet(ruleSets, declarations, selectorsList);
+
+    return ruleSet;
+  }
+}

package/src/style/ruleSets.js

@@ -0,0 +1,57 @@
+"use strict";
+
+import RuleSet from "./ruleSet";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const ruleSetNonTerminalNodesQuery = nodesQuery("/*/ruleSet");
+
+export default class RuleSets {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  asCSS(selectorsList, outermost = false) {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength(),
+          selectorsListLength = selectorsList.getLength();
+
+    if ((length > 0) && (selectorsListLength > 0)) {
+      css = this.array.reduce((css, ruleSet) => {
+        const ruleSetCSS = ruleSet.asCSS(selectorsList, outermost);
+
+        css = (css === null) ?
+                ruleSetCSS :  ///
+                  `${css}${ruleSetCSS}`;
+
+        return css;
+      }, null);
+    }
+
+    return css;
+  }
+
+  static fromNothing() {
+    const array = [],
+          ruleSets = new RuleSets(array);
+
+    return ruleSets;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const ruleSetNonTerminalNodes = ruleSetNonTerminalNodesQuery(node),
+          array = ruleSetNonTerminalNodes.map((ruleSetNonTerminalNode) => {
+            const node = ruleSetNonTerminalNode, ///
+                  ruleSet = RuleSet.fromRuleSetsNodeAndTokens(RuleSets, node, tokens);
+
+            return ruleSet;
+          }),
+          ruleSets = new RuleSets(array);
+
+    return ruleSets;
+  }
+}

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;
+  }
+}