@zohodesk/react-cli 1.1.11-exp.3 → 1.1.11-exp.4

package/packages/client_build_tool/lib/shared/postcss/__test__/postcss-rtl-all-cases.test.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _postcss = _interopRequireDefault(require("postcss"));
+
+var _getSpecificPostCssPlugin = require("../getSpecificPostCssPlugin");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable max-lines */
+
+/* eslint-disable no-use-before-define */
+// import { checkIsPatternsMatchFilename } from '../filterPluginsAllowedForSpecficFile';
+const normalize = cssString => cssString.replace(/} /g, '}');
+/* fix extra space added by `postcss-import` */
+
+
+const run = (expect, input, output, opts) => //   opts && console.log(opts);
+(0, _postcss.default)([(0, _getSpecificPostCssPlugin.configPostCssRtl)(opts)]).process(input, {
+  from: undefined
+}).then(result => {
+  expect(normalize(result.css)).toEqual(normalize(output));
+  expect(result.warnings().length).toEqual(0);
+});
+
+test('Should NOT add [dir] prefix to symmetric rules', () => run(expect, 'a { font-size: 1em }', 'a { font-size: 1em }'));
+test('Should ONLY create LTR & RTL rules to asymmetric rules', () => run(expect, 'a { font-size: 1em; text-align: left }', 'a { font-size: 1em }' + '[dir=ltr] a { text-align: left }' + '[dir=rtl] a { text-align: right }'));
+xtest('Should add [dir] prefix to symmetric rules with direction related declarations', () => run(expect, 'a { text-align: center }', '[dir] a { text-align: center }'));
+xtest('Should add [dir] prefix to symmetric rules with direction related declarations (2)', () => run(expect, 'a { font-size: 1em; text-align: center }', 'a { font-size: 1em }[dir] a { text-align: center }'));
+xtest('Should add [dir] prefix to symmetric rules with direction related declarations (3)', () => run(expect, 'a { text-align: left }a { text-align: center }', '[dir=ltr] a { text-align: left }' + '[dir=rtl] a { text-align: right }' + '[dir] a { text-align: center }'));
+xtest('Should add [dir] prefix to symmetric rules with direction related declarations (4)', () => run(expect, 'a { margin: 0 10px 0 0 }a { margin-top: 20px }', '[dir=ltr] a { margin: 0 10px 0 0 }' + '[dir=rtl] a { margin: 0 0 0 10px }' + '[dir] a { margin-top: 20px }'));
+test('Creates both LTR & RTL rules for asymmetric declarations', () => run(expect, 'a { text-align: left }', '[dir=ltr] a { text-align: left }[dir=rtl] a { text-align: right }'));
+test('Removes original rule without symmetric declarations', () => run(expect, 'a { text-align: left }', '[dir=ltr] a { text-align: left }[dir=rtl] a { text-align: right }'));
+xtest('Adds prefix to the html element', () => run(expect, 'html { text-align: left }', 'html[dir=ltr] { text-align: left }html[dir=rtl] { text-align: right }'));
+xtest('Adds prefix to the html element with class', () => run(expect, 'html.foo { text-align: left }', 'html[dir=ltr].foo { text-align: left }' + 'html[dir=rtl].foo { text-align: right }'));
+test('Adds prefix to the :root element', () => run(expect, ':root { text-align: left }', '[dir=ltr]:root { text-align: left }' + '[dir=rtl]:root { text-align: right }'));
+xtest('Adds prefix to the :root element with class', () => run(expect, ':root.foo { text-align: left }', '[dir=ltr]:root.foo { text-align: left }' + '[dir=rtl]:root.foo { text-align: right }'));
+xtest('Use custom `addPrefixToSelector` function', () => run(expect, 'a { text-align: left }', '[dir=ltr] > a { text-align: left }' + '[dir=rtl] > a { text-align: right }', {
+  addPrefixToSelector(selector, prefix) {
+    return `${prefix} > ${selector}`;
+  }
+
+}));
+test('Should correctly process values containing commas', () => run(expect, // eslint-disable-next-line no-useless-concat
+'div { background: url(\'ht' + 'tp://placecage.com/400/400\') 0 0 }', // eslint-disable-next-line no-useless-concat
+'[dir=ltr] div { background: url(\'ht' + 'tp://placecage.com/400/400\') 0 0 }' + // eslint-disable-next-line no-useless-concat
+'[dir=rtl] div { background: url(\'ht' + 'tp://placecage.com/400/400\') 100% 0 }'));
+test('Should correctly process values containing !important', () => run(expect, '.test { margin-left: 0 !important; padding-left: 0 !important }', '[dir=ltr] .test { margin-left: 0 !important; padding-left: 0 !important }' + '[dir=rtl] .test { margin-right: 0 !important; padding-right: 0 !important }'));
+test('Shouldn not create unnecessary duplications with !important', () => run(expect, '.test { display: none !important }', '.test { display: none !important }'));
+test('Should correctly process values containing _display', () => run(expect, '.test { float: left; _display: inline }', '.test { _display: inline }' + '[dir=ltr] .test { float: left }' + '[dir=rtl] .test { float: right }'));
+test('Should ignore declarations prefixed with /* rtl:ignore */', () => run(expect, '/* rtl:ignore */ .test { margin-left:0; padding-left:0 }', '.test { margin-left:0; padding-left:0 }'));
+test('/* rtl:ignore */: Should leave other selectors alone', () => run(expect, '/* rtl:ignore */ .test { margin-left:0 } ' + '.rtled { margin-left:0; padding-left:0 }', '.test { margin-left:0 } ' + '[dir=ltr] .rtled { margin-left:0; padding-left:0 } ' + '[dir=rtl] .rtled { margin-right:0; padding-right:0 }'));
+test('/* rtl:ignore */: should understand overrides', () => run(expect, '.x { left: 0 } /* rtl:ignore */.x { direction: ltr }', '[dir=ltr] .x { left: 0 }' + '[dir=rtl] .x { right: 0 }' + '.x { direction: ltr }'));
+test('/* rtl:begin:ignore */ starts ignore mode', () => run(expect, '/* rtl:begin:ignore */' + '.foo { padding-left: 0 }' + '.bar { direction: ltr }', '.foo { padding-left: 0 }.bar { direction: ltr }'));
+test('/* rtl:end:ignore */ stops ignore mode', () => run(expect, '/* rtl:begin:ignore */' + '.foo { padding-left: 0 }' + '/* rtl:end:ignore */' + '.bar { direction: ltr }', '.foo { padding-left: 0 }' + '[dir=ltr] .bar { direction: ltr }' + '[dir=rtl] .bar { direction: rtl }'));
+test('/* rtl:ignore */ can be used inside /* rtl:begin:ignore */ and /* rtl:end:ignore */', () => run(expect, '/* rtl:begin:ignore */' + '.foo { padding-left: 0 }' + '/* rtl:ignore */' + '.bar { direction: ltr }' + '.baz { left: 0 }' + '/* rtl:end:ignore */', '.foo { padding-left: 0 }.bar { direction: ltr }.baz { left: 0 }'));
+test('that it ignores normal comments', () => run(expect, '/* some comment */ .foo { padding-left: 0 }', '/* some comment */ [dir=ltr] .foo { padding-left: 0 } [dir=rtl] .foo { padding-right: 0 }'));
+test('Value based ignore comments are honored', () => run(expect, '.foo { margin-left: 12px; padding-left: 12px /* rtl:ignore */; }', '.foo { padding-left: 12px /* rtl:ignore */; }' + '[dir=ltr] .foo { margin-left: 12px; }' + '[dir=rtl] .foo { margin-right: 12px; }'));
+test('/*! rtl:ignore */ should consider as a valid directive', () => run(expect, '/*! rtl:ignore */ .test { margin-left:0; padding-left:0 }', '.test { margin-left:0; padding-left:0 }'));
+test('/*! rtl:begin:ignore */ and /*! rtl:end:ignore */ should consider as a valid directive', () => run(expect, '/*! rtl:begin:ignore */' + '.foo { padding-left: 0 }' + '/*! rtl:end:ignore */' + '.bar { direction: ltr }', '.foo { padding-left: 0 }' + '[dir=ltr] .bar { direction: ltr }' + '[dir=rtl] .bar { direction: rtl }'));
+test('Should add direction to flippable keyframes-animations', () => run(expect, '@keyframes bar { 100% { transform: rotate(360deg); } }', '@keyframes bar-ltr { 100% { transform: rotate(360deg); } }' + '@keyframes bar-rtl { 100% { transform: rotate(-360deg); } }'));
+test('Should handle multiple keyframes-animations', () => run(expect, '.loader {animation: load6 1.7s infinite ease, spinner 1.7s infinite ease;}' + '@keyframes load6 { 100% { transform: rotate(1deg) } }' + '@keyframes spinner { 100% { transform: rotate(-1deg) } }', '[dir=ltr] .loader {animation:  load6-ltr 1.7s infinite ease, spinner-ltr 1.7s infinite ease;}' + '[dir=rtl] .loader {animation:  load6-rtl 1.7s infinite ease, spinner-rtl 1.7s infinite ease;}' + '@keyframes load6-ltr { 100% { transform: rotate(1deg) } }' + '@keyframes load6-rtl { 100% { transform: rotate(-1deg) } }' + '@keyframes spinner-ltr { 100% { transform: rotate(-1deg) } }' + '@keyframes spinner-rtl { 100% { transform: rotate(1deg) } }'));
+test('Should ignore keyframes-animation prefixed with /* rtl:ignore */', () => run(expect, '/* rtl:ignore */ @keyframes bar { 100% { transform: rotate(360deg); } }', '@keyframes bar { 100% { transform: rotate(360deg); } }'));
+test('/* rtl:begin:ignore */ starts ignore mode for both keyframes and rules', () => run(expect, '/* rtl:begin:ignore */ @keyframes bar { 100% { transform: rotate(360deg); } } .foo { left: 5px }', '@keyframes bar { 100% { transform: rotate(360deg); } } .foo { left: 5px }'));
+test('/* rtl:end:ignore */ stops ignore mode for keyframes', () => run(expect, '/* rtl:begin:ignore */ @keyframes bar { 100% { transform: rotate(360deg); } } /* rtl:end:ignore */' + '.foo { left: 5px }', '@keyframes bar { 100% { transform: rotate(360deg); } }' + '[dir=ltr] .foo { left: 5px }' + '[dir=rtl] .foo { right: 5px }'));
+test('Should create only LTR version', () => run(expect, 'a { font-size: 1em; text-align: left }' + '@keyframes bar { 100% { transform: rotate(360deg); } }', 'a { font-size: 1em }' + '[dir=ltr] a { text-align: left }' + '@keyframes bar-ltr { 100% { transform: rotate(360deg); } }', {
+  onlyDirection: 'ltr'
+}));
+test('Should create only RTL version', () => run(expect, 'a { font-size: 1em; text-align: left }' + '@keyframes bar { 100% { transform: rotate(360deg); } }', 'a { font-size: 1em }' + '[dir=rtl] a { text-align: right }' + '@keyframes bar-rtl { 100% { transform: rotate(-360deg); } }', {
+  onlyDirection: 'rtl'
+}));
+test('Value replacement directives are honored', () => run(expect, '.foo { font-weight: bold; flex-direction: row/* rtl:row-reverse */; }', '.foo { font-weight: bold; }[dir=ltr] .foo { flex-direction: row/* rtl:row-reverse */; }[dir=rtl] .foo { flex-direction: row-reverse; }'));
+test('Value prepend directives are honored', () => run(expect, '.foo { font-weight: bold; font-family: "Droid Sans", "Helvetica Neue", Arial, sans-serif/*rtl:prepend:"Droid Arabic Kufi",*/; }', '.foo { font-weight: bold; }[dir=ltr] .foo { font-family: "Droid Sans", "Helvetica Neue", Arial, sans-serif/*rtl:prepend:"Droid Arabic Kufi",*/; }[dir=rtl] .foo { font-family: "Droid Arabic Kufi", "Droid Sans", "Helvetica Neue", Arial, sans-serif; }'));
+test('Value append directives are honored', () => run(expect, '.foo { font-weight: bold; transform: rotate(45deg)/* rtl:append: scaleX(-1) */; }', '.foo { font-weight: bold; }[dir=ltr] .foo { transform: rotate(45deg)/* rtl:append: scaleX(-1) */; }[dir=rtl] .foo { transform: rotate(45deg) scaleX(-1); }'));
+test('Value based ignore important comments are honored', () => run(expect, '.foo { margin-left: 12px; padding-left: 12px /*! rtl:ignore */; }', '.foo { padding-left: 12px /*! rtl:ignore */; }' + '[dir=ltr] .foo { margin-left: 12px; }' + '[dir=rtl] .foo { margin-right: 12px; }'));
+test('Value replacement directives with important comments are honored', () => run(expect, '.foo { font-weight: bold; flex-direction: row/*! rtl:row-reverse */; }', '.foo { font-weight: bold; }[dir=ltr] .foo { flex-direction: row/*! rtl:row-reverse */; }[dir=rtl] .foo { flex-direction: row-reverse; }'));
+test('Value prepend directives with important comments are honored', () => run(expect, '.foo { font-weight: bold; font-family: "Droid Sans", "Helvetica Neue", Arial, sans-serif/*!rtl:prepend:"Droid Arabic Kufi",*/; }', '.foo { font-weight: bold; }[dir=ltr] .foo { font-family: "Droid Sans", "Helvetica Neue", Arial, sans-serif/*!rtl:prepend:"Droid Arabic Kufi",*/; }[dir=rtl] .foo { font-family: "Droid Arabic Kufi", "Droid Sans", "Helvetica Neue", Arial, sans-serif; }'));
+test('Value append directives with important comments are honored', () => run(expect, '.foo { font-weight: bold; transform: rotate(45deg)/*! rtl:append: scaleX(-1) */; }', '.foo { font-weight: bold; }[dir=ltr] .foo { transform: rotate(45deg)/*! rtl:append: scaleX(-1) */; }[dir=rtl] .foo { transform: rotate(45deg) scaleX(-1); }'));
+test('Should keep comments', () => run(expect, '/* rtl:ignore */ a { text-align: left }', '/* rtl:ignore */ a { text-align: left }', {
+  removeComments: false
+}));
+test('Should respect custom prefix (attribute)', () => run(expect, 'a { text-align: left }', '[custom-dir-prefix=ltr] a { text-align: left }' + '[custom-dir-prefix=rtl] a { text-align: right }', {
+  prefix: 'custom-dir-prefix'
+}));
+test('Should respect custom prefix (class)', () => run(expect, 'a { text-align: left }', '.custom-dir-prefix-ltr a { text-align: left }' + '.custom-dir-prefix-rtl a { text-align: right }', {
+  prefix: 'custom-dir-prefix',
+  prefixType: 'class'
+}));
+test('Should not swap "left" and "right" subparts of selectors', () => run(expect, '.arrowLeft { margin-right: -3px }', '[dir=ltr] .arrowLeft { margin-right: -3px }' + '[dir=rtl] .arrowLeft { margin-left: -3px }'));
+test('Should respect multiline values', () => run(expect, `.multiline {
+        background: rgba(0, 0, 0, 0, .5),
+          linear-gradient(to right, transparent, #000);
+      }`, `[dir=ltr] .multiline {
+        background: rgba(0, 0, 0, 0, .5),
+          linear-gradient(to right, transparent, #000);
+      }` + `[dir=rtl] .multiline {
+        background: rgba(0, 0, 0, 0, .5),
+          linear-gradient(to left, transparent, #000);
+      }`));
+test('rtl:as: directive', () => run(expect, ':root { --padding /* rtl:as:padding */: 1px 2px 3px 4px }', '[dir=ltr]:root { --padding /* rtl:as:padding */: 1px 2px 3px 4px }' + '[dir=rtl]:root { --padding /* rtl:as:padding */: 1px 4px 3px 2px }'));
+test('rtl aliases', () => run(expect, ':root { --padding: 1px 2px 3px 4px }', '[dir=ltr]:root { --padding: 1px 2px 3px 4px }' + '[dir=rtl]:root { --padding: 1px 4px 3px 2px }', {
+  aliases: {
+    '--padding': 'padding'
+  }
+}));
+test('should ignore blacklist properties', () => run(expect, '.test {padding-left: 1rem;padding: 1rem 2rem 3rem 4rem}', '.test {padding: 1rem 2rem 3rem 4rem}' + '[dir=ltr] .test {padding-left: 1rem}' + '[dir=rtl] .test {padding-right: 1rem}', {
+  blacklist: ['padding']
+}));
+test('should process whitelist properties only', () => run(expect, '.test {padding-left: 1rem;padding: 1rem 2rem 3rem 4rem}', '.test {padding-left: 1rem}' + '[dir=ltr] .test {padding: 1rem 2rem 3rem 4rem}' + '[dir=rtl] .test {padding: 1rem 4rem 3rem 2rem}', {
+  whitelist: ['padding']
+}));
+/* ignored test cases */
+//   it('should ignore ignored @import', () =>
+//   run(
+//     expect,
+//     '/* rtl:begin:ignore */' +
+//       `@import "${__dirname}/../test-import.css";` +
+//       '/* rtl:end:ignore */',
+//     '.test-import { padding-left: 1rem }'
+//   ));

