cssstyle 5.3.7 → 6.0.0

package/lib/utils/propertyDescriptors.js

@@ -2,54 +2,141 @@
 
 const parsers = require("../parsers");
 
+// Constants
 const { AST_TYPES } = parsers;
 
-const getPropertyDescriptor = (property) => ({
-  set(v) {
-    const value = parsers.prepareValue(v);
-    if (parsers.hasVarFunc(value)) {
-      this._setProperty(property, value);
-    } else {
-      const parsedValue = parsers.parsePropertyValue(property, v, {
-        globalObject: this._global,
-        inArray: true
-      });
-      if (Array.isArray(parsedValue)) {
-        if (parsedValue.length === 1) {
-          const [{ name, type, value: itemValue }] = parsedValue;
-          switch (type) {
-            case AST_TYPES.CALC: {
-              this._setProperty(property, `${name}(${itemValue})`);
-              break;
-            }
-            case AST_TYPES.GLOBAL_KEYWORD:
-            case AST_TYPES.IDENTIFIER: {
-              // Set the normalized name for keywords or identifiers.
-              this._setProperty(property, name);
-              break;
-            }
-            default: {
-              // Set the prepared value for Dimension, Function, etc.
-              this._setProperty(property, value);
+/**
+ * Creates a generic property descriptor for a given property. Such descriptors are used whenever we don't have a
+ * specific handler in `./properties/*.js`. They perform some basic logic that works as a fallback, and is correct for
+ * simple properties, but properties with more complex grammars will need their own handlers.
+ *
+ * @param {string} property - The canonical CSS property name (e.g. "backdrop-filter", not "backdropFilter").
+ * @param {object} opts - The options object.
+ * @param {boolean} opts.caseSensitive - True if value is case-sensitive, false otherwise.
+ * @param {object} [opts.dimensionTypes={}] - An object containing information about the dimension types used by this
+ * property, if any. Keys are a type of dimension, which determines which serializer to use, and values are the
+ * information used by the serializer to serialize a parsed value.
+ * @param {object} [opts.functionTypes={}] - An object containing information about the function types used by this
+ * property, if any. Keys are a type of function, which determines which function to use; values are ignored.
+ * @returns {object} The property descriptor object.
+ */
+function createGenericPropertyDescriptor(property, { caseSensitive, dimensionTypes = {}, functionTypes = {} }) {
+  return {
+    set(v) {
+      const value = parsers.prepareValue(v);
+      if (parsers.hasVarFunc(value)) {
+        this._setProperty(property, value);
+      } else {
+        const parsedValue = parsers.parsePropertyValue(property, v, {
+          caseSensitive
+        });
+        if (Array.isArray(parsedValue)) {
+          if (parsedValue.length === 1) {
+            const {
+              angle: angleType,
+              dimension: dimensionType,
+              length: lengthType,
+              number: numberType,
+              percentage: percentageType
+            } = dimensionTypes;
+            const { color: colorType, image: imageType } = functionTypes;
+            const [{ name, type, value: itemValue }] = parsedValue;
+            switch (type) {
+              case AST_TYPES.CALC: {
+                this._setProperty(property, `${name}(${itemValue})`);
+                break;
+              }
+              case AST_TYPES.DIMENSION: {
+                let val;
+                if (dimensionType && lengthType) {
+                  val = parsers.serializeLength(parsedValue, lengthType);
+                  if (!val) {
+                    val = parsers.serializeDimension(parsedValue, dimensionType);
+                  }
+                } else if (lengthType) {
+                  val = parsers.serializeLength(parsedValue, lengthType);
+                } else {
+                  val = parsers.serializeDimension(parsedValue, dimensionType);
+                }
+                this._setProperty(property, val);
+                break;
+              }
+              case AST_TYPES.HASH: {
+                this._setProperty(property, parsers.serializeColor(parsedValue));
+                break;
+              }
+              case AST_TYPES.NUMBER: {
+                let val;
+                if (numberType) {
+                  val = parsers.serializeNumber(parsedValue, numberType);
+                } else if (angleType) {
+                  val = parsers.serializeAngle(parsedValue, angleType);
+                } else if (lengthType) {
+                  val = parsers.serializeLength(parsedValue, lengthType);
+                } else if (percentageType) {
+                  val = parsers.serializePercentage(parsedValue, percentageType);
+                }
+                this._setProperty(property, val);
+                break;
+              }
+              case AST_TYPES.GLOBAL_KEYWORD:
+              case AST_TYPES.IDENTIFIER: {
+                this._setProperty(property, name);
+                break;
+              }
+              case AST_TYPES.PERCENTAGE: {
+                let numericType;
+                if (percentageType) {
+                  numericType = percentageType;
+                } else if (dimensionType) {
+                  numericType = dimensionType;
+                } else if (angleType) {
+                  numericType = angleType;
+                } else if (lengthType) {
+                  numericType = lengthType;
+                }
+                if (numericType) {
+                  this._setProperty(property, parsers.resolveNumericValue(parsedValue, numericType));
+                }
+                break;
+              }
+              case AST_TYPES.STRING: {
+                this._setProperty(property, parsers.serializeString(parsedValue));
+                break;
+              }
+              case AST_TYPES.URL: {
+                this._setProperty(property, parsers.serializeURL(parsedValue));
+                break;
+              }
+              case AST_TYPES.FUNCTION:
+              default: {
+                if (colorType) {
+                  this._setProperty(property, parsers.serializeColor(parsedValue));
+                } else if (imageType) {
+                  this._setProperty(property, parsers.serializeGradient(parsedValue));
+                } else {
+                  this._setProperty(property, value);
+                }
+              }
             }
+          } else {
+            // Set the prepared value for lists containing multiple values.
+            this._setProperty(property, value);
           }
-        } else {
-          // Set the prepared value for lists containing multiple values.
-          this._setProperty(property, value);
+        } else if (typeof parsedValue === "string") {
+          // Empty string.
+          this._setProperty(property, parsedValue);
         }
-      } else if (typeof parsedValue === "string") {
-        // Empty string.
-        this._setProperty(property, parsedValue);
       }
-    }
-  },
-  get() {
-    return this.getPropertyValue(property);
-  },
-  enumerable: true,
-  configurable: true
-});
+    },
+    get() {
+      return this.getPropertyValue(property);
+    },
+    enumerable: true,
+    configurable: true
+  };
+}
 
 module.exports = {
-  getPropertyDescriptor
+  createGenericPropertyDescriptor
 };

package/lib/utils/strings.js

@@ -2,12 +2,14 @@
 
 "use strict";
 
-// https://infra.spec.whatwg.org/#ascii-whitespace
-const asciiWhitespaceRe = /^[\t\n\f\r ]$/;
-exports.asciiWhitespaceRe = asciiWhitespaceRe;
-
-// https://infra.spec.whatwg.org/#ascii-lowercase
-exports.asciiLowercase = (s) => {
+/**
+ * Converts a string to ASCII lowercase.
+ *
+ * @see https://infra.spec.whatwg.org/#ascii-lowercase
+ * @param {string} s - The string to convert.
+ * @returns {string} The converted string.
+ */
+function asciiLowercase(s) {
   if (!/[^\x00-\x7f]/.test(s)) {
     return s.toLowerCase();
   }
@@ -19,155 +21,8 @@ exports.asciiLowercase = (s) => {
     out[i] = code >= 65 && code <= 90 ? String.fromCharCode(code | 32) : s[i];
   }
   return out.join("");
-};
-
-// https://infra.spec.whatwg.org/#ascii-uppercase
-exports.asciiUppercase = (s) => {
-  if (!/[^\x00-\x7f]/.test(s)) {
-    return s.toUpperCase();
-  }
-  const len = s.length;
-  const out = new Array(len);
-  for (let i = 0; i < len; i++) {
-    const code = s.charCodeAt(i);
-    // If the character is between 'a' (97) and 'z' (122), convert using bitwise AND with ~32
-    out[i] = code >= 97 && code <= 122 ? String.fromCharCode(code & ~32) : s[i];
-  }
-  return out.join("");
-};
-
-// https://infra.spec.whatwg.org/#strip-newlines
-exports.stripNewlines = (s) => {
-  return s.replace(/[\n\r]+/g, "");
-};
-
-// https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
-exports.stripLeadingAndTrailingASCIIWhitespace = (s) => {
-  return s.replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
-};
-
-// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
-exports.stripAndCollapseASCIIWhitespace = (s) => {
-  return s
-    .replace(/[ \t\n\f\r]+/g, " ")
-    .replace(/^[ \t\n\f\r]+/, "")
-    .replace(/[ \t\n\f\r]+$/, "");
-};
-
-// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-simple-colour
-exports.isValidSimpleColor = (s) => {
-  return /^#[a-fA-F\d]{6}$/.test(s);
-};
-
-// https://infra.spec.whatwg.org/#ascii-case-insensitive
-exports.asciiCaseInsensitiveMatch = (a, b) => {
-  if (a.length !== b.length) {
-    return false;
-  }
+}
 
-  for (let i = 0; i < a.length; ++i) {
-    if ((a.charCodeAt(i) | 32) !== (b.charCodeAt(i) | 32)) {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-integers
-// Error is represented as null.
-const parseInteger = (exports.parseInteger = (input) => {
-  // The implementation here is slightly different from the spec's. We want to use parseInt(), but parseInt() trims
-  // Unicode whitespace in addition to just ASCII ones, so we make sure that the trimmed prefix contains only ASCII
-  // whitespace ourselves.
-  const numWhitespace = input.length - input.trimStart().length;
-  if (/[^\t\n\f\r ]/.test(input.slice(0, numWhitespace))) {
-    return null;
-  }
-  // We don't allow hexadecimal numbers here.
-  // eslint-disable-next-line radix
-  const value = parseInt(input, 10);
-  if (Number.isNaN(value)) {
-    return null;
-  }
-  // parseInt() returns -0 for "-0". Normalize that here.
-  return value === 0 ? 0 : value;
-});
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-non-negative-integers
-// Error is represented as null.
-exports.parseNonNegativeInteger = (input) => {
-  const value = parseInteger(input);
-  if (value === null) {
-    return null;
-  }
-  if (value < 0) {
-    return null;
-  }
-  return value;
-};
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-floating-point-number
-const floatingPointNumRe = /^-?(?:\d+|\d*\.\d+)(?:[eE][-+]?\d+)?$/;
-exports.isValidFloatingPointNumber = (str) => floatingPointNumRe.test(str);
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-floating-point-number-values
-// Error is represented as null.
-exports.parseFloatingPointNumber = (str) => {
-  // The implementation here is slightly different from the spec's. We need to use parseFloat() in order to retain
-  // accuracy, but parseFloat() trims Unicode whitespace in addition to just ASCII ones, so we make sure that the
-  // trimmed prefix contains only ASCII whitespace ourselves.
-  const numWhitespace = str.length - str.trimStart().length;
-  if (/[^\t\n\f\r ]/.test(str.slice(0, numWhitespace))) {
-    return null;
-  }
-  const parsed = parseFloat(str);
-  return isFinite(parsed) ? parsed : null;
-};
-
-// https://infra.spec.whatwg.org/#split-on-ascii-whitespace
-exports.splitOnASCIIWhitespace = (str) => {
-  let position = 0;
-  const tokens = [];
-  while (position < str.length && asciiWhitespaceRe.test(str[position])) {
-    position++;
-  }
-  if (position === str.length) {
-    return tokens;
-  }
-  while (position < str.length) {
-    const start = position;
-    while (position < str.length && !asciiWhitespaceRe.test(str[position])) {
-      position++;
-    }
-    tokens.push(str.slice(start, position));
-    while (position < str.length && asciiWhitespaceRe.test(str[position])) {
-      position++;
-    }
-  }
-  return tokens;
-};
-
-// https://infra.spec.whatwg.org/#split-on-commas
-exports.splitOnCommas = (str) => {
-  let position = 0;
-  const tokens = [];
-  while (position < str.length) {
-    let start = position;
-    while (position < str.length && str[position] !== ",") {
-      position++;
-    }
-    let end = position;
-    while (start < str.length && asciiWhitespaceRe.test(str[start])) {
-      start++;
-    }
-    while (end > start && asciiWhitespaceRe.test(str[end - 1])) {
-      end--;
-    }
-    tokens.push(str.slice(start, end));
-    if (position < str.length) {
-      position++;
-    }
-  }
-  return tokens;
+module.exports = {
+  asciiLowercase
 };

package/package.json

@@ -6,7 +6,7 @@
     "CSSStyleDeclaration",
     "StyleSheet"
   ],
-  "version": "5.3.7",
+  "version": "6.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jsdom/cssstyle.git"
@@ -14,36 +14,26 @@
   "files": [
     "lib/"
   ],
-  "main": "./lib/CSSStyleDeclaration.js",
+  "main": "./lib/index.js",
   "dependencies": {
     "@asamuzakjp/css-color": "^4.1.1",
-    "@csstools/css-syntax-patches-for-csstree": "^1.0.21",
+    "@csstools/css-syntax-patches-for-csstree": "^1.0.26",
     "css-tree": "^3.1.0",
-    "lru-cache": "^11.2.4"
+    "lru-cache": "^11.2.5"
   },
   "devDependencies": {
-    "@babel/generator": "^7.28.5",
-    "@babel/parser": "^7.28.5",
-    "@babel/traverse": "^7.28.5",
-    "@babel/types": "^7.28.5",
-    "@domenic/eslint-config": "^4.0.1",
-    "@webref/css": "^8.1.1",
-    "eslint": "^9.39.1",
+    "@domenic/eslint-config": "^4.1.0",
+    "@webref/css": "^8.2.3",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "globals": "^16.5.0",
-    "npm-run-all": "^4.1.5",
-    "prettier": "^3.7.4",
-    "resolve": "^1.22.11"
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "prettier": "^3.8.1"
   },
   "scripts": {
-    "download": "node ./scripts/downloadLatestProperties.mjs",
     "lint": "eslint --max-warnings 0",
     "lint:fix": "eslint --fix --max-warnings 0",
-    "prepare": "run-p prepare:*",
-    "prepare:implemented_properties": "node ./scripts/generateImplementedProperties.mjs",
-    "prepare:properties": "node ./scripts/generateProperties.js",
-    "prepare:propertyDefinitions": "node ./scripts/generatePropertyDefinitions.mjs",
+    "prepare": "node ./scripts/prepare.mjs",
     "test": "node --test"
   },
   "license": "MIT",