@zohodesk/client_build_tool 0.0.11-exp.16.0 → 0.0.11-exp.17.0

package/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/specialCases.js

@@ -5,28 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.hackForComposes = hackForComposes;
 exports.removeRuleIfNoNormalSelectors = removeRuleIfNoNormalSelectors;
+
 var _insertBefore = require("./insertBefore");
+
 var _replaceUtils = require("./replaceUtils");
+
 function hackForComposes(rule, hoveredSelectors, params) {
   const {
     Rule
   } = params;
+
   if (hoveredSelectors.length === 0) {
     return;
-  }
-
-  // NOTE: we create Empty Rule with hovered selectors that :hover removed from hover selector
+  } // NOTE: we create Empty Rule with hovered selectors that :hover removed from hover selector
   // Reason: when composes looking for selector it most be at least empty rule other wise composes will throw error.
+
+
   (0, _insertBefore.insertBefore)(rule, new Rule({
     selector: hoveredSelectors.map(_replaceUtils.removeHoverFromSelector).join(',')
   }));
 }
-
 /**
  * NOTE: this function will remove rule if the rule has no normal selectors.
  * @param {Rule} rule
  * @returns
  */
+
+
 function removeRuleIfNoNormalSelectors(normalSelectors, rule) {
   if (normalSelectors.length) {
     // NOTE: removed hovered selectors

package/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/typeCheckUtils.js

@@ -12,31 +12,41 @@ exports.isParentAtRuleContainsParam = isParentAtRuleContainsParam;
 exports.isRule = isRule;
 exports.isRuleNotInsideAtRule = isRuleNotInsideAtRule;
 exports.isSelectorHasHover = isSelectorHasHover;
+
 var _constants = require("./constants");
+
 function isComment(node) {
   return node.type === 'comment';
 }
+
 function isRule(node) {
   return node.type === 'rule';
 }
+
 function isMediaQuery(node) {
   return node.name === 'media';
 }
+
 function isAtRule(node) {
   return node.type === 'atrule';
 }
+
 function isAtRuleContainsParam(atRule, content) {
   return atRule.params.includes(content);
 }
+
 function isParentAtRuleContainsParam(rule, content) {
   return isAtRuleContainsParam(rule.parent, content);
 }
+
 function isParentAtRule(rule) {
   return isAtRule(rule.parent);
 }
+
 function isRuleNotInsideAtRule(node) {
   return isRule(node) && node && !isAtRule(node.parent);
 }
+
 function isSelectorHasHover(selector) {
   return selector.indexOf(_constants.HOVER_NOTATION) !== -1;
 }

package/lib/shared/postcss/custom_postcss_plugins/RTLSplitPlugin.js

@@ -5,24 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.separateRtlAndLtr = separateRtlAndLtr;
 exports.separateSingleDir = separateSingleDir;
+
 var postcss = _interopRequireWildcard(require("postcss"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-/* eslint-disable no-param-reassign */
 
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/* eslint-disable no-param-reassign */
 const oppositeDir = {
   ltr: 'rtl',
   rtl: 'ltr'
 };
+
 function compareSelector(selector1, selector2) {
   // console.log({ selector1, selector2 }, selector1 === selector2);
   return selector1 === selector2;
 }
+
 const directionRegexs = {
   ltr: /\[dir=ltr\]/,
   rtl: /\[dir=rtl\]/
 };
+
 const getRegex = dir => directionRegexs[dir];
+
 const getOppositeRegex = dir => getRegex(oppositeDir[dir]);
+
 function selectorMinifySameDir(selector, direction) {
   // NOTE: if this rule is same dir as current need
   //  then we can just remove that [dir=ltr] or [dir=rtl]
@@ -30,16 +39,18 @@ function selectorMinifySameDir(selector, direction) {
   const regex = getRegex(direction);
   return selector.replace(regex, '').trim();
 }
-
 /**
  * this funtion will remove given rule,
  *  if given selector and it's previous sibiling rule selector  are same
  * current rule properties will move to previous sibiling rule.
  * @param {Rule} rule current rule
  */
+
+
 function mergeIfSameSelector(rule) {
   // NOTE: to merge dublicate selector rules
   const prev = rule.prev();
+
   if (prev && compareSelector(prev.selector, rule.selector)) {
     rule.each(decl => {
       prev.append(decl);
@@ -47,25 +58,27 @@ function mergeIfSameSelector(rule) {
     rule.remove();
   }
 }
-
 /**
  * this funtion will remove given rule,
  *  if given selector and it's previous sibiling rule selector  are same
  * current rule properties will move to previous sibiling rule.
  * @param {Rule} rule current rule
  */
+
+
 function removeIfOppsiteDirRule(rule, direction, rootOptions) {
   // console.log({ rule, type: rule.type });
-  const selectors = rule.selector.split(/\s*,\s*/);
-
-  // NOTE: if we use opposite dir selector as custom override reason,
+  const selectors = rule.selector.split(/\s*,\s*/); // NOTE: if we use opposite dir selector as custom override reason,
   //  and compain normal selector with it, In this  case
   //  we just a have to remove that selector only not full rule
+
   const oppositeDirRegex = getOppositeRegex(direction);
   let remainingSelectors = selectors.filter(selector => !oppositeDirRegex.test(selector));
+
   if (!rootOptions.disableMinifySelector) {
     remainingSelectors = remainingSelectors.map(selector => selectorMinifySameDir(selector, direction));
   }
+
   if (remainingSelectors.length) {
     rule.selector = remainingSelectors.join(', ');
   } else {
@@ -73,14 +86,17 @@ function removeIfOppsiteDirRule(rule, direction, rootOptions) {
     rule.remove();
   }
 }
+
 function removeIfOppsiteDirKeyframe(rule, direction) {
   const name = rule.params;
   const keyFrameDirName = name.slice(name.lastIndexOf('-') + 1);
+
   if (keyFrameDirName === oppositeDir[direction]) {
     // console.log({ m: 'removed', keyFrameName: rule.params });
     rule.remove();
   }
 }
+
 function separateSingleDir(root, direction, rootOptions) {
   root.walkRules(rule => {
     removeIfOppsiteDirRule(rule, direction, rootOptions);
@@ -91,14 +107,15 @@ function separateSingleDir(root, direction, rootOptions) {
   });
   return root;
 }
+
 function separateRtlAndLtr(css, rootOptions) {
   // let processor = postcss([]).process(css);
-  const root = postcss.parse(css);
-  // let { root } = processor;
+  const root = postcss.parse(css); // let { root } = processor;
   // console.log(processor, root);
   // NOTE: I did first rtl then ltr , Because  for ltr I use original root ref
-  const rtlRoot = separateSingleDir(root.clone(), 'rtl', rootOptions);
-  // console.log('############################');
+
+  const rtlRoot = separateSingleDir(root.clone(), 'rtl', rootOptions); // console.log('############################');
+
   const ltrRoot = separateSingleDir(root, 'ltr', rootOptions);
   return {
     ltrRoot,
@@ -106,11 +123,8 @@ function separateRtlAndLtr(css, rootOptions) {
     ltr: ltrRoot.toString(),
     rtl: rtlRoot.toString()
   };
-}
-
-// NOTE: to test in https://astexplorer.net/
+} // NOTE: to test in https://astexplorer.net/
 // you can test with sample input https://astexplorer.net/#/gist/a892a509eb585099355ef53ef094f836/1ca70d5f7af3b88ca4910296e12f118e9712c874
-
 // export default postcss.plugin('postcss-rtl-remove', (options = {}) =>
 //   // Work with options here
 //   root => {
@@ -119,7 +133,6 @@ function separateRtlAndLtr(css, rootOptions) {
 //     // root.append(postcss.comment({ text: 'comment' }));
 //     root.append(postcss.comment({ text: 'this  is  spliting part ' }));
 //     root.append(rtlRoot);
-
 //     //console.log({root, roots:root+""}, root+"")
 //     // Transform CSS AST here
 //   }

package/lib/shared/postcss/custom_postcss_plugins/SelectorReplace.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 /* eslint-disable no-param-reassign */
 var _default = (opts = {}) => {
   // eslint-disable-next-line no-use-before-define
@@ -14,10 +15,12 @@ var _default = (opts = {}) => {
   } = opts;
   return {
     postcssPlugin: 'postcss-selector-replace',
+
     Once(root) {
       root.walkRules(rule => {
         before.forEach((beforeOpt, idx) => {
           const afterOpt = after[idx];
+
           if (typeof beforeOpt === 'string') {
             rule.selector = rule.selector.split(beforeOpt).join(afterOpt);
           } else {
@@ -26,46 +29,60 @@ var _default = (opts = {}) => {
         });
       });
     }
+
   };
 };
+
 exports.default = _default;
+
 function validator(opts) {
   if (!opts || typeof opts !== 'object') {
     throw new Error('Always requires argment');
   }
+
   const {
     before,
     after
   } = opts;
+
   if (!before || !after) {
     throw new Error('Be sure to have "before" and "after" object names');
   }
+
   if (!Array.isArray(before) || !Array.isArray(after)) {
     throw new Error('Objects "before" and "after" must be of type Array');
   }
+
   if (before.length !== after.length) {
     throw new Error('Length of before and after options must be the same');
   }
+
   if (before.length === 0) {
     throw new Error('Array length is 1 or more');
   }
+
   before.forEach((beforeOpt, idx) => {
     const afterOpt = after[idx];
+
     switch (true) {
       case typeof beforeOpt === 'string':
         {
           if (!typeof afterOpt === 'string') {
             throw new Error(`The after option ${afterOpt} must be a string. If you want to apply the replace callback function, then use a RegExp for the before option`);
           }
+
           break;
         }
+
       case beforeOpt instanceof RegExp:
         {
           if (!typeof afterOpt === 'string' && !typeof afterOpt === 'function') {
             throw new Error(`The after option ${afterOpt} must be either a string, or a function`);
           }
+
           break;
         }
+
       default:
         throw new Error(`The before option ${beforeOpt} must be either a string, or a RegExp`);
     }

package/lib/shared/postcss/custom_postcss_plugins/ValueReplacer.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-const diffBasedOnStrLength = (a, b) => b.length - a.length;
 
+const diffBasedOnStrLength = (a, b) => b.length - a.length;
 /**
  * @param {Array} valueReplacer 
  * [
@@ -17,12 +17,15 @@ const diffBasedOnStrLength = (a, b) => b.length - a.length;
       }
     ]
  */
+
+
 const PostcssValueReplacer = (valueReplacer = []) => {
   const options = {};
   valueReplacer.forEach(obj => {
     obj.props.forEach(prop => {
       const valueKeys = Object.keys(obj.values);
       const propOptions = options[prop];
+
       if (options[prop]) {
         valueKeys.forEach(k => {
           propOptions.values[k] = obj.values[k];
@@ -35,8 +38,8 @@ const PostcssValueReplacer = (valueReplacer = []) => {
         };
       }
     });
-  });
-  // Work with options here
+  }); // Work with options here
+
   return {
     postcssPlugin: 'postcss-value-replacer',
     Declaration: decl => {
@@ -48,5 +51,7 @@ const PostcssValueReplacer = (valueReplacer = []) => {
     }
   };
 };
+
 PostcssValueReplacer.postcss = true;
-var _default = exports.default = PostcssValueReplacer;
+var _default = PostcssValueReplacer;
+exports.default = _default;

package/lib/shared/postcss/custom_postcss_plugins/VariableModificationPlugin/index.js

@@ -4,10 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var _fs = _interopRequireDefault(require("fs"));
+
 var _path = _interopRequireDefault(require("path"));
+
 var _ErrorHandler = require("../../../bundler/webpack/custom_plugins/VariableConversionCollector/ErrorHandler");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const convertableProps = {
   'font-size': true,
   margin: true,
@@ -52,30 +57,35 @@ const constantValues = {
   center: true,
   right: true
 };
+
 function getNumericValue(value) {
   if (value.includes('var')) {
     return parseInt(value.replace(/var\(--zd_size(\d+)\)/gi, '$1').replace(/var\(--zd_font_size(\d+)\)/gi, '$1'));
   }
+
   if (value.includes('rect')) {
     return parseInt(value.replace('rect(', '').replace(')', '').replace(',', ''));
-  }
-  // Not need for this dum loop
+  } // Not need for this dum loop
   // allowed.forEach(alwdUnit => {
   //   if (value.includes(alwdUnit)) {
   //     return parseInt(value);
   //   }
   // });
 
+
   if (constantValues[value.toLowerCase()]) {
     return 1;
   }
+
   return parseInt(value);
 }
+
 function pxToCalc(value) {
   const arr = value.split(' ');
   arr.forEach((val, index) => {
     ['px'].forEach(unit => {
       const valWithUnit = new RegExp(`(\\d+)${unit}`, 'gi');
+
       if (valWithUnit.test(val)) {
         arr[index] = val.replace(valWithUnit, '(var(--zd_size$1))');
       }
@@ -83,31 +93,38 @@ function pxToCalc(value) {
   });
   return arr.join(' ');
 }
+
 const singleConvertor = (value, changeVal, details, range) => {
   const {
     path,
     filename,
     decl
   } = details;
+
   if (decl.prop === 'background-position') {
     if (isNaN(parseInt(value))) {
       // console.log(`${value} skipped`);
       return;
     }
   }
+
   if (value == '0px') {
     value = value.replace('px', '');
   }
+
   if (getNumericValue(value) >= range.start && getNumericValue(value) <= range.end || getNumericValue(value) === 0) {
     let retVal = value.replace(/(\d+)px/gi, changeVal.replace('$$', '$1'));
+
     if (/^-var/.test(retVal)) {
       retVal = `calc( ${retVal.substring(1)} * -1 )`;
     }
+
     return retVal;
-  }
-  // if (!value.includes('rect')) {
+  } // if (!value.includes('rect')) {
   // if(unitErrorVal && unitErrorVal != '0' ){
   // console.log(value, 'not within range')
+
+
   const errObj = {
     decl,
     type: 'RANGE_ERROR',
@@ -115,9 +132,10 @@ const singleConvertor = (value, changeVal, details, range) => {
     message: `value (${value}) (${typeof value}) not within range (${range.start},${range.end})\r`,
     path
   };
+
   _ErrorHandler.errHandler.errorTable.push(errObj);
-  _ErrorHandler.errHandler.errorFunction(errObj);
-  // errorFunction(
+
+  _ErrorHandler.errHandler.errorFunction(errObj); // errorFunction(
   //   {
   //     decl,
   //     type: 'RANGE_ERROR',
@@ -135,20 +153,24 @@ const singleConvertor = (value, changeVal, details, range) => {
   // } else {
   //   console.log('++++++++++++++++++++++rect val!', value);
   // }
+
 };
+
 var _default = ({
   configFile
 }) => {
   const rawdata = _fs.default.readFileSync(configFile);
+
   const data = JSON.parse(rawdata);
   const {
     errorsAllowed,
-    settings: settingsObject
-    // errorLog: errorLogStatus,
+    settings: settingsObject // errorLog: errorLogStatus,
     // errorInConsole: errorConsoleStatus
-  } = data;
-  // const keys = Object.keys(settingsObject);
+
+  } = data; // const keys = Object.keys(settingsObject);
+
   _ErrorHandler.errHandler.setAllowedErrs(errorsAllowed);
+
   const replacementArray = [];
   Object.keys(settingsObject).forEach(key => {
     Object.values(settingsObject[key].replacements).forEach(val => {
@@ -176,12 +198,12 @@ var _default = ({
           // case font-size
           const commentStr = 'variable:ignore';
           const prevNode = rule.nodes[position - 1];
-          const fromPath = rootOriginal.source.input.from;
-          // this will be problem for linux and mac use require('path').sep
+          const fromPath = rootOriginal.source.input.from; // this will be problem for linux and mac use require('path').sep
           // split not need use slice and lastIndexOf less memory
-          const filename = fromPath.split(_path.default.sep).pop();
-          // if(filename.includes('AddFormResponsive.module.css'){
+
+          const filename = fromPath.split(_path.default.sep).pop(); // if(filename.includes('AddFormResponsive.module.css'){
           // }
+
           if (prevNode && prevNode.type === 'comment' && prevNode.text.toLowerCase().includes(commentStr)) {
             const errObj = {
               decl,
@@ -190,31 +212,33 @@ var _default = ({
               message: 'Declaration Ignored',
               path: fromPath
             };
+
             _ErrorHandler.errHandler.errorTable.push(errObj);
+
             _ErrorHandler.errHandler.DECLARATION_IGNORED(errObj);
+
             return;
           }
+
           if (settingsObject[decl.prop] && !decl.value.includes('var(--')) {
-            const settings = settingsObject[decl.prop];
-            // console.log(settings)
+            const settings = settingsObject[decl.prop]; // console.log(settings)
+
             const {
               allowed,
               range
-            } = settings;
-            // suggestion filter  !decl.value.includes('calc')
+            } = settings; // suggestion filter  !decl.value.includes('calc')
             // Reason below some of logic happen based on this
-            const unit = decl.value.toString()
-            // no need round braket since you do not need group for less memory
-            .replace(/\d+/gi, '').replace('var(--zd_size)', 'px').replace('var(--zd_font_size)', 'px').replace('rect(', '').replace(')', '').replace('px,', 'px').replace(',', '').split(' ').filter(x => x !== '');
-            // unit = unit.replace(unit, unit.replace('-',''))
+
+            const unit = decl.value.toString() // no need round braket since you do not need group for less memory
+            .replace(/\d+/gi, '').replace('var(--zd_size)', 'px').replace('var(--zd_font_size)', 'px').replace('rect(', '').replace(')', '').replace('px,', 'px').replace(',', '').split(' ').filter(x => x !== ''); // unit = unit.replace(unit, unit.replace('-',''))
             // console.log('unit : ');
             // console.log(unit);
+
             unit.forEach((val, index) => {
               allowed.forEach(alwdVal => {
                 if (val.includes(alwdVal)) {
                   // ## for what purpose
-                  unit[index] = val
-                  // .replace(new RegExp('(\\d+).(\\d+)(\\w+)', 'gi'), '$3')
+                  unit[index] = val // .replace(new RegExp('(\\d+).(\\d+)(\\w+)', 'gi'), '$3')
                   .replace(`-${alwdVal}`, `${alwdVal}`).replace(`-.${alwdVal}`, `${alwdVal}`).replace(`${alwdVal},`, `${alwdVal}`);
                 }
               });
@@ -228,8 +252,8 @@ var _default = ({
                   unitErrorVal = val;
                 }
               }
-            });
-            // console.log(allowed, replacements, range)
+            }); // console.log(allowed, replacements, range)
+
             if (!unitError) {
               // use variable decl.value.split(' ')
               if (range) {
@@ -252,20 +276,27 @@ var _default = ({
                 unitErrorVal,
                 path: fromPath
               };
+
               if (unitErrorVal.trim() === '.') {
                 errObj.type = 'DECIMAL_CHECK';
                 errObj.message = `${unitErrorVal} (Decimal Value) Please check`;
+
                 _ErrorHandler.errHandler.errorTable.push(errObj);
+
                 _ErrorHandler.errHandler.DECIMAL_CHECK(errObj);
               } else if (unitErrorVal.includes('.') && !unitErrorVal.includes('%')) {
                 errObj.type = 'DECIMAL_REJECT';
                 errObj.message = `${unitErrorVal} (Decimal Value) Not Allowed \r`;
+
                 _ErrorHandler.errHandler.errorTable.push(errObj);
+
                 _ErrorHandler.errHandler.DECIMAL_REJECT(errObj);
               } else if (!unitErrorVal.includes('%')) {
                 errObj.type = 'UNIT_ERROR';
                 errObj.message = `${unitErrorVal} (Unit) Not Allowed`;
+
                 _ErrorHandler.errHandler.errorTable.push(errObj);
+
                 _ErrorHandler.errHandler.UNIT_ERROR(errObj);
               }
             } else {
@@ -287,10 +318,12 @@ var _default = ({
                   }, range);
                   return convertedVal || val;
                 }
+
                 return val;
               });
               decl.value = convertedVals.join(' ');
             }
+
             if (decl.prop && decl.value && !decl.prop.includes('--') && valRegex.test(decl.value) && (settingsObject[decl.prop] || convertableProps[decl.prop]) && decl.value.includes('var') && !decl.value.includes('calc')) {
               const errObj = {
                 decl,
@@ -299,7 +332,9 @@ var _default = ({
                 message: `value (${decl.value}) has var in it, kindly check`,
                 path: fromPath
               };
+
               _ErrorHandler.errHandler.errorTable.push(errObj);
+
               _ErrorHandler.errHandler.VARIABLE_PRESENT(errObj);
             }
           }
@@ -308,4 +343,5 @@ var _default = ({
     }
   };
 };
+
 exports.default = _default;

package/lib/shared/postcss/filterPluginsAllowedForSpecficFile.js

@@ -7,41 +7,49 @@ exports.filterCustomPluginsAllowedForSpecificFile = filterCustomPluginsAllowedFo
 exports.filterPluginsAllowedForSpecificFile = filterPluginsAllowedForSpecificFile;
 exports.getEnabledPlugins = getEnabledPlugins;
 exports.mapDefaultSupportedPlugins = mapDefaultSupportedPlugins;
+
 var _checkIsPatternsMatchFilename = require("../bundler/webpack/loaderConfigs/checkIsPatternsMatchFilename");
+
 var _getSpecificPostCssPlugin = require("./getSpecificPostCssPlugin");
-/* eslint-disable no-use-before-define */
 
+/* eslint-disable no-use-before-define */
 function mapDefaultSupportedPlugins(pluginsOptions) {
-  return _getSpecificPostCssPlugin.supportedPluginsOptionNames.map(pluginName => ({
-    ...pluginsOptions[pluginName],
+  return _getSpecificPostCssPlugin.supportedPluginsOptionNames.map(pluginName => ({ ...pluginsOptions[pluginName],
     pluginName
   }));
 }
+
 function getEnabledPlugins(pluginsOptions) {
   function isEnabled(pluginName) {
     return pluginsOptions[pluginName].enable;
   }
-  return _getSpecificPostCssPlugin.supportedPluginsOptionNames.filter(isEnabled).map(pluginName => ({
-    ...pluginsOptions[pluginName],
+
+  return _getSpecificPostCssPlugin.supportedPluginsOptionNames.filter(isEnabled).map(pluginName => ({ ...pluginsOptions[pluginName],
     pluginName
   }));
 }
+
 function filterPluginsAllowedForSpecificFile(plugins, filename) {
   return plugins.filter(pluginOption => checkIsPluginAllowed(pluginOption, filename)).map(pluginOption => (0, _getSpecificPostCssPlugin.getSpecificPostCssPlugin)(pluginOption)).filter(Boolean);
 }
+
 function checkIsPluginAllowed(pluginOption, filename) {
   return (0, _checkIsPatternsMatchFilename.checkIsPatternsMatchFilename)(pluginOption.patterns, filename);
 }
+
 function getCustomPlugins(pluginOption) {
   if (typeof pluginOption.plugin === 'string') {
     // eslint-disable-next-line import/no-dynamic-require, global-require
     return require(pluginOption.plugin).plugin(pluginOption);
   }
+
   if (typeof pluginOption.plugin === 'function') {
     return pluginOption.plugin(pluginOption);
   }
+
   return null;
 }
+
 function filterCustomPluginsAllowedForSpecificFile(customPlugins, filename) {
   return customPlugins.filter(pluginOption => checkIsPluginAllowed(pluginOption, filename)).map(getCustomPlugins).filter(Boolean);
 }