highmark-markdown 0.0.217 → 0.0.221

package/src/markdownStyle/bnf.js

@@ -2,9 +2,12 @@
 
 const bnf = `
 
-    style          ::=  ( ruleSet | declaration | nonsense | error )+ ;
+    style          ::=  ( media | ruleSet | declaration | nonsense | error )+ ;
 
     
+    media          ::= "@"<NO_WHITESPACE>"media" mediaTypes "{" ( ruleSet | declaration | nonsense )* "}" ;
+    
+
     ruleSet..      ::=  selectorsList "{" ( ruleSet | declaration | nonsense )* "}" ;
     
     
@@ -17,6 +20,12 @@ const bnf = `
     error.         ::=  . ;
 
 
+    mediaTypes     ::=  mediaType ( "and" mediaType )* ;
+                                                              
+                                                              
+    mediaType      ::=  [name] ;
+                                                              
+                                                              
     selectorsList  ::=  selectors ( "," selectors )* ;
 
 

package/src/markdownStyle/entries.js

@@ -29,7 +29,7 @@ const entries = [
     "bracket": "^(?:\\{|\\})"
   },
   {
-    "special": "^(?:,|:|;|-|\\.|\\(|\\)|\\[|\\])"
+    "special": "^(?:,|:|;|-|\\.|\\(|\\)|\\[|\\]|@)"
   },
   {
     "unassigned": "^[^\\s]+"

package/src/mediaTypeNames.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export const WEB_MEDIA_TYPE_NAME = "web";
+export const PRINT_MEDIA_TYPE_NAME = "print";
+export const PREVIEW_MEDIA_TYPE_NAME = "preview";
+
+export default {
+  WEB_MEDIA_TYPE_NAME,
+  PRINT_MEDIA_TYPE_NAME,
+  PREVIEW_MEDIA_TYPE_NAME
+};

package/src/style/declarations.js

@@ -42,13 +42,6 @@ ${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) => {

package/src/style/division.js

@@ -1,17 +1,22 @@
 "use strict";
 
+import Medias from "./medias";
 import RuleSets from "./ruleSets";
 import Declarations from "./declarations";
 
-import { EMPTY_STRING } from "../constants";
-
 export default class Division {
-  constructor(ruleSets, declarations, selectorsList) {
+  constructor(medias, ruleSets, declarations, mediaType, selectorsList) {
+    this.medias = medias;
     this.ruleSets = ruleSets;
     this.declarations = declarations;
+    this.mediaType = mediaType;
     this.selectorsList = selectorsList;
   }
 
+  getMedias() {
+    return this.medias;
+  }
+
   getRuleSets() {
     return this.ruleSets;
   }
@@ -20,26 +25,35 @@ export default class Division {
     return this.declarations;
   }
 
+  getMediaType() {
+    return this.mediaType;
+  }
+
   getSelectorsList() {
     return this.selectorsList;
   }
 
   asCSS() {
     const outermost = true,
+          mediasCSS = this.medias.asCSS(this.mediaType, this.selectorsList, outermost),
           ruleSetsCSS = this.ruleSets.asCSS(this.selectorsList, outermost),
           declarationsCSS = this.declarations.asCSS(this.selectorsList, outermost),
-          css = (declarationsCSS === EMPTY_STRING) ?
-                  ruleSetsCSS : ///
-                    `${declarationsCSS}
-${ruleSetsCSS}`;
+          css = `
+
+${declarationsCSS}
+${mediasCSS}
+${ruleSetsCSS}
+
+`;
 
     return css;
   }
 
-  static fromNodeTokensAndSelectorsList(node, tokens, selectorsList) {
-    const ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
+  static fromNodeTokensMediaTypeAndSelectorsList(node, tokens, mediaType, selectorsList) {
+    const medias = Medias.fromNodeAndTokens(node, tokens),
+          ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
           declarations = Declarations.fromNodeAndTokens(node, tokens),
-          division = new Division(ruleSets, declarations, selectorsList);
+          division = new Division(medias, ruleSets, declarations, mediaType, selectorsList);
 
     return division;
   }

package/src/style/media.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import RuleSets from "./ruleSets";
+import MediaTypes from "./mediaTypes";
+import Declarations from "./declarations";
+
+import { nodeQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const mediaTypesNonTerminalNodeQuery = nodeQuery("/*/mediaTypes");
+
+export default class Media {
+  constructor(types, ruleSets, declarations) {
+    this.types = types;
+    this.ruleSets = ruleSets;
+    this.declarations = declarations;
+  }
+
+  getTypes() {
+    return this.types;
+  }
+
+  getRuleSets() {
+    return this.ruleSets;
+  }
+
+  getDeclarations() {
+    return this.declarations;
+  }
+
+  asCSS(mediaType, selectorsList, outermost) {
+    let css = EMPTY_STRING;
+
+    const typeMatchMediaType = this.types.matchMediaType(mediaType);
+
+    if (typeMatchMediaType) {
+      const declarationsCSS = this.declarations.asCSS(selectorsList, outermost),
+            ruleSetsCSS = this.ruleSets.asCSS(selectorsList, outermost);
+
+      css = (declarationsCSS === EMPTY_STRING) ?
+              ruleSetsCSS : ///
+              `${declarationsCSS}
+${ruleSetsCSS}`;
+    }
+
+    return css;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const types = typesFromNodeAndTokens(node, tokens),
+          ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
+          declarations = Declarations.fromNodeAndTokens(node, tokens),
+          media = new Media(types, ruleSets, declarations);
+
+    return media;
+  }
+}
+
+function typesFromNodeAndTokens(node, tokens) {
+  const mediaTypesNonTerminalNode = mediaTypesNonTerminalNodeQuery(node);
+
+  node = mediaTypesNonTerminalNode;  ///
+
+  const mediaTypes = MediaTypes.fromNodeAndTokens(node, tokens),
+        types = mediaTypes;
+
+  return types;
+}

package/src/style/mediaType.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const nameTerminalNodesQuery = nodeQuery("/*/@name");
+
+export default class MediaType {
+  constructor(name) {
+    this.name = name;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  asCSS() {
+    const css = this.name;  ///
+
+    return css;
+  }
+
+  match(mediaType) {
+    const name = mediaType.getName(),
+          matches = (this.name === name);
+
+    return matches;
+  }
+
+  static fromMediaTypeName(mediaTypeName) {
+    const name = mediaTypeName, ///
+          mediaType = new MediaType(name);
+
+    return mediaType;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const name = nameFromNode(node),
+          mediaType = new MediaType(name);
+
+    return mediaType;
+  }
+}
+
+function nameFromNode(node) {
+  const nameTerminalNode = nameTerminalNodesQuery(node),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        name = nameTerminalNodeContent; ///
+
+  return name;
+}

package/src/style/mediaTypes.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import MediaType from "./mediaType";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const mediaTypeNonTerminalNodesQuery = nodesQuery("/*/mediaType");
+
+export default class MediaTypes {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  asCSS() {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength();
+
+    if (length > 0) {
+      css = this.array.reduce((css, media) => {
+        const mediaTypeCSS = mediaType.asCSS();
+
+        css = (css === null) ?
+                mediaTypeCSS :  ///
+                  `${css} and ${mediaTypeCSS}`;
+
+        return css;
+      }, null);
+    }
+
+    return css;
+  }
+
+  matchMediaType(mediaType) {
+    const mediaTypeA = mediaType, ///
+          matchesMediaType = this.array.some((mediaType) => {
+            const mediaTypeB = mediaType, ///
+                  matches = mediaTypeA.match(mediaTypeB);
+
+            if (matches) {
+              return true;
+            }
+          });
+
+    return matchesMediaType;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const mediaTypeNonTerminalNodes = mediaTypeNonTerminalNodesQuery(node),
+          array = mediaTypeNonTerminalNodes.map((mediaTypeNonTerminalNode) => {
+            const node = mediaTypeNonTerminalNode, ///
+                  mediaType = MediaType.fromNodeAndTokens(node, tokens);
+
+            return mediaType;
+          }),
+          medias = new MediaTypes(array);
+
+    return medias;
+  }
+}

package/src/style/medias.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import Media from "./media";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const mediaNonTerminalNodesQuery = nodesQuery("/*/media");
+
+export default class Medias {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  asCSS(mediaType, selectorsList, outermost) {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength(),
+          selectorsListLength = selectorsList.getLength();
+
+    if ((length > 0) && (selectorsListLength > 0)) {
+      css = this.array.reduce((css, media) => {
+        const mediaCSS = media.asCSS(mediaType, selectorsList, outermost);
+
+        css = (css === null) ?
+                mediaCSS :  ///
+                  `${css}${mediaCSS}`;
+
+        return css;
+      }, null);
+    }
+
+    return css;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const mediaNonTerminalNodes = mediaNonTerminalNodesQuery(node),
+          array = mediaNonTerminalNodes.map((mediaNonTerminalNode) => {
+            const node = mediaNonTerminalNode, ///
+                  media = Media.fromNodeAndTokens(node, tokens);
+
+            return media;
+          }),
+          medias = new Medias(array);
+
+    return medias;
+  }
+}

package/src/style/ruleSet.js

@@ -37,7 +37,7 @@ ${ruleSetsCSS}`;
     return css;
   }
 
-  static fromRuleSetsNodeAndTokens(RuleSets, node, tokens) {
+  static fromNodeAndTokens(node, tokens, RuleSets) {
     const ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
           declarations = Declarations.fromNodeAndTokens(node, tokens),
           selectorsList = SelectorsList.fromNodeAndTokens(node, tokens),

package/src/style/ruleSets.js

@@ -35,18 +35,11 @@ export default class RuleSets {
     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);
+                  ruleSet = RuleSet.fromNodeAndTokens(node, tokens, RuleSets);
 
             return ruleSet;
           }),

package/src/styleElement/markdown.js

@@ -1,15 +1,16 @@
 "use strict";
 
+import MediaType from "../style/mediaType";
 import StyleElement from "../styleElement";
 import SelectorsList from "../style/selectorsList";
 
 import { EMPTY_STRING } from "../constants";
 import { createDOMElement } from "../styleElement";
-import { cssFromMarkdownStyleAndSelectorsList } from "../utilities/css";
+import { cssFromMarkdownStyleMediaTypeAndSelectorsList } from "../utilities/css";
 
 export default class MarkdownStyleElement extends StyleElement {
-  constructor(domElement, selectorsList) {
-    super(domElement);
+  constructor(mediaType, domElement, selectorsList) {
+    super(mediaType, domElement);
 
     this.selectorsList = selectorsList;
   }
@@ -18,8 +19,9 @@ export default class MarkdownStyleElement extends StyleElement {
     return this.selectorsList;
   }
 
-  update(markdownStyle = null) {
-    const css = cssFromMarkdownStyleAndSelectorsList(markdownStyle, this.selectorsList);
+  update(markdownStyle) {
+    const mediaType = this.getMediaType(),
+          css = cssFromMarkdownStyleMediaTypeAndSelectorsList(markdownStyle, mediaType, this.selectorsList);
 
     this.setCSS(css);
 
@@ -32,16 +34,19 @@ export default class MarkdownStyleElement extends StyleElement {
     this.update(markdownStyle)
   }
 
-  static fromSelectorsString(Class, selectorString) {
+  static fromMediaTypeNameAndSelectorsString(Class, mediaTypeName, selectorString) {
     if (selectorString === undefined) {
-      selectorString = Class; ///
+      selectorString = mediaTypeName; ///
+
+      mediaTypeName = Class; ///
 
       Class = MarkdownStyleElement; ///
     }
 
-    const domElement = createDOMElement(),
+    const mediaType = MediaType.fromMediaTypeName(mediaTypeName),
+          domElement = createDOMElement(),
           selectorsList = SelectorsList.fromSelectorsString(selectorString),
-          markdownStyleElement = new Class(domElement, selectorsList);
+          markdownStyleElement = new Class(mediaType, domElement, selectorsList);
 
     return markdownStyleElement;
   }

package/src/styleElement.js

@@ -3,14 +3,23 @@
 import { HEAD, STYLE } from "./constants";
 
 export default class StyleElement {
-  constructor(domElement) {
+  constructor(mediaType, domElement) {
+    this.mediaType = mediaType;
     this.domElement = domElement;
   }
 
+  getMediaType() {
+    return this.mediaType;
+  }
+
   getDOMElement() {
     return this.domElement;
   }
 
+  setMediaType(mediaType) {
+    this.mediaType = mediaType;
+  }
+
   setDOMElement(domElement) {
     this.domElement = domElement;
   }
@@ -28,13 +37,6 @@ ${css}
   }
 
   remove() { this.domElement.remove(); }
-
-  static fromNothing() {
-    const domElement = createDOMElement(),
-          styleElement = new StyleElement(domElement);
-
-    return styleElement;
-  }
 }
 
 export function createDOMElement() {

package/src/utilities/css.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Division from "../style/division";
+import MediaType from "../style/mediaType";
 import SelectorsList from "../style/selectorsList";
 import MarkdownStyleLexer from "../markdownStyle/lexer";
 import MarkdownStyleParser from "../markdownStyle/parser";
@@ -10,7 +11,7 @@ import { EMPTY_STRING } from "../constants";
 const markdownStyleLexer = MarkdownStyleLexer.fromNothing(),
       markdownStyleParser = MarkdownStyleParser.fromNothing();
 
-export function cssFromMarkdownStyleAndSelectorsList(markdownStyle, selectorsList) {
+export function cssFromMarkdownStyleMediaTypeAndSelectorsList(markdownStyle, mediaType, selectorsList) {
   let css = EMPTY_STRING;
 
   const lexer = markdownStyleLexer, ///
@@ -20,7 +21,7 @@ export function cssFromMarkdownStyleAndSelectorsList(markdownStyle, selectorsLis
         node = parser.parse(tokens);
 
   if (node !== null) {
-    const division = Division.fromNodeTokensAndSelectorsList(node, tokens, selectorsList);
+    const division = Division.fromNodeTokensMediaTypeAndSelectorsList(node, tokens, mediaType, selectorsList);
 
     css = division.asCSS();
   }
@@ -28,14 +29,15 @@ export function cssFromMarkdownStyleAndSelectorsList(markdownStyle, selectorsLis
   return css;
 }
 
-export function cssFromMarkdownStyleAndSelectorString(markdownStyle, selectorString) {
+export function cssFromMarkdownStyleMediaTypeNameAndSelectorString(markdownStyle, mediaTypeName, selectorString) {
   const selectorsList = SelectorsList.fromSelectorsString(selectorString),
-        css = cssFromMarkdownStyleAndSelectorsList(markdownStyle, selectorsList);
+        mediaType = MediaType.fromMediaTypeName(mediaTypeName),
+        css = cssFromMarkdownStyleMediaTypeAndSelectorsList(markdownStyle, mediaType, selectorsList);
 
   return css;
 }
 
 export default {
-  cssFromMarkdownStyleAndSelectorsList,
-  cssFromMarkdownStyleAndSelectorString
+  cssFromMarkdownStyleMediaTypeAndSelectorsList,
+  cssFromMarkdownStyleMediaTypeNameAndSelectorString
 };

package/src/utilities/query.js

@@ -19,7 +19,7 @@ export function nodeQuery(expression) {
 
   return function(node) {
     const nodes = query.execute(node),
-      nodesLength = nodes.length;
+          nodesLength = nodes.length;
 
     if (nodesLength > 0) {
       const firstNode = first(nodes);