package/packages/client_build_tool/lib/shared/postcss/__test__/postcssRtl.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _postcss = _interopRequireDefault(require("postcss"));
+
+var _getSpecificPostCssPlugin = require("../getSpecificPostCssPlugin");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-use-before-define */
+// import { checkIsPatternsMatchFilename } from '../filterPluginsAllowedForSpecficFile';
+describe('postcss-rtl plugin basic requirement tests', () => {
+  it('is creating rtl css code for for margin-left', () => {
+    const cssInputStr = '.main{margin-left:20px}';
+    const cssOutputStr = '[dir=ltr] .main{margin-left:20px}[dir=rtl] .main{margin-right:20px}';
+    const result = runRTLPostCssPluginForCssString(cssInputStr);
+    expect(result.css).toEqual(cssOutputStr);
+  });
+  it('is creating rtl css code for for margin-right', cb => {
+    const cssInputStr = '.main{margin-right:20px}';
+    const cssOutputStr = '[dir=ltr] .main{margin-right:20px}[dir=rtl] .main{margin-left:20px}'; // console.log(postcss);
+
+    runRTLPostCssPluginForCssString(cssInputStr).then(res => {
+      expect(res.css).toEqual(cssOutputStr);
+      cb();
+    });
+  });
+});
+
+function runRTLPostCssPluginForCssString(cssInputStr) {
+  return (0, _postcss.default)([(0, _getSpecificPostCssPlugin.configPostCssRtl)()]).process(cssInputStr, {
+    from: '',
+    to: ''
+  });
+}

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/EmptyPlugin.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+// eslint-disable-next-line no-unused-vars
+const EmptyPlugin = (opts = {}) => ({
+  postcssPlugin: 'postcss-empty',
+
+  // eslint-disable-next-line no-unused-vars
+  Once(root, {
+    result
+  }) {}
+
+});
+
+EmptyPlugin.postcss = true;
+var _default = EmptyPlugin;
+exports.default = _default;

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HOVER_NOTATION = void 0;
+
+/* eslint-disable no-use-before-define */
+const HOVER_NOTATION = ':hover';
+exports.HOVER_NOTATION = HOVER_NOTATION;

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/handleIgnores.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleIgnores = handleIgnores;
+
+var _typeCheckUtils = require("./typeCheckUtils");
+
+const hoverIgnoreQuery = 'Hover:ignore';
+const activeIgnoreQuery = 'Active:ignore';
+const hoverActiveIgnoreQuery = 'HoverActive:ignore';
+
+function handleIgnore() {
+  let isIgnored = false;
+  return {
+    isIgnored: () => isIgnored,
+    update: isGoingTobeIgnored => {
+      isIgnored = isGoingTobeIgnored;
+    },
+    reset: () => {
+      isIgnored = false;
+    }
+  };
+} // eslint-disable-next-line no-unused-vars
+
+
+function handleIgnores(options) {
+  const hoverHandler = handleIgnore();
+  const activeHandler = handleIgnore();
+
+  function generateReturnValue() {
+    return {
+      hoverIgnored: hoverHandler.isIgnored(),
+      activeIgnored: activeHandler.isIgnored()
+    };
+  }
+
+  const ignoreCommentMap = {
+    [hoverIgnoreQuery]: () => {
+      hoverHandler.update(true);
+    },
+    [activeIgnoreQuery]: () => {
+      activeHandler.update(true);
+    },
+    [hoverActiveIgnoreQuery]: () => {
+      hoverHandler.update(true);
+      activeHandler.update(true);
+    }
+  };
+  return node => {
+    if ((0, _typeCheckUtils.isComment)(node)) {
+      const commentText = node.text.trim();
+      ignoreCommentMap[commentText] && ignoreCommentMap[commentText](); //   NOTE: we return here because this is just comment we can skip it.
+
+      return generateReturnValue();
+    } //   NOTE: we get the here. But return after resetting for next. Because these comment Only works for once.
+    //  Even If we support multiple line Skip we must do it in reset or separate method.
+
+
+    const returnValue = generateReturnValue();
+    hoverHandler.reset();
+    activeHandler.reset();
+    return returnValue;
+  };
+}

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/index.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _handleIgnores = require("./handleIgnores");
+
+var _typeCheckUtils = require("./typeCheckUtils");
+
+var _isPreviouslyProcessed = require("./isPreviouslyProcessed");
+
+var _insertBefore = require("./insertBefore");
+
+var _separateHoveredSelectorAndNormalSelector = require("./separateHoveredSelectorAndNormalSelector");
+
+var _replaceUtils = require("./replaceUtils");
+
+var _specialCases = require("./specialCases");
+
+var _default = config => {
+  const hoverMedQuerySuffix = config.hover;
+  const activeMedQuerySuffix = config.active;
+  return {
+    postcssPlugin: 'postcss-mobile-hover',
+    Once: function Once(root, params) {
+      const getIgnoreStatus = (0, _handleIgnores.handleIgnores)(); // eslint-disable-next-line no-use-before-define
+
+      const mediaRuleCreatorMap = getMediaRuleMap(params, hoverMedQuerySuffix, activeMedQuerySuffix);
+      root.walk(node => {
+        const ignoreStatus = getIgnoreStatus(node);
+
+        if ((0, _typeCheckUtils.isRule)(node) === false) {
+          return;
+        }
+
+        if ((0, _typeCheckUtils.isAtRule)(node.parent) && !(0, _typeCheckUtils.isMediaQuery)(node.parent)) {
+          return;
+        } // NOTE: after previous return we expect rule that are only normal rule or rules that inside media query
+
+
+        const rule = node;
+
+        if ((0, _isPreviouslyProcessed.isPreviouslyProcessed)(rule, {
+          hoverMedQuerySuffix,
+          activeMedQuerySuffix
+        })) {
+          return;
+        }
+
+        const {
+          hoveredSelectors,
+          normalSelectors
+        } = (0, _separateHoveredSelectorAndNormalSelector.separateHoveredSelectorAndNormalSelector)(rule.selector); // NOTE: this if will remove rule if the rule has no normal selectors. and return So be aware.
+
+        if (hoveredSelectors.length === 0) {
+          //  || isRuleHasHover(rule) === false
+          return;
+        }
+
+        let newHoverMediaQuery = null;
+        let newActiveMediaQuery = null;
+        let prefix = '';
+
+        if ((0, _typeCheckUtils.isAtRule)(rule.parent)) {
+          prefix = rule.parent.params;
+        } else {
+          // NOTE: for usual rules we don't need prefix, So use prefix as empty string
+          prefix = '';
+        }
+
+        if (!ignoreStatus.hoverIgnored) {
+          newHoverMediaQuery = mediaRuleCreatorMap.hoverRule({
+            rule,
+            hoveredSelectors,
+            prefix
+          }, params);
+        }
+
+        if (!ignoreStatus.activeIgnored) {
+          newActiveMediaQuery = mediaRuleCreatorMap.activeRule({
+            rule,
+            hoveredSelectors,
+            prefix
+          }, params);
+        }
+
+        (0, _insertBefore.insertNearBy)(rule, newHoverMediaQuery);
+        (0, _insertBefore.insertNearBy)(rule, newActiveMediaQuery);
+        (0, _specialCases.hackForComposes)(rule, hoveredSelectors, params);
+        (0, _specialCases.removeRuleIfNoNormalSelectors)(normalSelectors, rule);
+      });
+    }
+  };
+};
+
+exports.default = _default;
+
+function getMediaRuleMap(params, hoverMedQuerySuffix, activeMedQuerySuffix) {
+  const {
+    AtRule
+  } = params;
+  return {
+    hoverRule({
+      rule,
+      hoveredSelectors,
+      prefix
+    }) {
+      const newMediaQuery = new AtRule({
+        name: 'media',
+        params: (0, _isPreviouslyProcessed.concatMediaParams)(prefix, hoverMedQuerySuffix)
+      });
+      const clonedRule = rule.clone();
+      clonedRule.selector = hoveredSelectors.join(',');
+      newMediaQuery.append(clonedRule);
+      return newMediaQuery;
+    },
+
+    activeRule({
+      rule,
+      hoveredSelectors,
+      prefix
+    }) {
+      const newMediaQuery = new AtRule({
+        name: 'media',
+        params: (0, _isPreviouslyProcessed.concatMediaParams)(prefix, activeMedQuerySuffix)
+      });
+      const clonedRule = rule.clone();
+      clonedRule.selector = hoveredSelectors.map(_replaceUtils.replaceHoverToActiveInSelector).join(',');
+      newMediaQuery.append(clonedRule);
+      return newMediaQuery;
+    }
+
+  };
+}

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/insertBefore.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBefore = insertBefore;
+exports.insertNearBy = insertNearBy;
+
+var _typeCheckUtils = require("./typeCheckUtils");
+
+function insertBefore(node, newNode) {
+  newNode && node.parent.insertBefore(node, newNode);
+  return newNode;
+} // function insertAfter(node, newNode) {
+//   newNode && node.parent.insertAfter(node, newNode);
+//   return newNode;
+// }
+
+
+function insertNearBy(node, newNode) {
+  if (!newNode) {
+    return newNode;
+  } // we use insertBefore Because we wouldn't end up recursive (repeated) check and creation
+
+
+  if ((0, _typeCheckUtils.isParentAtRule)(node) && (0, _typeCheckUtils.isAtRule)(newNode)) {
+    return insertNearBy(node.parent, newNode);
+  }
+
+  return insertBefore(node, newNode); // return insertAfter(node, newNode);
+  // return newNode;
+}

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/isPreviouslyProcessed.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.concatMediaParams = concatMediaParams;
+exports.isPreviouslyProcessed = isPreviouslyProcessed;
+
+var _typeCheckUtils = require("./typeCheckUtils");
+
+function concatMediaParams(prefix, suffix) {
+  return prefix ? `${prefix} and ${suffix}` : `${suffix}`;
+}
+
+function isPreviouslyProcessed(rule, {
+  hoverMedQuerySuffix,
+  activeMedQuerySuffix
+}) {
+  return (0, _typeCheckUtils.isParentAtRule)(rule) && ((0, _typeCheckUtils.isParentAtRuleContainsParam)(rule, hoverMedQuerySuffix) || (0, _typeCheckUtils.isParentAtRuleContainsParam)(rule, activeMedQuerySuffix));
+}

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/replaceUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceHoverToActiveInSelector = exports.removeHoverFromSelector = void 0;
+
+var _constants = require("./constants");
+
+// function isRuleHasHover(rule) {
+//   return isSelectorHasHover(rule.selector);
+// }
+function generateReplacer(baseStr, replaceStr) {
+  return (inputStr = '') => inputStr.replaceAll(baseStr, replaceStr);
+}
+
+const removeHoverFromSelector = generateReplacer(_constants.HOVER_NOTATION, '');
+exports.removeHoverFromSelector = removeHoverFromSelector;
+const replaceHoverToActiveInSelector = generateReplacer(_constants.HOVER_NOTATION, ':active');
+exports.replaceHoverToActiveInSelector = replaceHoverToActiveInSelector;

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/HoverActivePlugin/separateHoveredSelectorAndNormalSelector.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.separateHoveredSelectorAndNormalSelector = separateHoveredSelectorAndNormalSelector;
+
+var _typeCheckUtils = require("./typeCheckUtils");
+
+function separateHoveredSelectorAndNormalSelector(fullselector = '') {
+  const hoveredSelectors = [];
+  const normalSelectors = [];
+  fullselector.split(/\s*,\s*/).forEach(selector => {
+    if ((0, _typeCheckUtils.isSelectorHasHover)(selector)) {
+      hoveredSelectors.push(selector);
+    } else {
+      normalSelectors.push(selector);
+    }
+  });
+  return {
+    hoveredSelectors,
+    normalSelectors
+  };
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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
+  // 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
+    // eslint-disable-next-line no-param-reassign
+    rule.selector = normalSelectors.join(',');
+  } else {
+    rule.remove();
+  }
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAtRule = isAtRule;
+exports.isAtRuleContainsParam = isAtRuleContainsParam;
+exports.isComment = isComment;
+exports.isMediaQuery = isMediaQuery;
+exports.isParentAtRule = isParentAtRule;
+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/packages/client_build_tool/lib/shared/{bundler/webpack/custom_postcss_loaders → postcss/custom_postcss_plugins}/RTLSplitPlugin.js

@@ -39,11 +39,11 @@ 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
+/**
+ * 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
  */
 
 
@@ -58,11 +58,11 @@ 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
+/**
+ * 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
  */