postcss-discard-unused 5.0.3 → 5.1.0

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "postcss-discard-unused",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "Discard unused counter styles, keyframes and fonts.",
   "main": "src/index.js",
+  "types": "types/index.d.ts",
   "files": [
     "LICENSE-MIT",
-    "src"
+    "src",
+    "types"
   ],
   "keywords": [
     "css",

package/src/index.js

@@ -11,6 +11,7 @@ const rule = 'rule';
  * @return {string[]}
  */
 function splitValues({ value }, comma, space) {
+  /** @type {string[]} */
   let result = [];
   for (const val of comma(value)) {
     result = result.concat(space(val));
@@ -18,6 +19,10 @@ function splitValues({ value }, comma, space) {
   return result;
 }
 
+/**
+ * @param {{atRules: import('postcss').AtRule[], values: string[]}} arg
+ * @return {void}
+ */
 function filterAtRule({ atRules, values }) {
   const uniqueValues = new Set(values);
   atRules.forEach((node) => {
@@ -29,6 +34,10 @@ function filterAtRule({ atRules, values }) {
   });
 }
 
+/**
+ * @param {{atRules: import('postcss').AtRule[], rules: (string | true)[]}} arg
+ * @return {void}
+ */
 function filterNamespace({ atRules, rules }) {
   const uniqueRules = new Set(rules);
   atRules.forEach((atRule) => {
@@ -46,15 +55,32 @@ function filterNamespace({ atRules, rules }) {
   });
 }
 
+/**
+ * @param {string} fontFamily
+ * @param {string[]} cache
+ * @param {(input: string) => string[]} comma
+ * @return {boolean}
+ */
 function hasFont(fontFamily, cache, comma) {
   return comma(fontFamily).some((font) => cache.some((c) => c.includes(font)));
 }
 
-// fonts have slightly different logic
+/** 
+ * fonts have slightly different logic
+
+ * @param {{atRules: import('postcss').AtRule[], values: string[]}} cache
+ * @param {(input: string) => string[]} comma
+ * @return {void}
+ */
 function filterFont({ atRules, values }, comma) {
   values = [...new Set(values)];
   atRules.forEach((r) => {
-    const families = r.nodes.filter(({ prop }) => prop === 'font-family');
+    /** @type {import('postcss').Declaration[]} */
+    const families = /** @type {import('postcss').Declaration[]} */ (
+      r.nodes.filter(
+        (node) => node.type === 'decl' && node.prop === 'font-family'
+      )
+    );
 
     // Discard the @font-face if it has no font-family
     if (!families.length) {
@@ -69,6 +95,12 @@ function filterFont({ atRules, values }, comma) {
   });
 }
 
+/**@typedef {{fontFace?: boolean, counterStyle?: boolean, keyframes?: boolean, namespace?: boolean}} Options */
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
 function pluginCreator(opts) {
   const { fontFace, counterStyle, keyframes, namespace } = Object.assign(
     {},
@@ -85,35 +117,40 @@ function pluginCreator(opts) {
     postcssPlugin: 'postcss-discard-unused',
 
     prepare() {
+      /** @type {{atRules: import('postcss').AtRule[], values: string[]}} */
       const counterStyleCache = { atRules: [], values: [] };
+      /** @type {{atRules: import('postcss').AtRule[], values: string[]}} */
       const keyframesCache = { atRules: [], values: [] };
+      /** @type {{atRules: import('postcss').AtRule[], rules: (string | true)[]}} */
       const namespaceCache = { atRules: [], rules: [] };
+      /** @type {{atRules: import('postcss').AtRule[], values: string[]}} */
       const fontCache = { atRules: [], values: [] };
 
       return {
         OnceExit(css, { list }) {
           const { comma, space } = list;
           css.walk((node) => {
-            const { type, prop, selector, name } = node;
+            const { type } = node;
 
-            if (type === rule && namespace && selector.includes('|')) {
-              if (selector.includes('[')) {
+            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(selector);
+                }).process(node.selector);
               } else {
                 // Use a simple split function for the namespace
                 namespaceCache.rules = namespaceCache.rules.concat(
-                  selector.split('|')[0]
+                  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)
@@ -122,6 +159,7 @@ function pluginCreator(opts) {
 
               if (
                 fontFace &&
+                node.parent !== undefined &&
                 node.parent.type === rule &&
                 /font(|-family)/.test(prop)
               ) {
@@ -140,6 +178,7 @@ function pluginCreator(opts) {
             }
 
             if (type === atrule) {
+              const { name } = node;
               if (counterStyle && /counter-style/.test(name)) {
                 counterStyleCache.atRules.push(node);
               }

package/types/index.d.ts

@@ -0,0 +1,18 @@
+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 };
+}
+type Options = {
+    fontFace?: boolean;
+    counterStyle?: boolean;
+    keyframes?: boolean;
+    namespace?: boolean;
+};
+declare var postcss: true;