postcss-discard-unused 8.0.1 → 8.0.3

package/LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (https://beneb.info)
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

package/README.md

@@ -120,7 +120,7 @@ See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTOR
 
 ## License
 
-MIT © [Ben Briggs](http://beneb.info)
+MIT © [Ben Briggs](https://beneb.info)
 
 
 [postcss]: https://github.com/postcss/postcss

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "postcss-discard-unused",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "description": "Discard unused counter styles, keyframes and fonts.",
-  "main": "src/index.js",
-  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./src": "./src/index.js",
+    "./src/index": "./src/index.js",
+    "./src/index.js": "./src/index.js",
+    "./package.json": "./package.json"
+  },
   "files": [
     "LICENSE-MIT",
     "src",
@@ -22,11 +30,14 @@
   "author": {
     "name": "Ben Briggs",
     "email": "beneb.info@gmail.com",
-    "url": "http://beneb.info"
+    "url": "https://beneb.info"
+  },
+  "repository": {
+    "type": "git",
+    "url": "cssnano/cssnano"
   },
-  "repository": "cssnano/cssnano",
   "dependencies": {
-    "postcss-selector-parser": "^7.1.2"
+    "postcss-selector-parser": "^7.1.5"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
@@ -35,9 +46,12 @@
     "node": "^22.11.0 || ^24.11.0 || >=26.0"
   },
   "devDependencies": {
-    "postcss": "^8.5.15"
+    "postcss": "^8.5.26"
   },
   "peerDependencies": {
-    "postcss": "^8.5.15"
+    "postcss": "^8.5.26"
+  },
+  "scripts": {
+    "test": "node --test"
   }
 }

package/src/index.js

@@ -4,6 +4,12 @@ const selectorParser = require('postcss-selector-parser');
 const atrule = 'atrule';
 const decl = 'decl';
 const rule = 'rule';
+const animationRegex = /animation/;
+const listStyleRegex = /list-style|system/;
+const fontRegex = /font(|-family)/;
+const counterStyleRegex = /counter-style/;
+const keyframesRegex = /keyframes/;
+
 /**
  * @param {{value: string}} arg
  * @param {(input: string) => string[]} comma
@@ -25,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();
     }
-  });
+  }
 }
 
 /**
@@ -65,7 +71,7 @@ function hasFont(fontFamily, cache, comma) {
   return comma(fontFamily).some((font) => cache.some((c) => c.includes(font)));
 }
 
-/** 
+/**
  * fonts have slightly different logic
 
  * @param {{atRules: import('postcss').AtRule[], values: string[]}} cache
@@ -97,9 +103,149 @@ function filterFont({ atRules, values }, comma) {
   }
 }
 
+/**
+ *
+ * @param {{atRules: import('postcss').AtRule[], rules: (string | true)[]}} namespaceCache
+ * @param {import('postcss').Rule} node
+ * @return {void}
+ */
+function processAttributeSelector(namespaceCache, node) {
+  selectorParser((ast) => {
+    ast.walkAttributes(({ namespace: ns }) => {
+      namespaceCache.rules = namespaceCache.rules.concat(ns);
+    });
+  }).process(node.selector);
+}
+
 /**@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);
+  }
+}
+
 /**
- * @type {import('postcss').PluginCreator<Options>}
  * @param {Options} opts
  * @return {import('postcss').Plugin}
  */
@@ -129,82 +275,40 @@ function pluginCreator(opts) {
       const fontCache = { atRules: [], values: [] };
 
       return {
+        /**
+         * @param {import('postcss').Root} css
+         * @param {import('postcss').Helpers} helpers
+         */
         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.
-                selectorParser((ast) => {
-                  ast.walkAttributes(({ namespace: ns }) => {
-                    namespaceCache.rules = namespaceCache.rules.concat(ns);
-                  });
-                }).process(node.selector);
-              } 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 && /list-style|system/.test(prop)) {
-                counterStyleCache.values = counterStyleCache.values.concat(
-                  splitValues(node, comma, space)
-                );
-              }
-
-              if (
-                fontFace &&
-                node.parent !== undefined &&
-                node.parent.type === rule &&
-                /font(|-family)/.test(prop)
-              ) {
-                fontCache.values = fontCache.values.concat(
-                  comma(node.value.toLowerCase())
-                );
-              }
-
-              if (keyframes && /animation/.test(prop)) {
-                keyframesCache.values = keyframesCache.values.concat(
-                  splitValues(node, comma, space)
-                );
-              }
-
-              return;
-            }
-
-            if (type === atrule) {
-              const { name } = node;
-              if (counterStyle && /counter-style/.test(name)) {
-                counterStyleCache.atRules.push(node);
-              }
-
-              if (fontFace && name === 'font-face' && node.nodes) {
-                fontCache.atRules.push(node);
-              }
-
-              if (keyframes && /keyframes/.test(name)) {
-                keyframesCache.atRules.push(node);
-              }
-
-              if (namespace && name === 'namespace') {
-                namespaceCache.atRules.push(node);
-              }
-
-              return;
-            }
+            processNode(node, context);
           });
 
-          counterStyle && filterAtRule(counterStyleCache);
-          fontFace && filterFont(fontCache, comma);
-          keyframes && filterAtRule(keyframesCache);
-          namespace && filterNamespace(namespaceCache);
+          if (counterStyle) {
+            filterAtRule(counterStyleCache);
+          }
+          if (fontFace) {
+            filterFont(fontCache, comma);
+          }
+          if (keyframes) {
+            filterAtRule(keyframesCache);
+          }
+          if (namespace) {
+            filterNamespace(namespaceCache);
+          }
         },
       };
     },
@@ -212,4 +316,6 @@ function pluginCreator(opts) {
 }
 
 pluginCreator.postcss = true;
-module.exports = pluginCreator;
+module.exports = /** @type {import('postcss').PluginCreator<Options>}*/ (
+  pluginCreator
+);

package/types/index.d.ts

@@ -1,16 +1,6 @@
-export = pluginCreator;
-/**@typedef {{fontFace?: boolean, counterStyle?: boolean, keyframes?: boolean, namespace?: boolean}} Options */
-/**
- * @type {import('postcss').PluginCreator<Options>}
- * @param {Options} opts
- * @return {import('postcss').Plugin}
- */
-declare function pluginCreator(opts: Options): import("postcss").Plugin;
-declare namespace pluginCreator {
-    export { postcss, Options };
-}
-declare var postcss: true;
-type Options = {
+declare const _exports: import("postcss").PluginCreator<Options>;
+export = _exports;
+export type Options = {
     fontFace?: boolean;
     counterStyle?: boolean;
     keyframes?: boolean;

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AAmGA,+GAA+G;AAC/G;;;;GAIG;AACH,qCAHW,OAAO,GACN,OAAO,SAAS,EAAE,MAAM,CA4GnC;;;;;eAhHY;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;AAuHG,YAAkG,OAAO,GAA/F;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAC,CAAS"}