cssstyle 5.2.1 → 5.3.1

package/lib/properties/flexGrow.js

@@ -2,26 +2,59 @@
 
 const parsers = require("../parsers");
 
-module.exports.parse = function parse(v) {
-  return parsers.parseNumber(v, true);
-};
+const property = "flex-grow";
+const shorthand = "flex";
 
-module.exports.isValid = function isValid(v) {
-  return typeof module.exports.parse(v) === "string";
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
+  if (v === "") {
+    return v;
+  }
+  const value = parsers.parsePropertyValue("flex-grow", v, {
+    globalObject,
+    inArray: true
+  });
+  if (Array.isArray(value) && value.length === 1) {
+    const [{ isNumber, name, type, value: itemValue }] = value;
+    switch (type) {
+      case "Calc": {
+        if (isNumber) {
+          return `${name}(${itemValue})`;
+        }
+        break;
+      }
+      case "GlobalKeyword": {
+        return name;
+      }
+      default: {
+        return parsers.parseNumber(value);
+      }
+    }
+  } else if (typeof value === "string") {
+    return value;
+  }
 };
 
 module.exports.definition = {
   set(v) {
     v = parsers.prepareValue(v, this._global);
     if (parsers.hasVarFunc(v)) {
-      this._setProperty("flex", "");
-      this._setProperty("flex-grow", v);
+      this._setProperty(shorthand, "");
+      this._setProperty(property, v);
     } else {
-      this._setProperty("flex-grow", module.exports.parse(v));
+      const val = module.exports.parse(v, {
+        globalObject: this._global
+      });
+      if (typeof val === "string") {
+        const shorthandPriority = this._priorities.get(shorthand);
+        const prior = this._priorities.get(property) ?? "";
+        const priority = shorthandPriority && prior ? "" : prior;
+        this._flexBoxSetter(property, val, priority, shorthand);
+      }
     }
   },
   get() {
-    return this.getPropertyValue("flex-grow");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/flexShrink.js

@@ -2,26 +2,59 @@
 
 const parsers = require("../parsers");
 
-module.exports.parse = function parse(v) {
-  return parsers.parseNumber(v, true);
-};
+const property = "flex-shrink";
+const shorthand = "flex";
 
-module.exports.isValid = function isValid(v) {
-  return typeof module.exports.parse(v) === "string";
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
+  if (v === "") {
+    return v;
+  }
+  const value = parsers.parsePropertyValue(property, v, {
+    globalObject,
+    inArray: true
+  });
+  if (Array.isArray(value) && value.length === 1) {
+    const [{ isNumber, name, type, value: itemValue }] = value;
+    switch (type) {
+      case "Calc": {
+        if (isNumber) {
+          return `${name}(${itemValue})`;
+        }
+        break;
+      }
+      case "GlobalKeyword": {
+        return name;
+      }
+      default: {
+        return parsers.parseNumber(value);
+      }
+    }
+  } else if (typeof value === "string") {
+    return value;
+  }
 };
 
 module.exports.definition = {
   set(v) {
     v = parsers.prepareValue(v, this._global);
     if (parsers.hasVarFunc(v)) {
-      this._setProperty("flex", "");
-      this._setProperty("flex-shrink", v);
+      this._setProperty(shorthand, "");
+      this._setProperty(property, v);
     } else {
-      this._setProperty("flex-shrink", module.exports.parse(v));
+      const val = module.exports.parse(v, {
+        globalObject: this._global
+      });
+      if (typeof val === "string") {
+        const shorthandPriority = this._priorities.get(shorthand);
+        const prior = this._priorities.get(property) ?? "";
+        const priority = shorthandPriority && prior ? "" : prior;
+        this._flexBoxSetter(property, val, priority, shorthand);
+      }
     }
   },
   get() {
-    return this.getPropertyValue("flex-shrink");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/float.js

@@ -2,25 +2,48 @@
 
 const parsers = require("../parsers");
 
-module.exports.parse = function parse(v) {
-  const keywords = ["left", "right", "none", "inline-start", "inline-end"];
-  return parsers.parseKeyword(v, keywords);
-};
+const property = "float";
 
-module.exports.isValid = function isValid(v) {
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
   if (v === "") {
-    return true;
+    return v;
+  }
+  const value = parsers.parsePropertyValue(property, v, {
+    globalObject,
+    inArray: true
+  });
+  if (Array.isArray(value) && value.length === 1) {
+    const [{ name, type }] = value;
+    switch (type) {
+      case "GlobalKeyword":
+      case "Identifier": {
+        return name;
+      }
+      default:
+    }
+  } else if (typeof value === "string") {
+    return value;
   }
-  return typeof module.exports.parse(v) === "string";
 };
 
 module.exports.definition = {
   set(v) {
     v = parsers.prepareValue(v, this._global);
-    this._setProperty("float", module.exports.parse(v));
+    if (parsers.hasVarFunc(v)) {
+      this._setProperty(property, v);
+    } else {
+      const val = module.exports.parse(v, {
+        globalObject: this._global
+      });
+      if (typeof val === "string") {
+        const priority = this._priorities.get(property) ?? "";
+        this._setProperty(property, val, priority);
+      }
+    }
   },
   get() {
-    return this.getPropertyValue("float");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/floodColor.js

@@ -2,28 +2,49 @@
 
 const parsers = require("../parsers");
 
-module.exports.parse = function parse(v) {
-  const val = parsers.parseColor(v);
-  if (val) {
-    return val;
-  }
-  return parsers.parseKeyword(v);
-};
+const property = "flood-color";
 
-module.exports.isValid = function isValid(v) {
-  if (v === "" || typeof parsers.parseKeyword(v) === "string") {
-    return true;
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
+  if (v === "") {
+    return v;
+  }
+  const value = parsers.parsePropertyValue(property, v, {
+    globalObject,
+    inArray: true
+  });
+  if (Array.isArray(value) && value.length === 1) {
+    const [{ name, type }] = value;
+    switch (type) {
+      case "GlobalKeyword": {
+        return name;
+      }
+      default: {
+        return parsers.parseColor(value);
+      }
+    }
+  } else if (typeof value === "string") {
+    return value;
   }
-  return parsers.isValidColor(v);
 };
 
 module.exports.definition = {
   set(v) {
     v = parsers.prepareValue(v, this._global);
-    this._setProperty("flood-color", module.exports.parse(v));
+    if (parsers.hasVarFunc(v)) {
+      this._setProperty(property, v);
+    } else {
+      const val = module.exports.parse(v, {
+        globalObject: this._global
+      });
+      if (typeof val === "string") {
+        const priority = this._priorities.get(property) ?? "";
+        this._setProperty(property, val, priority);
+      }
+    }
   },
   get() {
-    return this.getPropertyValue("flood-color");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/font.js

@@ -8,6 +8,8 @@ const fontSize = require("./fontSize");
 const lineHeight = require("./lineHeight");
 const fontFamily = require("./fontFamily");
 
+const property = "font";
+
 module.exports.shorthandFor = new Map([
   ["font-style", fontStyle],
   ["font-variant", fontVariant],
@@ -17,11 +19,15 @@ module.exports.shorthandFor = new Map([
   ["font-family", fontFamily]
 ]);
 
-module.exports.parse = function parse(v) {
-  const keywords = ["caption", "icon", "menu", "message-box", "small-caption", "status-bar"];
-  const key = parsers.parseKeyword(v, keywords);
-  if (key) {
-    return key;
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
+  if (v === "") {
+    return v;
+  } else if (parsers.hasCalcFunc(v)) {
+    v = parsers.resolveCalc(v);
+  }
+  if (!parsers.isValidPropertyValue(property, v)) {
+    return;
   }
   const [fontBlock, ...families] = parsers.splitValue(v, {
     delimiter: ","
@@ -37,13 +43,21 @@ module.exports.parse = function parse(v) {
   const fontFamilies = new Set();
   if (fontBlockB) {
     const [lineB, ...familiesB] = fontBlockB.trim().split(" ");
-    if (!lineB || !lineHeight.isValid(lineB) || !familiesB.length) {
+    if (!lineB || !familiesB.length) {
+      return;
+    }
+    const lineHeightB = lineHeight.parse(lineB, {
+      global
+    });
+    if (typeof lineHeightB !== "string") {
       return;
     }
-    const lineHeightB = lineHeight.parse(lineB);
-    const familyB = familiesB.join(" ");
-    if (fontFamily.isValid(familyB)) {
-      fontFamilies.add(fontFamily.parse(familyB));
+    const familyB = fontFamily.parse(familiesB.join(" "), {
+      globalObject,
+      caseSensitive: true
+    });
+    if (typeof familyB === "string") {
+      fontFamilies.add(familyB);
     } else {
       return;
     }
@@ -53,15 +67,42 @@ module.exports.parse = function parse(v) {
       if (part === "normal") {
         continue;
       } else {
-        for (const property of properties) {
-          switch (property) {
-            case "font-style":
-            case "font-variant":
-            case "font-weight":
+        for (const longhand of properties) {
+          switch (longhand) {
             case "font-size": {
-              const value = module.exports.shorthandFor.get(property);
-              if (value.isValid(part)) {
-                font[property] = value.parse(part);
+              const parsedValue = fontSize.parse(part, {
+                globalObject
+              });
+              if (typeof parsedValue === "string") {
+                font[longhand] = parsedValue;
+              }
+              break;
+            }
+            case "font-style":
+            case "font-weight": {
+              if (font[longhand] === "normal") {
+                const longhandItem = module.exports.shorthandFor.get(longhand);
+                const parsedValue = longhandItem.parse(part, {
+                  globalObject
+                });
+                if (typeof parsedValue === "string") {
+                  font[longhand] = parsedValue;
+                }
+              }
+              break;
+            }
+            case "font-variant": {
+              if (font[longhand] === "normal") {
+                const parsedValue = fontVariant.parse(part, {
+                  globalObject
+                });
+                if (typeof parsedValue === "string") {
+                  if (parsedValue === "small-cap") {
+                    font[longhand] = parsedValue;
+                  } else if (parsedValue !== "normal") {
+                    return;
+                  }
+                }
               }
               break;
             }
@@ -77,27 +118,66 @@ module.exports.parse = function parse(v) {
     }
   } else {
     const revParts = parsers.splitValue(fontBlockA.trim()).toReversed();
-    const revFontFamily = [];
+    if (revParts.length === 1) {
+      const [part] = revParts;
+      const value = parsers.parsePropertyValue(property, part, {
+        globalObject,
+        inArray: true
+      });
+      if (Array.isArray(value) && value.length === 1) {
+        const [{ name, type }] = value;
+        if (type === "GlobalKeyword") {
+          return {
+            "font-style": name,
+            "font-variant": name,
+            "font-weight": name,
+            "font-size": name,
+            "line-height": name,
+            "font-family": name
+          };
+        }
+      }
+      return;
+    }
     const properties = ["font-style", "font-variant", "font-weight", "line-height"];
-    font["font-style"] = "normal";
-    font["font-variant"] = "normal";
-    font["font-weight"] = "normal";
-    font["line-height"] = "normal";
+    for (const longhand of properties) {
+      font[longhand] = "normal";
+    }
+    const revFontFamily = [];
     let fontSizeA;
     for (const part of revParts) {
       if (fontSizeA) {
-        if (part === "normal") {
+        if (/^normal$/i.test(part)) {
           continue;
         } else {
-          for (const property of properties) {
-            switch (property) {
+          for (const longhand of properties) {
+            switch (longhand) {
               case "font-style":
-              case "font-variant":
               case "font-weight":
               case "line-height": {
-                const value = module.exports.shorthandFor.get(property);
-                if (value.isValid(part)) {
-                  font[property] = value.parse(part);
+                if (font[longhand] === "normal") {
+                  const longhandItem = module.exports.shorthandFor.get(longhand);
+                  const parsedValue = longhandItem.parse(part, {
+                    globalObject
+                  });
+                  if (typeof parsedValue === "string") {
+                    font[longhand] = parsedValue;
+                  }
+                }
+                break;
+              }
+              case "font-variant": {
+                if (font[longhand] === "normal") {
+                  const parsedValue = fontVariant.parse(part, {
+                    globalObject
+                  });
+                  if (typeof parsedValue === "string") {
+                    if (parsedValue === "small-cap") {
+                      font[longhand] = parsedValue;
+                    } else if (parsedValue !== "normal") {
+                      return;
+                    }
+                  }
                 }
                 break;
               }
@@ -105,16 +185,30 @@ module.exports.parse = function parse(v) {
             }
           }
         }
-      } else if (fontSize.isValid(part)) {
-        fontSizeA = fontSize.parse(part);
-      } else if (fontFamily.isValid(part)) {
-        revFontFamily.push(part);
       } else {
-        return;
+        const parsedFontSize = fontSize.parse(part, {
+          globalObject
+        });
+        if (typeof parsedFontSize === "string") {
+          fontSizeA = parsedFontSize;
+        } else {
+          const parsedFontFamily = fontFamily.parse(part, {
+            globalObject,
+            caseSensitive: true
+          });
+          if (typeof parsedFontFamily === "string") {
+            revFontFamily.push(parsedFontFamily);
+          } else {
+            return;
+          }
+        }
       }
     }
-    const family = revFontFamily.reverse().join(" ");
-    if (fontSizeA && fontFamily.isValid(family)) {
+    const family = fontFamily.parse(revFontFamily.toReversed().join(" "), {
+      globalObject,
+      caseSensitive: true
+    });
+    if (fontSizeA && family) {
       font["font-size"] = fontSizeA;
       fontFamilies.add(fontFamily.parse(family));
     } else {
@@ -122,8 +216,12 @@ module.exports.parse = function parse(v) {
     }
   }
   for (const family of families) {
-    if (fontFamily.isValid(family)) {
-      fontFamilies.add(fontFamily.parse(family));
+    const parsedFontFamily = fontFamily.parse(family, {
+      globalObject,
+      caseSensitive: true
+    });
+    if (parsedFontFamily) {
+      fontFamilies.add(parsedFontFamily);
     } else {
       return;
     }
@@ -139,17 +237,20 @@ module.exports.definition = {
       for (const [key] of module.exports.shorthandFor) {
         this._setProperty(key, "");
       }
-      this._setProperty("font", v);
+      this._setProperty(property, v);
     } else {
-      const obj = module.exports.parse(v);
+      const obj = module.exports.parse(v, {
+        globalObject: this._global
+      });
       if (!obj) {
         return;
       }
+      const priority = this._priorities.get(property) ?? "";
       const str = new Set();
       for (const [key] of module.exports.shorthandFor) {
         const val = obj[key];
         if (typeof val === "string") {
-          this._setProperty(key, val);
+          this._setProperty(key, val, priority);
           if (val && val !== "normal" && !str.has(val)) {
             if (key === "line-height") {
               str.add(`/ ${val}`);
@@ -159,11 +260,11 @@ module.exports.definition = {
           }
         }
       }
-      this._setProperty("font", [...str].join(" "));
+      this._setProperty(property, [...str].join(" "), priority);
     }
   },
   get() {
-    const val = this.getPropertyValue("font");
+    const val = this.getPropertyValue(property);
     if (parsers.hasVarFunc(val)) {
       return val;
     }