cssstyle 5.2.0 → 5.3.0

package/lib/properties/borderWidth.js

@@ -1,43 +1,128 @@
 "use strict";
 
 const parsers = require("../parsers");
+const borderTopWidth = require("./borderTopWidth");
+const borderRightWidth = require("./borderRightWidth");
+const borderBottomWidth = require("./borderBottomWidth");
+const borderLeftWidth = require("./borderLeftWidth");
 
-module.exports.parse = function parse(v) {
-  const keywords = ["thin", "medium", "thick"];
-  const key = parsers.parseKeyword(v, keywords);
-  if (key) {
-    return key;
-  }
-  return parsers.parseLength(v, true);
-};
+const property = "border-width";
+const shorthand = "border";
 
-module.exports.isValid = function isValid(v) {
+module.exports.shorthandFor = new Map([
+  ["border-top-width", borderTopWidth],
+  ["border-right-width", borderRightWidth],
+  ["border-bottom-width", borderBottomWidth],
+  ["border-left-width", borderLeftWidth]
+]);
+
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
   if (v === "") {
-    return true;
+    return v;
+  }
+  const values = parsers.parsePropertyValue(property, v, {
+    globalObject,
+    inArray: true
+  });
+  const parsedValues = [];
+  if (Array.isArray(values) && values.length) {
+    if (values.length > 4) {
+      return;
+    }
+    for (const value of values) {
+      const { isNumber, name, type, value: itemValue } = value;
+      switch (type) {
+        case "Calc": {
+          if (isNumber) {
+            return;
+          }
+          parsedValues.push(`${name}(${itemValue})`);
+          break;
+        }
+        case "GlobalKeyword": {
+          if (values.length !== 1) {
+            return;
+          }
+          return name;
+        }
+        case "Identifier": {
+          parsedValues.push(name);
+          break;
+        }
+        default: {
+          const parsedValue = parsers.parseLength([value], {
+            min: 0
+          });
+          if (!parsedValue) {
+            return;
+          }
+          parsedValues.push(parsedValue);
+        }
+      }
+    }
+  } else if (typeof values === "string") {
+    parsedValues.push(values);
+  }
+  if (parsedValues.length) {
+    switch (parsedValues.length) {
+      case 1: {
+        return parsedValues;
+      }
+      case 2: {
+        const [val1, val2] = parsedValues;
+        if (val1 === val2) {
+          return [val1];
+        }
+        return parsedValues;
+      }
+      case 3: {
+        const [val1, val2, val3] = parsedValues;
+        if (val1 === val3) {
+          if (val1 === val2) {
+            return [val1];
+          }
+          return [val1, val2];
+        }
+        return parsedValues;
+      }
+      case 4: {
+        const [val1, val2, val3, val4] = parsedValues;
+        if (val2 === val4) {
+          if (val1 === val3) {
+            if (val1 === val2) {
+              return [val1];
+            }
+            return [val1, val2];
+          }
+          return [val1, val2, val3];
+        }
+        return parsedValues;
+      }
+      default:
+    }
   }
-  return typeof module.exports.parse(v) === "string";
 };
 
 module.exports.definition = {
   set(v) {
     v = parsers.prepareValue(v, this._global);
     if (parsers.hasVarFunc(v)) {
-      this._setProperty("border", "");
-      this._setProperty("border-width", v);
+      this._borderSetter(property, v, "");
     } else {
-      const positions = ["top", "right", "bottom", "left"];
-      this._implicitSetter(
-        "border",
-        "width",
-        v,
-        module.exports.isValid,
-        module.exports.parse,
-        positions
-      );
+      const val = module.exports.parse(v, {
+        globalObject: this._global
+      });
+      if (Array.isArray(val) || typeof val === "string") {
+        const shorthandPriority = this._priorities.get(shorthand);
+        const prior = this._priorities.get(property) ?? "";
+        const priority = shorthandPriority && prior ? "" : prior;
+        this._borderSetter(property, val, priority);
+      }
     }
   },
   get() {
-    return this.getPropertyValue("border-width");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/bottom.js

@@ -2,28 +2,56 @@
 
 const parsers = require("../parsers");
 
-module.exports.parse = function parse(v) {
-  const dim = parsers.parseMeasurement(v);
-  if (dim) {
-    return dim;
-  }
-  return parsers.parseKeyword(v, ["auto"]);
-};
+const property = "bottom";
 
-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 [{ isNumber, name, raw, type }] = value;
+    switch (type) {
+      case "Calc": {
+        if (!isNumber) {
+          return raw;
+        }
+        break;
+      }
+      case "GlobalKeyword":
+      case "Identifier": {
+        return name;
+      }
+      default: {
+        return parsers.parseLengthPercentage(value);
+      }
+    }
+  } 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("bottom", 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("bottom");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/clear.js

@@ -2,38 +2,48 @@
 
 const parsers = require("../parsers");
 
-module.exports.parse = function parse(v) {
-  const keywords = [
-    "inline-start",
-    "inline-end",
-    "block-start",
-    "block-end",
-    "left",
-    "right",
-    "top",
-    "bottom",
-    "both-inline",
-    "both-block",
-    "both",
-    "none"
-  ];
-  return parsers.parseKeyword(v, keywords);
-};
+const property = "clear";
 
-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("clear", 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("clear");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/clip.js

@@ -3,51 +3,65 @@
 // @see https://drafts.fxtf.org/css-masking/#clip-property
 
 const parsers = require("../parsers");
-const strings = require("../utils/strings");
 
-module.exports.parse = function parse(v) {
+const property = "clip";
+
+module.exports.parse = function parse(v, opt = {}) {
+  const { globalObject } = opt;
   if (v === "") {
     return v;
   }
-  const val = parsers.parseKeyword(v, ["auto"]);
-  if (val) {
-    return val;
-  }
-  // parse legacy <shape>
-  v = strings.asciiLowercase(v);
-  const matches = v.match(/^rect\(\s*(.*)\s*\)$/);
-  if (!matches) {
-    return;
-  }
-  const parts = matches[1].split(/\s*,\s*/);
-  if (parts.length !== 4) {
-    return;
-  }
-  const valid = parts.every(function (part, index) {
-    const measurement = parsers.parseMeasurement(part.trim());
-    parts[index] = measurement;
-    return typeof measurement === "string";
+  const value = parsers.parsePropertyValue(property, v, {
+    globalObject,
+    inArray: true
   });
-  if (!valid) {
-    return;
-  }
-  return `rect(${parts.join(", ")})`;
-};
-
-module.exports.isValid = function isValid(v) {
-  if (v === "") {
-    return true;
+  if (Array.isArray(value) && value.length === 1) {
+    const [{ name, type, value: itemValue }] = value;
+    switch (type) {
+      case "Function": {
+        const values = parsers.splitValue(itemValue, {
+          delimiter: ","
+        });
+        const parsedValues = [];
+        for (const item of values) {
+          const parsedValue = parsers.parseCSS(item, { context: "value" }, true);
+          const val = parsers.parseLengthPercentage(parsedValue.children);
+          if (val) {
+            parsedValues.push(val);
+          } else {
+            return;
+          }
+        }
+        return `${name}(${parsedValues.join(", ")})`;
+      }
+      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("clip", 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("clip");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true

package/lib/properties/color.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 = "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("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("color");
+    return this.getPropertyValue(property);
   },
   enumerable: true,
   configurable: true