cssnano-preset-default 6.0.4 → 6.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cssnano-preset-default",
-  "version": "6.0.4",
+  "version": "6.1.0",
   "main": "src/index.js",
   "types": "types/index.d.ts",
   "description": "Safe defaults for cssnano which require minimal configuration.",
@@ -11,35 +11,36 @@
   ],
   "license": "MIT",
   "dependencies": {
+    "browserslist": "^4.23.0",
     "css-declaration-sorter": "^7.1.1",
     "postcss-calc": "^9.0.1",
-    "cssnano-utils": "^4.0.1",
-    "postcss-colormin": "^6.0.2",
-    "postcss-convert-values": "^6.0.3",
-    "postcss-discard-comments": "^6.0.1",
-    "postcss-discard-duplicates": "^6.0.2",
-    "postcss-discard-empty": "^6.0.2",
-    "postcss-discard-overridden": "^6.0.1",
-    "postcss-merge-longhand": "^6.0.2",
-    "postcss-merge-rules": "^6.0.3",
-    "postcss-minify-font-values": "^6.0.1",
-    "postcss-minify-gradients": "^6.0.1",
-    "postcss-minify-params": "^6.0.2",
-    "postcss-minify-selectors": "^6.0.2",
-    "postcss-normalize-charset": "^6.0.1",
-    "postcss-normalize-display-values": "^6.0.1",
-    "postcss-normalize-positions": "^6.0.1",
-    "postcss-normalize-repeat-style": "^6.0.1",
-    "postcss-normalize-string": "^6.0.1",
-    "postcss-normalize-timing-functions": "^6.0.1",
-    "postcss-normalize-unicode": "^6.0.2",
-    "postcss-normalize-url": "^6.0.1",
-    "postcss-normalize-whitespace": "^6.0.1",
-    "postcss-ordered-values": "^6.0.1",
-    "postcss-reduce-initial": "^6.0.2",
-    "postcss-reduce-transforms": "^6.0.1",
-    "postcss-svgo": "^6.0.2",
-    "postcss-unique-selectors": "^6.0.2"
+    "cssnano-utils": "^4.0.2",
+    "postcss-colormin": "^6.1.0",
+    "postcss-convert-values": "^6.1.0",
+    "postcss-discard-comments": "^6.0.2",
+    "postcss-discard-duplicates": "^6.0.3",
+    "postcss-discard-empty": "^6.0.3",
+    "postcss-discard-overridden": "^6.0.2",
+    "postcss-merge-longhand": "^6.0.4",
+    "postcss-merge-rules": "^6.1.0",
+    "postcss-minify-font-values": "^6.0.3",
+    "postcss-minify-gradients": "^6.0.3",
+    "postcss-minify-params": "^6.1.0",
+    "postcss-minify-selectors": "^6.0.3",
+    "postcss-normalize-charset": "^6.0.2",
+    "postcss-normalize-display-values": "^6.0.2",
+    "postcss-normalize-positions": "^6.0.2",
+    "postcss-normalize-repeat-style": "^6.0.2",
+    "postcss-normalize-string": "^6.0.2",
+    "postcss-normalize-timing-functions": "^6.0.2",
+    "postcss-normalize-unicode": "^6.1.0",
+    "postcss-normalize-url": "^6.0.2",
+    "postcss-normalize-whitespace": "^6.0.2",
+    "postcss-ordered-values": "^6.0.2",
+    "postcss-reduce-initial": "^6.1.0",
+    "postcss-reduce-transforms": "^6.0.2",
+    "postcss-svgo": "^6.0.3",
+    "postcss-unique-selectors": "^6.0.3"
   },
   "author": {
     "name": "Ben Briggs",

package/src/index.js

@@ -43,89 +43,153 @@ const postcssNormalizeDisplayValues = require('postcss-normalize-display-values'
 const postcssNormalizeTimingFunctions = require('postcss-normalize-timing-functions');
 const { rawCache } = require('cssnano-utils');
 
-/** @typedef {{
-discardComments?: false | import('postcss-discard-comments').Options & { exclude?: true},
-reduceInitial?:  false | { exclude?: true}
-minifyGradients?:  false | { exclude?: true}
-svgo?: false | import('postcss-svgo').Options & { exclude?: true},
-reduceTransforms?:  false | { exclude?: true}
-convertValues?: false | import('postcss-convert-values').Options & { exclude?: true},
-calc?: false | import('postcss-calc').PostCssCalcOptions & { exclude?: true},
-colormin?: false | Record<string, any> & { exclude?: true},
-orderedValues?: false | { exclude?: true},
-minifySelectors?: false | { exclude?: true},
-minifyParams?: false | { exclude?: true},
-normalizeCharset?: false | import('postcss-normalize-charset').Options & { exclude?: true},
-minifyFontValues?: false | import('postcss-minify-font-values').Options & { exclude?: true},
-normalizeUrl?: false | { exclude?: true},
-mergeLonghand?: false | { exclude?: true},
-discardDuplicates?: false | { exclude?: true},
-discardOverridden?: false | { exclude?: true},
-normalizeRepeatStyle?: false | { exclude?: true},
-mergeRules?: false | { exclude?: true},
-discardEmpty?: false | { exclude?: true},
-uniqueSelectors?: false | { exclude?: true},
-normalizeString?: false | import('postcss-normalize-string').Options & { exclude?: true},
-normalizePositions?: false | { exclude?: true},
-normalizeWhitespace?: false| { exclude?: true},
-normalizeUnicode?: false | { exclude?: true},
-normalizeDisplayValues?: false | { exclude?: true},
-normalizeTimingFunctions?: false | { exclude?: true},
-rawCache?: false | { exclude?: true}}} Options */
+/**
+ * @template {object | void} [OptionsExtends=void]
+ * @typedef {false | OptionsExtends & {exclude?: true}} SimpleOptions
+ */
+
+/**
+ * @typedef {object} Options
+ * @property {SimpleOptions<Parameters<typeof cssDeclarationSorter>[0]>} [cssDeclarationSorter]
+ * @property {SimpleOptions<import('postcss-discard-comments').Options>} [discardComments]
+ * @property {SimpleOptions<import('postcss-reduce-initial').Options>} [reduceInitial]
+ * @property {SimpleOptions} [minifyGradients]
+ * @property {SimpleOptions<import('postcss-svgo').Options>} [svgo]
+ * @property {SimpleOptions} [reduceTransforms]
+ * @property {SimpleOptions<import('postcss-convert-values').Options>} [convertValues]
+ * @property {SimpleOptions<import('postcss-calc').PostCssCalcOptions>} [calc]
+ * @property {SimpleOptions<import('postcss-colormin').Options>} [colormin]
+ * @property {SimpleOptions} [orderedValues]
+ * @property {SimpleOptions} [minifySelectors]
+ * @property {SimpleOptions<import('postcss-minify-params').Options>} [minifyParams]
+ * @property {SimpleOptions<import('postcss-normalize-charset').Options>} [normalizeCharset]
+ * @property {SimpleOptions<import('postcss-minify-font-values').Options>} [minifyFontValues]
+ * @property {SimpleOptions} [normalizeUrl]
+ * @property {SimpleOptions} [mergeLonghand]
+ * @property {SimpleOptions} [discardDuplicates]
+ * @property {SimpleOptions} [discardOverridden]
+ * @property {SimpleOptions} [normalizeRepeatStyle]
+ * @property {SimpleOptions<import('postcss-merge-rules').Options>} [mergeRules]
+ * @property {SimpleOptions} [discardEmpty]
+ * @property {SimpleOptions} [uniqueSelectors]
+ * @property {SimpleOptions<import('postcss-normalize-string').Options>} [normalizeString]
+ * @property {SimpleOptions} [normalizePositions]
+ * @property {SimpleOptions} [normalizeWhitespace]
+ * @property {SimpleOptions<import('postcss-normalize-unicode').Options>} [normalizeUnicode]
+ * @property {SimpleOptions} [normalizeDisplayValues]
+ * @property {SimpleOptions} [normalizeTimingFunctions]
+ * @property {SimpleOptions} [rawCache]
+ */
 
-const defaultOpts = {
-  convertValues: {
-    length: false,
-  },
-  normalizeCharset: {
-    add: false,
-  },
-  cssDeclarationSorter: {
-    keepOverrides: true,
-  },
-};
+/**
+ * @typedef {{ overrideBrowserslist?: string | string[] }} AutoprefixerOptions
+ * @typedef {Pick<import('browserslist').Options, 'stats' | 'path' | 'env'>} BrowserslistOptions
+ */
 
 /**
- * @param {Options} opts
- * @return {{plugins: [import('postcss').PluginCreator<any>, boolean | Record<string, any> | undefined][]}}
+ * @param {[import('postcss').PluginCreator<any>, keyof Options][]} plugins
+ * @param {Parameters<typeof defaultPreset>[0]} opts
+ * @returns {ReturnType<typeof defaultPreset>["plugins"]}
  */
-function defaultPreset(opts = {}) {
-  const options = Object.assign({}, defaultOpts, opts);
+function configurePlugins(plugins, opts = {}) {
+  const { overrideBrowserslist, stats, env, path } = opts;
 
-  /** @type {[import('postcss').PluginCreator<any>, boolean | Record<string, any> | undefined][]} **/
-  const plugins = [
-    [postcssDiscardComments, options.discardComments],
-    [postcssMinifyGradients, options.minifyGradients],
-    [postcssReduceInitial, options.reduceInitial],
-    [postcssSvgo, options.svgo],
-    [postcssNormalizeDisplayValues, options.normalizeDisplayValues],
-    [postcssReduceTransforms, options.reduceTransforms],
-    [postcssColormin, options.colormin],
-    [postcssNormalizeTimingFunctions, options.normalizeTimingFunctions],
-    [postcssCalc, options.calc],
-    [postcssConvertValues, options.convertValues],
-    [postcssOrderedValues, options.orderedValues],
-    [postcssMinifySelectors, options.minifySelectors],
-    [postcssMinifyParams, options.minifyParams],
-    [postcssNormalizeCharset, options.normalizeCharset],
-    [postcssDiscardOverridden, options.discardOverridden],
-    [postcssNormalizeString, options.normalizeString],
-    [postcssNormalizeUnicode, options.normalizeUnicode],
-    [postcssMinifyFontValues, options.minifyFontValues],
-    [postcssNormalizeUrl, options.normalizeUrl],
-    [postcssNormalizeRepeatStyle, options.normalizeRepeatStyle],
-    [postcssNormalizePositions, options.normalizePositions],
-    [postcssNormalizeWhitespace, options.normalizeWhitespace],
-    [postcssMergeLonghand, options.mergeLonghand],
-    [postcssDiscardDuplicates, options.discardDuplicates],
-    [postcssMergeRules, options.mergeRules],
-    [postcssDiscardEmpty, options.discardEmpty],
-    [postcssUniqueSelectors, options.uniqueSelectors],
-    [cssDeclarationSorter, options.cssDeclarationSorter],
-    [rawCache, options.rawCache],
-  ];
+  // Shared Autoprefixer + Browserslist options
+  const sharedProps = {
+    overrideBrowserslist,
+    stats,
+    env,
+    path,
+  };
 
-  return { plugins };
+  /**
+   * @type {Options}
+   */
+  const defaults = {
+    colormin: {
+      ...sharedProps,
+    },
+    convertValues: {
+      length: false,
+      ...sharedProps,
+    },
+    mergeRules: {
+      ...sharedProps,
+    },
+    minifyParams: {
+      ...sharedProps,
+    },
+    normalizeCharset: {
+      add: false,
+    },
+    normalizeUnicode: {
+      ...sharedProps,
+    },
+    reduceInitial: {
+      ...sharedProps,
+    },
+    cssDeclarationSorter: {
+      keepOverrides: true,
+    },
+  };
+
+  // Merge option properties for each plugin
+  return plugins.map(([plugin, opt]) => {
+    const defaultProps = defaults[opt] ?? {};
+    const presetProps = opts[opt] ?? {};
+
+    return [
+      plugin,
+      presetProps !== false
+        ? { ...defaultProps, ...presetProps }
+        : { exclude: true },
+    ];
+  });
+}
+
+/**
+ * Safe defaults for cssnano which require minimal configuration
+ *
+ * @param {Options & AutoprefixerOptions & BrowserslistOptions} opts
+ * @returns {{ plugins: [import('postcss').PluginCreator<any>, Options[keyof Options]][] }}
+ */
+function defaultPreset(opts = {}) {
+  return {
+    plugins: configurePlugins(
+      [
+        [postcssDiscardComments, 'discardComments'],
+        [postcssMinifyGradients, 'minifyGradients'],
+        [postcssReduceInitial, 'reduceInitial'],
+        [postcssSvgo, 'svgo'],
+        [postcssNormalizeDisplayValues, 'normalizeDisplayValues'],
+        [postcssReduceTransforms, 'reduceTransforms'],
+        [postcssColormin, 'colormin'],
+        [postcssNormalizeTimingFunctions, 'normalizeTimingFunctions'],
+        [postcssCalc, 'calc'],
+        [postcssConvertValues, 'convertValues'],
+        [postcssOrderedValues, 'orderedValues'],
+        [postcssMinifySelectors, 'minifySelectors'],
+        [postcssMinifyParams, 'minifyParams'],
+        [postcssNormalizeCharset, 'normalizeCharset'],
+        [postcssDiscardOverridden, 'discardOverridden'],
+        [postcssNormalizeString, 'normalizeString'],
+        [postcssNormalizeUnicode, 'normalizeUnicode'],
+        [postcssMinifyFontValues, 'minifyFontValues'],
+        [postcssNormalizeUrl, 'normalizeUrl'],
+        [postcssNormalizeRepeatStyle, 'normalizeRepeatStyle'],
+        [postcssNormalizePositions, 'normalizePositions'],
+        [postcssNormalizeWhitespace, 'normalizeWhitespace'],
+        [postcssMergeLonghand, 'mergeLonghand'],
+        [postcssDiscardDuplicates, 'discardDuplicates'],
+        [postcssMergeRules, 'mergeRules'],
+        [postcssDiscardEmpty, 'discardEmpty'],
+        [postcssUniqueSelectors, 'uniqueSelectors'],
+        [cssDeclarationSorter, 'cssDeclarationSorter'],
+        [rawCache, 'rawCache'],
+      ],
+      opts
+    ),
+  };
 }
 
 module.exports = defaultPreset;

package/types/index.d.ts

@@ -1,98 +1,67 @@
 export = defaultPreset;
 /**
- * @param {Options} opts
- * @return {{plugins: [import('postcss').PluginCreator<any>, boolean | Record<string, any> | undefined][]}}
+ * Safe defaults for cssnano which require minimal configuration
+ *
+ * @param {Options & AutoprefixerOptions & BrowserslistOptions} opts
+ * @returns {{ plugins: [import('postcss').PluginCreator<any>, Options[keyof Options]][] }}
  */
-declare function defaultPreset(opts?: Options): {
-    plugins: [import('postcss').PluginCreator<any>, boolean | Record<string, any> | undefined][];
+declare function defaultPreset(opts?: Options & AutoprefixerOptions & BrowserslistOptions): {
+    plugins: [import('postcss').PluginCreator<any>, Options[keyof Options]][];
 };
 declare namespace defaultPreset {
-    export { Options };
+    export { SimpleOptions, Options, AutoprefixerOptions, BrowserslistOptions };
 }
 type Options = {
-    discardComments?: false | import('postcss-discard-comments').Options & {
-        exclude?: true;
-    };
-    reduceInitial?: false | {
-        exclude?: true;
-    };
-    minifyGradients?: false | {
-        exclude?: true;
-    };
-    svgo?: false | import('postcss-svgo').Options & {
-        exclude?: true;
-    };
-    reduceTransforms?: false | {
-        exclude?: true;
-    };
-    convertValues?: false | import('postcss-convert-values').Options & {
-        exclude?: true;
-    };
-    calc?: false | import('postcss-calc').PostCssCalcOptions & {
-        exclude?: true;
-    };
-    colormin?: false | (Record<string, any> & {
-        exclude?: true;
-    });
-    orderedValues?: false | {
-        exclude?: true;
-    };
-    minifySelectors?: false | {
-        exclude?: true;
-    };
-    minifyParams?: false | {
-        exclude?: true;
-    };
-    normalizeCharset?: false | import('postcss-normalize-charset').Options & {
-        exclude?: true;
-    };
-    minifyFontValues?: false | import('postcss-minify-font-values').Options & {
-        exclude?: true;
-    };
-    normalizeUrl?: false | {
-        exclude?: true;
-    };
-    mergeLonghand?: false | {
-        exclude?: true;
-    };
-    discardDuplicates?: false | {
-        exclude?: true;
-    };
-    discardOverridden?: false | {
-        exclude?: true;
-    };
-    normalizeRepeatStyle?: false | {
-        exclude?: true;
-    };
-    mergeRules?: false | {
-        exclude?: true;
-    };
-    discardEmpty?: false | {
-        exclude?: true;
-    };
-    uniqueSelectors?: false | {
-        exclude?: true;
-    };
-    normalizeString?: false | import('postcss-normalize-string').Options & {
-        exclude?: true;
-    };
-    normalizePositions?: false | {
-        exclude?: true;
-    };
-    normalizeWhitespace?: false | {
-        exclude?: true;
-    };
-    normalizeUnicode?: false | {
-        exclude?: true;
-    };
-    normalizeDisplayValues?: false | {
-        exclude?: true;
-    };
-    normalizeTimingFunctions?: false | {
-        exclude?: true;
-    };
-    rawCache?: false | {
-        exclude?: true;
-    };
+    cssDeclarationSorter?: SimpleOptions<{
+        order?: ("alphabetical" | "concentric-css" | "smacss") | ((propertyNameA: string, propertyNameB: string) => 0 | 1 | -1) | undefined;
+        keepOverrides?: boolean | undefined;
+    } | undefined> | undefined;
+    discardComments?: SimpleOptions<postcssDiscardComments.Options> | undefined;
+    reduceInitial?: SimpleOptions<postcssReduceInitial.Options> | undefined;
+    minifyGradients?: SimpleOptions<void> | undefined;
+    svgo?: SimpleOptions<postcssSvgo.Options> | undefined;
+    reduceTransforms?: SimpleOptions<void> | undefined;
+    convertValues?: SimpleOptions<postcssConvertValues.Options> | undefined;
+    calc?: SimpleOptions<postcssCalc.PostCssCalcOptions> | undefined;
+    colormin?: SimpleOptions<postcssColormin.Options> | undefined;
+    orderedValues?: SimpleOptions<void> | undefined;
+    minifySelectors?: SimpleOptions<void> | undefined;
+    minifyParams?: SimpleOptions<postcssMinifyParams.Options> | undefined;
+    normalizeCharset?: SimpleOptions<postcssNormalizeCharset.Options> | undefined;
+    minifyFontValues?: SimpleOptions<postcssMinifyFontValues.Options> | undefined;
+    normalizeUrl?: SimpleOptions<void> | undefined;
+    mergeLonghand?: SimpleOptions<void> | undefined;
+    discardDuplicates?: SimpleOptions<void> | undefined;
+    discardOverridden?: SimpleOptions<void> | undefined;
+    normalizeRepeatStyle?: SimpleOptions<void> | undefined;
+    mergeRules?: SimpleOptions<postcssMergeRules.Options> | undefined;
+    discardEmpty?: SimpleOptions<void> | undefined;
+    uniqueSelectors?: SimpleOptions<void> | undefined;
+    normalizeString?: SimpleOptions<postcssNormalizeString.Options> | undefined;
+    normalizePositions?: SimpleOptions<void> | undefined;
+    normalizeWhitespace?: SimpleOptions<void> | undefined;
+    normalizeUnicode?: SimpleOptions<postcssNormalizeUnicode.Options> | undefined;
+    normalizeDisplayValues?: SimpleOptions<void> | undefined;
+    normalizeTimingFunctions?: SimpleOptions<void> | undefined;
+    rawCache?: SimpleOptions<void> | undefined;
 };
-import { rawCache } from "cssnano-utils";
+type AutoprefixerOptions = {
+    overrideBrowserslist?: string | string[];
+};
+type BrowserslistOptions = Pick<import('browserslist').Options, 'stats' | 'path' | 'env'>;
+type SimpleOptions<OptionsExtends extends void | object = void> = false | (OptionsExtends & {
+    exclude?: true;
+});
+import postcssDiscardComments = require("postcss-discard-comments");
+import postcssReduceInitial = require("postcss-reduce-initial");
+import postcssSvgo = require("postcss-svgo");
+import postcssConvertValues = require("postcss-convert-values");
+import postcssCalc = require("postcss-calc");
+import postcssColormin = require("postcss-colormin");
+import postcssMinifyParams = require("postcss-minify-params");
+import postcssNormalizeCharset = require("postcss-normalize-charset");
+import postcssMinifyFontValues = require("postcss-minify-font-values");
+import postcssMergeRules = require("postcss-merge-rules");
+import postcssNormalizeString = require("postcss-normalize-string");
+import postcssNormalizeUnicode = require("postcss-normalize-unicode");
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AAqJA;;;;;GAKG;AACH,sCAHW,OAAO,GAAG,mBAAmB,GAAG,mBAAmB,GACjD;IAAE,OAAO,EAAE,CAAC,OAAO,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,MAAM,OAAO,CAAC,CAAC,EAAE,CAAA;CAAE,CAuCzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA5GY;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE;2BAC5C,KAAK,OAAO,cAAc,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;kEAtC9D,KAAK,IAAG,cAAc,GAAG;IAAC,OAAO,CAAC,EAAE,IAAI,CAAA;CAAC,CAAA"}