@zohodesk/react-cli 0.0.1-exp.166.2 → 0.0.1-exp.168.3

package/lib/postcss-plugins/hoverActivePlugin.js

@@ -0,0 +1,357 @@
+"use strict";
+
+var _postcss = _interopRequireDefault(require("postcss"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function previousNodeCheck(nodes, index) {
+  return nodes !== undefined && nodes[index - 1] !== undefined && nodes[index - 1] && nodes[index - 1].text !== undefined;
+}
+
+function isComment(node) {
+  return node !== undefined && node.type === 'comment';
+}
+
+function isHoverPresent(atrule) {
+  let hoverPresent = false;
+  atrule.walkRules(rule => {
+    if (rule.selector.includes('hover')) {
+      hoverPresent = true;
+    }
+  });
+  return hoverPresent;
+}
+
+module.exports = _postcss.default.plugin('postcss-mobile-hover', () => rootOriginal => {
+  const hoverRules = [];
+  let positionsObj = {};
+  const hoverIgnoreQuery = 'Hover:ignore',
+        activeIgnoreQuery = 'Active:ignore',
+        hoverActiveIgnoreQuery = 'HoverActive:ignore';
+  const medHoverIgnoreQuery = 'MedHover:ignore',
+        medActiveIgnoreQuery = 'MedActive:ignore',
+        medHoverActiveIgnoreQuery = 'MedHoverActive:ignore';
+
+  function QueryIgnoreCheck(index, type) {
+    if (previousNodeCheck(rootOriginal.nodes, index)) {
+      return rootOriginal.nodes[index - 1].text === type;
+    }
+
+    return false;
+  }
+
+  function mediaQueryIgnoreCheck(node, type) {
+    if (isComment(node)) {
+      return node.text === type;
+    }
+
+    return false;
+  }
+
+  function handleIgnore({
+    index,
+    atrule,
+    type
+  }) {
+    if (type.match(/(Hover:ignore|Active:ignore|HoverActive:ignore)/g)) {
+      return QueryIgnoreCheck(index, type);
+    }
+
+    if (type.match(/(MedHover:ignore|MedActive:ignore|MedHoverActive:ignore)/g)) {
+      return mediaQueryIgnoreCheck(atrule.nodes[index - 1], type.slice(3));
+    }
+  }
+
+  function returnPositions(parent) {
+    let positions = {
+      hovMed: rootOriginal.nodes[positionsObj[`${parent.params} and all and (min--moz-device-pixel-ratio:0) and (hover: hover), (hover: hover)`] - 1],
+      actMed: rootOriginal.nodes[positionsObj[`${parent.params} and (hover: none)`] - 1]
+    };
+    return positions;
+  }
+
+  function handleMedHoverAndHoverActiveIgnore(atrule, index) {
+    return !handleIgnore({
+      atrule,
+      index,
+      type: medHoverIgnoreQuery
+    }) && !handleIgnore({
+      atrule,
+      index,
+      type: medHoverActiveIgnoreQuery
+    });
+  }
+
+  function handleMedActiveAndHoverActiveIgnore(atrule, index) {
+    return !handleIgnore({
+      atrule,
+      index,
+      type: medActiveIgnoreQuery
+    }) && !handleIgnore({
+      atrule,
+      index,
+      type: medHoverActiveIgnoreQuery
+    });
+  }
+
+  function handleHoverAndHoverActiveIgnore(index) {
+    return !handleIgnore({
+      index,
+      type: hoverIgnoreQuery
+    }) && !handleIgnore({
+      index,
+      type: hoverActiveIgnoreQuery
+    });
+  }
+
+  function handleActiveAndHoverActiveIgnore(index) {
+    return !handleIgnore({
+      index,
+      type: activeIgnoreQuery
+    }) && !handleIgnore({
+      index,
+      type: hoverActiveIgnoreQuery
+    });
+  }
+
+  function handleAllIgnoreCases(index) {
+    return !handleIgnore({
+      index,
+      type: activeIgnoreQuery
+    }) && !handleIgnore({
+      index,
+      type: hoverIgnoreQuery
+    }) && !handleIgnore({
+      index,
+      type: hoverActiveIgnoreQuery
+    });
+  }
+
+  function mediaCommaQuery(rule, index) {
+    if (rule.parent.params !== undefined && !rule.parent.params.includes('hover')) {
+      //console.log(hovMed, actMed);
+      let newSelector = '';
+      let {
+        hovMed,
+        actMed
+      } = returnPositions(rule.parent);
+      let hovQueries = [];
+      let actQueries = [];
+      rule.selector.split(/\s*,\s*/).forEach(_subrule => {
+        let subrule = _subrule.trim();
+
+        let clone = rule.clone();
+
+        if (subrule.includes('hover')) {
+          clone.selector = subrule;
+
+          if (handleMedHoverAndHoverActiveIgnore(rule.parent, index)) {
+            hovQueries.push(subrule);
+          }
+
+          if (handleMedActiveAndHoverActiveIgnore(rule.parent, index)) {
+            actQueries.push(subrule);
+          }
+        } else {
+          newSelector += `${subrule}, `;
+        }
+      });
+
+      if (hovQueries.length > 0) {
+        let clone = rule.clone();
+        clone.selector = hovQueries.join(',');
+        hovMed.append(clone);
+      }
+
+      if (actQueries.length > 0) {
+        let clone = rule.clone();
+        clone.selector = actQueries.join(',');
+        actMed.append(clone.clone({
+          selector: clone.selector.replace(/:hover/gi, ':active')
+        }));
+      }
+
+      if (handleMedHoverAndHoverActiveIgnore(rule.parent, index)) {
+        rule.selector = newSelector.substring(0, newSelector.length - 2);
+      }
+
+      if (rule.selector === '') {
+        rule.remove();
+      }
+    }
+  }
+
+  function mediaQuery(rule, index) {
+    // console.log(rule.parent.params + " and all and (min--moz-device-pixel-ratio:0) and (hover: hover), (hover: hover)");
+    if (rule.parent.params !== undefined && !rule.parent.params.includes('hover')) {
+      let {
+        hovMed,
+        actMed
+      } = returnPositions(rule.parent);
+
+      if (rule.selector.includes('hover') && hovMed !== undefined && rule.parent.type === 'atrule') {
+        if (handleMedHoverAndHoverActiveIgnore(rule.parent, index)) {
+          hovMed.append(rule);
+        }
+
+        if (handleMedActiveAndHoverActiveIgnore(rule.parent, index)) {
+          actMed.append(rule.clone({
+            selector: rule.selector.replace(/:hover/gi, ':active')
+          }));
+        }
+      }
+    }
+  }
+
+  function commaQuery(rule, index) {
+    //console.log("comma" , rule.selector.split('\n'));
+    let newSelector = '';
+    let hovQueries = [];
+    rule.selector.split(/\s*,\s*/).forEach(_subrule => {
+      let subrule = _subrule.trim();
+
+      if (subrule.includes('hover')) {
+        // hoverRules.push({ rule: clone, index });
+        hovQueries.push(subrule);
+      } else {
+        newSelector += `${subrule}, `;
+      }
+    });
+
+    if (hovQueries.length > 0) {
+      let clone = rule.clone();
+      clone.selector = hovQueries.join(',');
+      hoverRules.push({
+        rule: clone,
+        index
+      });
+    }
+
+    if (handleHoverAndHoverActiveIgnore(index)) {
+      rule.selector = newSelector.substring(0, newSelector.length - 2).trim();
+    }
+
+    if (rule.selector === '') {
+      rule.remove();
+    }
+  } // Start by identifying all :hover rules
+
+
+  rootOriginal.walkAtRules(atrule => {
+    //console.log(positions[`${atrule.params} and all and (min--moz-device-pixel-ratio:0) and (hover: hover), (hover: hover)`])
+    const hoverQuery = `${atrule.params} and all and (min--moz-device-pixel-ratio:0) and (hover: hover), (hover: hover)`;
+    const activeQuery = `${atrule.params} and (hover: none)`;
+
+    if (isHoverPresent(atrule)) {
+      if (!positionsObj[hoverQuery] && !positionsObj[activeQuery]) {
+        rootOriginal.append({
+          name: 'media',
+          params: hoverQuery
+        });
+        positionsObj[hoverQuery] = rootOriginal.nodes.length - 1;
+        rootOriginal.append({
+          name: 'media',
+          params: activeQuery
+        });
+        positionsObj[activeQuery] = rootOriginal.nodes.length - 1;
+      }
+    }
+  });
+  rootOriginal.walkRules(/:hover/i, (rule, index) => {
+    // console.log({ rule, index });
+    // media hover query with ',' ' ' '+'
+    // console.log("media query" , rule.selector)
+    if (rule.parent.type === 'atrule' && rule.selector.includes(',')) {
+      //console.log("media comma", rule.selector)
+      mediaCommaQuery(rule, index);
+    } else {
+      // plus, space and other media queries
+      //console.log("media", rule.selector)
+      mediaQuery(rule, index);
+    } // usual hover query
+
+
+    if (!rule.selector.match(/,+| +|\++/g) && rule.parent !== undefined && rule.parent.name === undefined) {
+      hoverRules.push({
+        rule,
+        index
+      });
+    } //usual hover query with ',' ' ' '+'
+
+
+    if (rule.selector.match(/,+| +|\++/g) && rule.parent.name === undefined) {
+      if (rule.selector.includes(',')) {
+        commaQuery(rule, index);
+      } else if (rule.selector.match(/ +|\++/g)) {
+        //console.log("plus or space" , rule.selector);
+        if (rule.selector.includes('hover')) {
+          hoverRules.push({
+            rule,
+            index
+          }); //rule.remove();
+        }
+      }
+    }
+  }); // If there are any :hover rules in the input, then create media queries
+  // to automatically translate it into :active on touch-based devices
+
+  if (hoverRules.length > 0) {
+    // Create a media query targetting devices that actually support
+    // hover
+    const hoverQuery = rootOriginal.append({
+      name: 'media',
+      params: 'all and (min--moz-device-pixel-ratio:0) and (hover: hover), (hover: hover)'
+    }).last; // Create a media query targetting devices that don't support hover
+    // (ie. devices where we should fall back to :active instead)
+
+    const activeQuery = rootOriginal.append({
+      name: 'media',
+      params: '(hover: none)'
+    }).last; // Loop through the hover rules and apply them to each of the media
+    // queries
+    // eslint-disable-next-line no-labels
+
+    outerLoop: for (const hoverRule of hoverRules) {
+      // determine if the rule has been nested inside another media
+      // query; in that case bail out as we have no way of reliably
+      // nesting these queries
+      let parentRule = hoverRule.rule.parent;
+
+      while (parentRule) {
+        if (parentRule.type === 'atrule' && parentRule.name === 'media') {
+          // eslint-disable-next-line no-labels
+          continue outerLoop;
+        }
+
+        parentRule = parentRule.parent;
+      } // Push a clone of the :hover rule 'as is' to queries where we
+      // expect the user's device to support hover
+      // ieQuery.append(hoverRule.clone());
+
+
+      if (handleHoverAndHoverActiveIgnore(hoverRule.index)) {
+        hoverQuery.append(hoverRule.rule.clone());
+      } // Push a clone of the :hover rule, where we transform the
+      // selector to :active to the query targetting devices that
+      // don't support hover
+
+
+      if (handleActiveAndHoverActiveIgnore(hoverRule.index)) {
+        activeQuery.append(hoverRule.rule.clone({
+          selector: hoverRule.rule.selector.replace(/:hover/gi, ':active')
+        }));
+      } // remove legacy rule from output
+
+
+      if (handleAllIgnoreCases(hoverRule.index)) {
+        hoverRule.rule.remove();
+      }
+    }
+  }
+
+  rootOriginal.walkAtRules(atrule => {
+    if (atrule !== undefined && atrule.nodes !== undefined && atrule.nodes.length === 0 || atrule.nodes === undefined) {
+      atrule.remove();
+    }
+  });
+});

package/lib/postcss-plugins/keyframesPlugin.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _postcss = _interopRequireWildcard(require("postcss"));
+
+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; }
+
+module.exports = _postcss.default.plugin('postcss-reduced-motion', () => {
+  function animDeclPosn(rule) {
+    let posn = -1;
+    rule.walkDecls((decl, index) => {
+      //console.log(decl.prop, " " , decl.value);
+      if (decl.prop.includes('animation')) {
+        //console.log(decl.prop," selected")
+        posn = index;
+      }
+    });
+    return posn;
+  }
+
+  return root => {
+    let redRules = [];
+    root.walkAtRules((atrule, index) => {
+      if (index !== 0) {
+        //ignore case
+        let ignore = false;
+
+        if (root.nodes[index - 1].type === 'comment') {
+          ignore = root.nodes[index - 1].text.includes('reduced-motion:ignore');
+        } //animation none push to reduced motion
+
+
+        if (!ignore) {
+          //console.log(atrule)
+          atrule.walkRules(rule => {
+            let pos = animDeclPosn(rule);
+
+            if (pos !== -1) {
+              let ruleNew = rule.clone();
+              let decl = ruleNew.nodes[pos];
+              let declClone = decl.clone();
+              declClone.value = 'none';
+              ruleNew.walkDecls(declVal => declVal.remove());
+              ruleNew.append(declClone);
+              let atRuleNew = atrule.clone();
+              atRuleNew.nodes = [];
+              atRuleNew.push(ruleNew);
+              redRules.push(atRuleNew);
+            }
+          });
+        }
+      } else {
+        //animation none push to reduced motion
+        //console.log(atrule)
+        atrule.walkRules(rule => {
+          let pos = animDeclPosn(rule);
+
+          if (pos !== -1) {
+            let ruleNew = rule.clone();
+            let decl = ruleNew.nodes[pos];
+            let declClone = decl.clone();
+            declClone.value = 'none';
+            ruleNew.walkDecls(declVal => declVal.remove());
+            ruleNew.append(declClone);
+            let atRuleNew = atrule.clone();
+            atRuleNew.nodes = [];
+            atRuleNew.push(ruleNew);
+            redRules.push(atRuleNew);
+          }
+        });
+      }
+    });
+    root.walkRules((rule, index) => {
+      if (rule.type === 'rule' && rule.parent.name === undefined) {
+        if (index !== 0) {
+          //ignore case
+          let ignore = false;
+
+          if (root.nodes[index - 1].type === 'comment') {
+            ignore = root.nodes[index - 1].text.includes('reduced-motion:ignore');
+          } //animation none push to reduced motion
+
+
+          if (!ignore) {
+            //console.log(atrule)
+            rule.walkDecls(decl => {
+              if (decl !== undefined && decl.prop.includes('animation')) {
+                let declClone = decl.clone();
+                let newRule = rule.clone();
+                declClone.value = 'none';
+                newRule.walkDecls(declVal => declVal.remove());
+                newRule.append(declClone);
+                redRules.push(newRule);
+              }
+            });
+          }
+        } else {
+          //animation none push to reduced motion
+          //console.log(atrule)
+          rule.walkDecls(decl => {
+            if (decl !== undefined && decl.prop.includes('animation')) {
+              let declClone = decl.clone();
+              let newRule = rule.clone();
+              declClone.value = 'none';
+              newRule.walkDecls(declVal => declVal.remove());
+              newRule.append(declClone);
+              redRules.push(newRule);
+            }
+          });
+        }
+      }
+    });
+
+    if (redRules.length > 0) {
+      let redMtnQuery = (0, _postcss.atRule)({
+        name: 'media',
+        params: '(prefers-reduced-motion)'
+      });
+      root.append(redMtnQuery).last;
+      redRules.forEach(rule => {
+        redMtnQuery.append(rule);
+      });
+    }
+  };
+});

package/lib/schemas/index.js

@@ -14,6 +14,11 @@ var _getCurrentBranch = _interopRequireDefault(require("../utils/getCurrentBranc
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var _default = {
+  cliRootPath: null,
+  unstableDepsInverse: {
+    value: false,
+    cli: 'unstable_deps_inverse'
+  },
   sslCertURL: {
     value: null,
     cli: 'ssl_cert_url'
@@ -60,7 +65,10 @@ var _default = {
     dirVarName: 'document.dir'
   },
   efc: {
-    hasEFC: false,
+    hasEFC: {
+      value: false,
+      cli: 'enable_efc'
+    },
     createSDkFile: false,
     nameScope: 'ZOHODESK',
     version: 'default',
@@ -148,7 +156,10 @@ var _default = {
     disableES5Transpile: false,
     isReactMig: false,
     hasWidget: false,
-    hasEFC: false,
+    hasEFC: {
+      value: false,
+      cli: 'enable_efc'
+    },
     enableChunkHash: {
       value: false,
       cli: 'hash_enable'
@@ -204,6 +215,8 @@ var _default = {
       value: 'zd',
       cli: 'class_prefix'
     },
+    combinerMq: false,
+    hoverActive: false,
     selectorReplace: null,
     devConsoleExculde: {
       value: false,
@@ -256,6 +269,10 @@ var _default = {
       value: true,
       cli: 'css_unique'
     },
+    enableChunkHash: false,
+    combinerMq: false,
+    hoverActive: false,
+    keyframesRedMtn: false,
     folder: 'src',
     disableES5Transpile: false,
     hasRTL: false,
@@ -554,6 +571,10 @@ var _default = {
       value: null,
       cli: 'clone_revision'
     },
+    shallowClone: {
+      value: false,
+      cli: 'shallow_clone'
+    },
     projectName: {
       value: null,
       cli: 'clone_proj_name'

package/lib/servers/{devBulid.js → devBuild.js}

@@ -18,6 +18,9 @@ var _getCliPath = require("./getCliPath");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const options = (0, _utils.getOptions)(); // const args = process.argv.slice(3);
+// NOTE: need to discuss about in below codes,
+//  when we run webpack the  usable options  that comes  for npm run not  working  as automatical
+//  we are use this option always --disable_watch=true reason for now no need for  
 
 const {
   app: {
@@ -61,8 +64,9 @@ const startTime = Date.now(); // const result = spawnSync(
 //   ),
 //   { stdio: 'inherit' }
 // );
+// --disable_watch=true
 
-const result = execSyncDefalut(`${webpack} --config ${require.resolve('../configs/webpack.dev.config.js')}`);
+const result = execSyncDefalut(`${webpack} --config ${require.resolve('../configs/webpack.dev.config.js')} ${process.argv.slice(2).map(o => o.replace(/(.*?)=(.*)/, '$1="$2"')).join(' ')} `);
 result && console.log(result);
 
 if (result && result.stderr) {
@@ -83,8 +87,8 @@ if (zipname) {
   } else {
     console.log('zip  file  created', cssSelectorZipPath);
   }
-} // npm run start --app:domain=tsi --impact:cssbountry="{$@&&@$}" --disable-watch --dev-cache --cssselector_zip=css-source-map.zip 
-// npm run start --app_domain=tsi --impact_cssbountry="{$@&&@$}" --disable-watch --dev-cache --cssselector_zip=css-source-map.zip 
+} // npm run start --app:domain=tsi --impact:cssbountry="{$@&&@$}" --disable-watch --dev-cache --cssselector_zip=css-source-map.zip
+// npm run start --app_domain=tsi --impact_cssbountry="{$@&&@$}" --disable-watch --dev-cache --cssselector_zip=css-source-map.zip
 
 
 console.log(`compailation done in ${Date.now() - startTime}ms`);

package/lib/servers/httpsOptions.js

@@ -12,8 +12,7 @@ var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const httpsOptions = {
-  key: _fs.default.readFileSync(_path.default.join(__dirname, '../../cert/key.pem')),
-  cert: _fs.default.readFileSync(_path.default.join(__dirname, '../../cert/cert.pem')),
-  passphrase: _fs.default.readFileSync(_path.default.join(__dirname, '../../cert/passphrase.pem')).toString()
+  key: _fs.default.readFileSync(_path.default.join(__dirname, '../../cert/Tsicsezwild-22-23.key')),
+  cert: _fs.default.readFileSync(_path.default.join(__dirname, '../../cert/Tsicsezwild-22-23.crt'))
 };
 exports.httpsOptions = httpsOptions;

package/lib/servers/nowatchserver.js

@@ -14,7 +14,7 @@ var _utils = require("../utils");
 
 var _httpsOptions = require("./httpsOptions");
 
-var _devBulid = require("./devBulid");
+var _devBuild = require("./devBuild");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -42,7 +42,7 @@ const {
   zipname,
   cssSelectorZipPath,
   outputFolderLocation
-} = (0, _devBulid.getPaths)();
+} = (0, _devBuild.getPaths)();
 const app = (0, _express.default)();
 
 if (hasMock) {

package/lib/servers/server.js

@@ -69,7 +69,8 @@ if (mode === 'prod') {
   config = require('../configs/webpack.dev.config');
 } else {
   throw new Error('You must configure valid option in mode');
-}
+} // console.log({ contextURL });
+
 
 let compiler = (0, _webpack.default)(config);
 let webpackServerOptions = {
@@ -144,15 +145,22 @@ app.post('/wmsmockapi', (req, res) => {
   res.send('success');
 });
 let webpackCompilation;
+let initalHTML;
 compiler.hooks.afterCompile.tap('ReactCLI', compilation => {
   webpackCompilation = compilation;
 });
+compiler.hooks.done.tap('ReactCLI', () => {
+  const indexHtml = webpackCompilation.assets['index.html'];
+
+  if (indexHtml) {
+    initalHTML = indexHtml.source();
+  }
+});
 
 if (contextURL) {
   app.use(contextURL, _express.default.static(context));
   app.use(`${contextURL}/*`, (req, res) => {
-    let indexHtml = webpackCompilation.assets['index.html'];
-    res.send(indexHtml && indexHtml.source());
+    res.send(initalHTML);
   });
 } else {
   app.use(_express.default.static(context));