@zohodesk/react-cli 0.0.1-beta.99 → 0.0.1-betaa.138.2

package/lib/plugins/PublicPathChangePlugin.js

@@ -1,335 +1,226 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+var _path = _interopRequireDefault(require("path"));
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _webpackSources = require("webpack-sources");
 
-var _path = require('path');
-
-var _path2 = _interopRequireDefault(_path);
-
-var _webpackSources = require('webpack-sources');
-
-var _utils = require('../utils');
+var _utils = require("../utils");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var MODULE_TYPE = 'css/mini-extract';
+const MODULE_TYPE = 'css/mini-extract';
+let {
+  chunkSplitEnable
+} = (0, _utils.getOptions)().i18n || {};
 
-var filenameParser = function filenameParser(filename) {
-  var filepaths = filename.split('/');
-  var hashedName = filepaths[filepaths.length - 1];
+let filenameParser = filename => {
+  let filepaths = filename.split('/');
+  let hashedName = filepaths[filepaths.length - 1];
 
-  var _path$parse = _path2.default.parse(hashedName),
-      name = _path$parse.name,
-      ext = _path$parse.ext;
+  let {
+    name,
+    ext
+  } = _path.default.parse(hashedName);
 
-  var nameparts = name.split('.');
+  let nameparts = name.split('.');
   return {
     name: nameparts.slice(0, nameparts.length - 1).join('.') + ext,
-    hashedName: hashedName,
-    ext: ext
+    hashedName,
+    ext
   };
 };
 
-var PublicPathChangePlugin = function () {
-  function PublicPathChangePlugin(_ref) {
-    var publicPaths = _ref.publicPaths,
-        resourceHints = _ref.resourceHints;
-
-    _classCallCheck(this, PublicPathChangePlugin);
-
+class PublicPathChangePlugin {
+  constructor({
+    publicPaths,
+    resourceHints
+  }) {
     if (Array.isArray(publicPaths)) {
-      var _publicPaths = publicPaths,
-          _publicPaths2 = _slicedToArray(_publicPaths, 5),
-          js = _publicPaths2[0],
-          css = _publicPaths2[1],
-          image = _publicPaths2[2],
-          font = _publicPaths2[3],
-          i18njs = _publicPaths2[4];
-      //eslint-disable-next-line
-
+      let [js, css, image, font, i18njs] = publicPaths; //eslint-disable-next-line
 
       publicPaths = {
-        __REACT_CLI_PUBLIC_PATHS__: { js: js, css: css, image: image, font: font, i18njs: i18njs }
+        __REACT_CLI_PUBLIC_PATHS__: {
+          js,
+          css,
+          image,
+          font,
+          i18njs
+        }
       };
     }
+
     this.publicPaths = publicPaths;
     this.resourceHints = resourceHints;
   }
 
-  _createClass(PublicPathChangePlugin, [{
-    key: 'getCssChunkObject',
-    value: function getCssChunkObject(mainChunk) {
-      var obj = {};
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = mainChunk.getAllAsyncChunks()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var chunk = _step.value;
-          var _iteratorNormalCompletion2 = true;
-          var _didIteratorError2 = false;
-          var _iteratorError2 = undefined;
-
-          try {
-            for (var _iterator2 = chunk.modulesIterable[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-              var module = _step2.value;
-
-              if (module.type === MODULE_TYPE) {
-                obj[chunk.id] = 1;
-                break;
-              }
-            }
-          } catch (err) {
-            _didIteratorError2 = true;
-            _iteratorError2 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion2 && _iterator2.return) {
-                _iterator2.return();
-              }
-            } finally {
-              if (_didIteratorError2) {
-                throw _iteratorError2;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
+  getCssChunkObject(mainChunk) {
+    const obj = {};
 
-      return obj;
-    }
-  }, {
-    key: 'needChunkOnDemandLoadingCode',
-    value: function needChunkOnDemandLoadingCode(chunk) {
-      var _iteratorNormalCompletion3 = true;
-      var _didIteratorError3 = false;
-      var _iteratorError3 = undefined;
-
-      try {
-        for (var _iterator3 = chunk.groupsIterable[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-          var chunkGroup = _step3.value;
-
-          if (chunkGroup.getNumberOfChildren() > 0) {
-            return true;
-          }
-        }
-      } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return) {
-            _iterator3.return();
-          }
-        } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
-          }
+    for (const chunk of mainChunk.getAllAsyncChunks()) {
+      for (const module of chunk.modulesIterable) {
+        if (module.type === MODULE_TYPE) {
+          obj[chunk.id] = 1;
+          break;
         }
       }
+    }
 
-      return false;
+    return obj;
+  }
+
+  needChunkOnDemandLoadingCode(chunk) {
+    for (const chunkGroup of chunk.groupsIterable) {
+      if (chunkGroup.getNumberOfChildren() > 0) {
+        return true;
+      }
     }
-  }, {
-    key: 'getResourceHints',
-    value: function getResourceHints(resourceHints, manifest, publicPaths) {
-      var ruleMapping = {};
-      var validFiles = Object.keys(manifest).filter(function (filename) {
-        var isValidFile = false;
-        var _iteratorNormalCompletion4 = true;
-        var _didIteratorError4 = false;
-        var _iteratorError4 = undefined;
-
-        try {
-          for (var _iterator4 = resourceHints[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-            var pattern = _step4.value;
-
-            if (typeof pattern === 'string') {
-              isValidFile = new RegExp(pattern).test(filename);
-            } else {
-              isValidFile = new RegExp(pattern.pattern).test(filename);
-            }
-            if (isValidFile) {
-              ruleMapping[filename] = typeof pattern !== 'string' ? pattern : {};
-              break;
-            }
-          }
-        } catch (err) {
-          _didIteratorError4 = true;
-          _iteratorError4 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion4 && _iterator4.return) {
-              _iterator4.return();
-            }
-          } finally {
-            if (_didIteratorError4) {
-              throw _iteratorError4;
-            }
-          }
-        }
 
-        return isValidFile;
-      });
-      var resourceHintsContent = '';
-      var _iteratorNormalCompletion5 = true;
-      var _didIteratorError5 = false;
-      var _iteratorError5 = undefined;
-
-      try {
-        for (var _iterator5 = validFiles[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-          var file = _step5.value;
-          var _manifest$file = manifest[file],
-              fileType = _manifest$file.fileType,
-              filename = _manifest$file.filename;
-
-          var rules = ruleMapping[file];
-          resourceHintsContent += '<link rel=' + (rules.hint || 'preload') + ' href=\'' + (publicPaths[fileType] + filename) + '\'' + (rules.hint === 'prefetch' ? '' : 'as=\'' + fileType + '\' crossorigin=\'' + (rules.crossorigin || 'false') + '\'') + ' />';
+    return false;
+  }
+
+  getResourceHints(resourceHints, manifest, publicPaths) {
+    let ruleMapping = {};
+    let validFiles = Object.keys(manifest).filter(filename => {
+      let isValidFile = false;
+
+      for (let pattern of resourceHints) {
+        if (typeof pattern === 'string') {
+          isValidFile = new RegExp(pattern).test(filename);
+        } else {
+          isValidFile = new RegExp(pattern.pattern).test(filename);
         }
-      } catch (err) {
-        _didIteratorError5 = true;
-        _iteratorError5 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion5 && _iterator5.return) {
-            _iterator5.return();
-          }
-        } finally {
-          if (_didIteratorError5) {
-            throw _iteratorError5;
-          }
+
+        if (isValidFile) {
+          ruleMapping[filename] = typeof pattern !== 'string' ? pattern : {};
+          break;
         }
       }
 
-      return resourceHintsContent;
+      return isValidFile;
+    });
+    let resourceHintsContent = '';
+
+    for (let file of validFiles) {
+      let {
+        fileType,
+        filename
+      } = manifest[file];
+      let rules = ruleMapping[file];
+      resourceHintsContent += `<link rel=${rules.hint || 'preload'} href='${publicPaths[fileType] + filename}'${rules.hint === 'prefetch' ? '' : `as='${fileType}' crossorigin='${rules.crossorigin || 'false'}'`} />`;
     }
-  }, {
-    key: 'apply',
-    value: function apply(compiler) {
-      var _this = this;
-
-      compiler.hooks.thisCompilation.tap('PublicPathChangePlugin', function (compilation) {
-        compilation.mainTemplate.hooks.requireEnsure.tap('PublicPathChangePlugin', function (source, chunk) {
-          var chunkMap = _this.getCssChunkObject(chunk);
-          if (Object.keys(chunkMap).length > 0) {
-            return source.replace('__webpack_require__.p', '__REACT_CLI_CSS_PUBLIC_PATH__');
-          }
-        });
-      });
 
-      compiler.hooks.compilation.tap('PublicPathChangePlugin', function (compilation) {
-        compilation.mainTemplate.hooks.localVars.tap('PublicPathChangePlugin', function (source, chunk) {
-          if (_this.needChunkOnDemandLoadingCode(chunk)) {
-            return source.replace('__webpack_require__.p', '__REACT_CLI_JS_PUBLIC_PATH__');
-          }
-        });
-      });
-
-      compiler.hooks.emit.tap('PublicPathChangePlugin', function (compilation) {
-        var cdns = Object.keys(_this.publicPaths);
-        var stats = compilation.getStats().toJson();
-
-        var manifest = stats.assets.reduce(function (files, asset) {
-          var filename = asset.name;
-
-          var fileType = (0, _utils.getFileType)(filename);
-          if (fileType === 'image' || fileType === 'font') {
-            var _filenameParser = filenameParser(filename),
-                name = _filenameParser.name,
-                hashedName = _filenameParser.hashedName,
-                ext = _filenameParser.ext;
-
-            files[name] = { hashedName: hashedName, ext: ext, fileType: fileType, filename: filename };
-          }
-          return files;
-        }, {});
-
-        Object.keys(compilation.assets).forEach(function (filename) {
-          if (Array.isArray(cdns)) {
-            cdns.forEach(function (cdn) {
-              var source = compilation.assets[filename].source();
-              if (/\.css$/g.test(filename)) {
-                var publicPaths = _this.publicPaths[cdn];
-                source = (0, _utils.cssUrlReplacer)(source, publicPaths, manifest, cdn);
-              } else if (/\.js$/g.test(filename)) {
-                var _publicPaths$cdn = _this.publicPaths[cdn],
-                    js = _publicPaths$cdn.js,
-                    css = _publicPaths$cdn.css,
-                    image = _publicPaths$cdn.image,
-                    font = _publicPaths$cdn.font;
-
-                if (typeof source === 'string') {
-                  source = source.replace(/__REACT_CLI_JS_PUBLIC_PATH__/g, '"' + js + '"');
-                  source = source.replace(/__REACT_CLI_CSS_PUBLIC_PATH__/g, '"' + css + '"');
-                  source = source.replace(/__REACT_CLI_IMAGE_PUBLIC_PATH__/g, '"' + image + '"');
-                  source = source.replace(/__REACT_CLI_FONT_PUBLIC_PATH__/g, '"' + font + '"');
-                }
-              } else if (/\.html$/g.test(filename)) {
-                var _publicPaths$cdn2 = _this.publicPaths[cdn],
-                    _js = _publicPaths$cdn2.js,
-                    _css = _publicPaths$cdn2.css,
-                    i18njs = _publicPaths$cdn2.i18njs;
-
-
-                source = source.replace(new RegExp('<script defer src="([^"]*)"', 'g'), function (match, arg) {
-                  return match.replace(arg, _js + arg);
-                });
-                source = source.replace(new RegExp('<link href="([^"]*)"', 'g'), function (match, arg) {
-                  return match.replace(arg, _css + arg);
-                });
+    return resourceHintsContent;
+  }
 
-                var _source$match = source.match(/<!--I18nInfoToServer(.*?)I18nInfoToServer-->/gm),
-                    _source$match2 = _slicedToArray(_source$match, 1),
-                    i18nStr = _source$match2[0];
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap('PublicPathChangePlugin', compilation => {
+      compilation.mainTemplate.hooks.requireEnsure.tap('PublicPathChangePlugin', (source, chunk) => {
+        const chunkMap = this.getCssChunkObject(chunk);
 
-                if (i18nStr) {
-                  var _i18nStr$match = i18nStr.match(/{(.*?)}/gm),
-                      _i18nStr$match2 = _slicedToArray(_i18nStr$match, 1),
-                      i18nObj = _i18nStr$match2[0];
+        if (Object.keys(chunkMap).length > 0) {
+          return source.replace('__webpack_require__.p', '__REACT_CLI_CSS_PUBLIC_PATH__');
+        }
+      });
+    });
+    compiler.hooks.compilation.tap('PublicPathChangePlugin', compilation => {
+      compilation.mainTemplate.hooks.localVars.tap('PublicPathChangePlugin', (source, chunk) => {
+        if (this.needChunkOnDemandLoadingCode(chunk)) {
+          return source.replace('__webpack_require__.p', '__REACT_CLI_JS_PUBLIC_PATH__');
+        }
+      });
+    });
+    compiler.hooks.emit.tap('PublicPathChangePlugin', compilation => {
+      let cdns = Object.keys(this.publicPaths);
+      let stats = compilation.getStats().toJson();
+      let manifest = stats.assets.reduce((files, asset) => {
+        let {
+          name: filename
+        } = asset;
+        let fileType = (0, _utils.getFileType)(filename);
+
+        if (fileType === 'image' || fileType === 'font') {
+          let {
+            name,
+            hashedName,
+            ext
+          } = filenameParser(filename);
+          files[name] = {
+            hashedName,
+            ext,
+            fileType,
+            filename
+          };
+        }
 
+        return files;
+      }, {});
+      Object.keys(compilation.assets).forEach(filename => {
+        if (Array.isArray(cdns)) {
+          cdns.forEach(cdn => {
+            let source = compilation.assets[filename].source();
+
+            if (/\.css$/g.test(filename)) {
+              let publicPaths = this.publicPaths[cdn];
+              source = (0, _utils.cssUrlReplacer)(source, publicPaths, manifest, cdn);
+            } else if (/\.js$/g.test(filename)) {
+              let {
+                js,
+                css,
+                image,
+                font
+              } = this.publicPaths[cdn];
+
+              if (typeof source === 'string') {
+                source = source.replace(/__REACT_CLI_JS_PUBLIC_PATH__/g, `"${js}"`);
+                source = source.replace(/__REACT_CLI_CSS_PUBLIC_PATH__/g, `"${css}"`);
+                source = source.replace(/__REACT_CLI_IMAGE_PUBLIC_PATH__/g, `"${image}"`);
+                source = source.replace(/__REACT_CLI_FONT_PUBLIC_PATH__/g, `"${font}"`);
+              }
+            } else if (/\.html$/g.test(filename)) {
+              let {
+                js,
+                css,
+                i18njs
+              } = this.publicPaths[cdn];
+              source = source.replace(new RegExp('<script defer src="([^"]*)"', 'g'), (match, arg) => match.replace(arg, js + arg));
+              source = source.replace(new RegExp('<link href="([^"]*)"', 'g'), (match, arg) => match.replace(arg, css + arg));
+              let [i18nStr] = source.match(/<!--I18nInfoToServer(.*?)I18nInfoToServer-->/gm);
+
+              if (i18nStr && !chunkSplitEnable) {
+                try {
+                  let [i18nObj] = i18nStr.match(/{(.*?)}/gm);
                   i18nObj = JSON.parse(JSON.parse(JSON.stringify(i18nObj)));
-                  Object.keys(i18nObj).forEach(function (locale) {
+                  Object.keys(i18nObj).forEach(locale => {
                     i18nObj[locale] = i18njs + i18nObj[locale];
                   });
+                  source = source.replace(/<!--I18nInfoToServer(.*?)I18nInfoToServer-->/gm, `<!--I18nInfoToServer${JSON.stringify(i18nObj)}I18nInfoToServer-->`);
+                } catch (e) {
+                  // eslint-disable-next-line no-console
+                  console.warn('may be I18nInfoToServer inside object was not valid make sure it is parseable by JSON.parse'); // eslint-disable-next-line no-console
 
-                  source = source.replace(/<!--I18nInfoToServer(.*?)I18nInfoToServer-->/gm, '<!--I18nInfoToServer' + JSON.stringify(i18nObj) + 'I18nInfoToServer-->');
-                }
-                if (Array.isArray(_this.resourceHints) && _this.resourceHints.length) {
-                  var resourceHintsContent = _this.getResourceHints(_this.resourceHints, manifest, _this.publicPaths[cdn]);
-                  source = source.replace(/<\/head>/g, resourceHintsContent + '</head>');
+                  console.warn(e);
                 }
               }
-              compilation.assets[cdn === '__REACT_CLI_PUBLIC_PATHS__' ? filename : cdn + '/' + filename] = new _webpackSources.RawSource(source);
-            });
-          }
-        });
+
+              if (Array.isArray(this.resourceHints) && this.resourceHints.length) {
+                let resourceHintsContent = this.getResourceHints(this.resourceHints, manifest, this.publicPaths[cdn]);
+                source = source.replace(/<\/head>/g, `${resourceHintsContent}</head>`);
+              }
+            }
+
+            compilation.assets[cdn === '__REACT_CLI_PUBLIC_PATHS__' ? filename : `${cdn}/${filename}`] = new _webpackSources.RawSource(source);
+          });
+        }
       });
-    }
-  }]);
+    });
+  }
 
-  return PublicPathChangePlugin;
-}();
+}
 
-exports.default = PublicPathChangePlugin;
+var _default = PublicPathChangePlugin;
+exports.default = _default;