postcss-discard-unused 8.0.2 → 8.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-discard-unused",
-  "version": "8.0.2",
+  "version": "8.0.4",
   "description": "Discard unused counter styles, keyframes and fonts.",
   "exports": {
     ".": {
@@ -34,10 +34,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "cssnano/cssnano"
+    "url": "git+https://github.com/cssnano/cssnano.git"
   },
   "dependencies": {
-    "postcss-selector-parser": "^7.1.4"
+    "postcss-selector-parser": "^7.1.5"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
@@ -46,9 +46,12 @@
     "node": "^22.11.0 || ^24.11.0 || >=26.0"
   },
   "devDependencies": {
-    "postcss": "^8.5.25"
+    "postcss": "^8.5.26"
   },
   "peerDependencies": {
-    "postcss": "^8.5.25"
+    "postcss": "^8.5.26"
+  },
+  "scripts": {
+    "test": "node --test"
   }
 }

package/src/index.js

@@ -31,13 +31,13 @@ function splitValues({ value }, comma, space) {
  */
 function filterAtRule({ atRules, values }) {
   const uniqueValues = new Set(values);
-  atRules.forEach((node) => {
+  for (const node of atRules) {
     const hasAtRule = uniqueValues.has(node.params);
 
     if (!hasAtRule) {
       node.remove();
     }
-  });
+  }
 }
 
 /**
@@ -79,7 +79,7 @@ function hasFont(fontFamily, cache, comma) {
  * @return {void}
  */
 function filterFont({ atRules, values }, comma) {
-  values = [...new Set(values)];
+  const uniqueValues = [...new Set(values)];
   for (const r of atRules) {
     if (r.nodes !== undefined) {
       /** @type {import('postcss').Declaration[]} */
@@ -95,7 +95,7 @@ function filterFont({ atRules, values }, comma) {
       }
 
       for (const family of families) {
-        if (!hasFont(family.value.toLowerCase(), values, comma)) {
+        if (!hasFont(family.value.toLowerCase(), uniqueValues, comma)) {
           r.remove();
         }
       }
@@ -118,6 +118,133 @@ function processAttributeSelector(namespaceCache, node) {
 }
 
 /**@typedef {{fontFace?: boolean, counterStyle?: boolean, keyframes?: boolean, namespace?: boolean}} Options */
+
+/**
+ * @param {import('postcss').AnyNode} node
+ * @param {{
+ *   fontFace: boolean,
+ *   counterStyle: boolean,
+ *   keyframes: boolean,
+ *   namespace: boolean,
+ *   counterStyleCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   keyframesCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   namespaceCache: {atRules: import('postcss').AtRule[], rules: (string | true)[]},
+ *   fontCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   comma: (input: string) => string[],
+ *   space: (input: string) => string[],
+ * }} context
+ * @return {void}
+ */
+function processNode(node, context) {
+  if (node.type === rule && context.namespace && node.selector.includes('|')) {
+    processRule(context.namespaceCache, node);
+    return;
+  }
+
+  if (node.type === decl) {
+    processDeclaration(node, context);
+    return;
+  }
+
+  if (node.type === atrule) {
+    processAtRule(node, context);
+  }
+}
+
+/**
+ * @param {{atRules: import('postcss').AtRule[], rules: (string | true)[]}} namespaceCache
+ * @param {import('postcss').Rule} node
+ * @return {void}
+ */
+function processRule(namespaceCache, node) {
+  if (node.selector.includes('[')) {
+    // Attribute selector, so we should parse further.
+    processAttributeSelector(namespaceCache, node);
+  } else {
+    // Use a simple split function for the namespace
+    namespaceCache.rules = namespaceCache.rules.concat(
+      node.selector.split('|')[0]
+    );
+  }
+}
+
+/**
+ * @param {import('postcss').Declaration} node
+ * @param {{
+ *   fontFace: boolean,
+ *   counterStyle: boolean,
+ *   keyframes: boolean,
+ *   namespace: boolean,
+ *   counterStyleCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   keyframesCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   namespaceCache: {atRules: import('postcss').AtRule[], rules: (string | true)[]},
+ *   fontCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   comma: (input: string) => string[],
+ *   space: (input: string) => string[],
+ * }} context
+ * @return {void}
+ */
+function processDeclaration(node, context) {
+  const { prop } = node;
+  if (context.counterStyle && listStyleRegex.test(prop)) {
+    context.counterStyleCache.values = context.counterStyleCache.values.concat(
+      splitValues(node, context.comma, context.space)
+    );
+  }
+
+  if (
+    context.fontFace &&
+    node.parent !== undefined &&
+    node.parent.type === rule &&
+    fontRegex.test(prop)
+  ) {
+    context.fontCache.values = context.fontCache.values.concat(
+      context.comma(node.value.toLowerCase())
+    );
+  }
+
+  if (context.keyframes && animationRegex.test(prop)) {
+    context.keyframesCache.values = context.keyframesCache.values.concat(
+      splitValues(node, context.comma, context.space)
+    );
+  }
+}
+
+/**
+ * @param {import('postcss').AtRule} node
+ * @param {{
+ *   fontFace: boolean,
+ *   counterStyle: boolean,
+ *   keyframes: boolean,
+ *   namespace: boolean,
+ *   counterStyleCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   keyframesCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   namespaceCache: {atRules: import('postcss').AtRule[], rules: (string | true)[]},
+ *   fontCache: {atRules: import('postcss').AtRule[], values: string[]},
+ *   comma: (input: string) => string[],
+ *   space: (input: string) => string[],
+ * }} context
+ * @return {void}
+ */
+function processAtRule(node, context) {
+  const { name } = node;
+  if (context.counterStyle && counterStyleRegex.test(name)) {
+    context.counterStyleCache.atRules.push(node);
+  }
+
+  if (context.fontFace && name === 'font-face' && node.nodes) {
+    context.fontCache.atRules.push(node);
+  }
+
+  if (context.keyframes && keyframesRegex.test(name)) {
+    context.keyframesCache.atRules.push(node);
+  }
+
+  if (context.namespace && name === 'namespace') {
+    context.namespaceCache.atRules.push(node);
+  }
+}
+
 /**
  * @param {Options} opts
  * @return {import('postcss').Plugin}
@@ -154,68 +281,20 @@ function pluginCreator(opts) {
          */
         OnceExit(css, { list }) {
           const { comma, space } = list;
+          const context = {
+            fontFace,
+            counterStyle,
+            keyframes,
+            namespace,
+            counterStyleCache,
+            keyframesCache,
+            namespaceCache,
+            fontCache,
+            comma,
+            space,
+          };
           css.walk((node) => {
-            const { type } = node;
-
-            if (type === rule && namespace && node.selector.includes('|')) {
-              if (node.selector.includes('[')) {
-                // Attribute selector, so we should parse further.
-                processAttributeSelector(namespaceCache, node);
-              } else {
-                // Use a simple split function for the namespace
-                namespaceCache.rules = namespaceCache.rules.concat(
-                  node.selector.split('|')[0]
-                );
-              }
-              return;
-            }
-
-            if (type === decl) {
-              const { prop } = node;
-              if (counterStyle && listStyleRegex.test(prop)) {
-                counterStyleCache.values = counterStyleCache.values.concat(
-                  splitValues(node, comma, space)
-                );
-              }
-
-              if (
-                fontFace &&
-                node.parent !== undefined &&
-                node.parent.type === rule &&
-                fontRegex.test(prop)
-              ) {
-                fontCache.values = fontCache.values.concat(
-                  comma(node.value.toLowerCase())
-                );
-              }
-
-              if (keyframes && animationRegex.test(prop)) {
-                keyframesCache.values = keyframesCache.values.concat(
-                  splitValues(node, comma, space)
-                );
-              }
-
-              return;
-            }
-
-            if (type === atrule) {
-              const { name } = node;
-              if (counterStyle && counterStyleRegex.test(name)) {
-                counterStyleCache.atRules.push(node);
-              }
-
-              if (fontFace && name === 'font-face' && node.nodes) {
-                fontCache.atRules.push(node);
-              }
-
-              if (keyframes && keyframesRegex.test(name)) {
-                keyframesCache.atRules.push(node);
-              }
-
-              if (namespace && name === 'namespace') {
-                namespaceCache.atRules.push(node);
-              }
-            }
+            processNode(node, context);
           });
 
           if (counterStyle) {