@zohodesk/react-cli 1.1.27-exp.1 → 1.1.27-exp.3

package/packages/client_build_tool/lib/shared/bundler/webpack/configCustomLoaders.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configCustomLoaders = configCustomLoaders;
+
+function configCustomLoaders(options) {
+  return options.customLoaders || [];
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/cssLoaders.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cssLoaders = cssLoaders;
+
+var _getCSSLoaders = require("./getCSSLoaders");
+
+function cssLoaders(options) {
+  return [{
+    test: /\.css$/,
+    // exclude: /\.module\.css$/,
+    use: (0, _getCSSLoaders.getCSSLoaders)(options)
+  }];
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/BundleIntegrityReport/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BundleIntegrityReport = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _stream = require("stream");
+
+var _objectManipulation = require("../../utils/object-manipulation");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pluginName = 'BundleIntegrityReportPlugin';
+
+class BundleIntegrityReport {
+  constructor({
+    options,
+    excludeKeysInReport,
+    fileName
+  }) {
+    this.excludeKeysInStat = excludeKeysInReport;
+    this.statsFileName = fileName;
+    this.statsOptions = options;
+  }
+
+  apply(compiler) {
+    compiler.hooks.done.tapAsync(pluginName, (stats, callback) => {
+      const statsJson = (0, _objectManipulation.removeKeysFromObject)(stats.toJson(this.statsOptions), this.excludeKeysInStat);
+      this.emitStats(statsJson).on('end', () => {
+        callback();
+      }).on('error', e => {
+        callback(e);
+      });
+    });
+  }
+
+  writeStatsFileInAStream(statsObj) {
+    const {
+      outputPath
+    } = statsObj;
+
+    const ouputFileName = _path.default.join(outputPath, this.statsFileName);
+
+    return this.createReadStream(statsObj).pipe(_fs.default.createWriteStream(ouputFileName));
+  }
+
+  createReadStream(statsObj) {
+    const excludeKeys = this.excludeKeysInStat;
+    return new _stream.Readable({
+      read() {
+        let isDone = false;
+        const objToStringGen = (0, _objectManipulation.convertObjectToStringGen)(statsObj, excludeKeys);
+
+        while (!isDone) {
+          const {
+            done,
+            value
+          } = objToStringGen.next();
+
+          if (done) {
+            isDone = true;
+            this.push(null);
+          } else {
+            this.push(value);
+          }
+        }
+      }
+
+    });
+  }
+
+  emitStats(statsJson) {
+    return this.writeStatsFileInAStream(statsJson);
+  }
+
+}
+
+exports.BundleIntegrityReport = BundleIntegrityReport;

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/CdnChangePlugin/index.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+var _webpack = require("webpack");
+
+var _nameTemplates = require("../../common/nameTemplates");
+
+var _modeUtils = require("../../common/modeUtils");
+
+var _webpackCustomJsUrlLoader = _interopRequireDefault(require("./webpackCustomJsUrlLoader"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import { RuntimeGlobals, RuntimeModule } from 'webpack';
+// eslint-disable-next-line import/extensions
+// import { Template } from 'webpack';
+// eslint-disable-next-line import/extensions
+const pluginName = 'CdnChangePlugin'; // const MODULE_TYPE = 'css/mini-extract';
+// class CdnChangeRuntimePlugin extends RuntimeModule {
+//   constructor(compiler, { variableName }) {
+//     super('cdn loading', 10);
+//     this.variableName = variableName;
+//   }
+//   generate() {
+//     return `${RuntimeGlobals.getChunkCssFilename} = function(chunkId) {
+//       const cssCdnUrl = window[${this.variableName}] || chunkId;
+//       return cssCdnUrl;
+//     }`;
+//   }
+// }
+
+class CdnChangePlugin {
+  constructor(options) {
+    this.createSeparateSMap = options.createSeparateSMap;
+    this.i18nTemplate = options.i18nTemplate || '{{__I18N_CDN__}}';
+    this.variableName = options.variableName || 'window.__SMAP_PATH__';
+    this.cssTemplate = options.cssTemplate || '{{__CSS_CDN__}}';
+    this.jsTemplate = options.jsTemplate || '{{__JS_CDN__}}';
+    this.mode = options.mode || 'prod';
+  }
+
+  apply(compiler) {
+    // compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+    //   const enabledChunks = new WeakSet();
+    //   const handler = (entryRuntimeChunk, set) => {
+    //     if (enabledChunks.has(entryRuntimeChunk)) {
+    //       return;
+    //     }
+    //     enabledChunks.add(entryRuntimeChunk);
+    //     set.add(RuntimeGlobals.getFullHash);
+    //     set.add(RuntimeGlobals.getChunkCssFilename);
+    //     compilation.addRuntimeModule(
+    //       entryRuntimeChunk,
+    //       new CdnChangeRuntimePlugin(set, {
+    //         compiler,
+    //         variableName: this.variableName
+    //       })
+    //     );
+    //   };
+    //   compilation.hooks.runtimeRequirementInTree
+    //     .for(RuntimeGlobals.ensureChunkHandlers)
+    //     .tap(pluginName, handler);
+    // });
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(pluginName, (data, cb) => {
+        const {
+          createSeparateSMap,
+          mode
+        } = this; // eslint-disable-next-line no-param-reassign
+
+        data.assets = { ...data.assets,
+          css: data.assets.css.map(css => `${this.cssTemplate}${css}`),
+          js: data.assets.js.map(js => {
+            if ((0, _modeUtils.isProductionMode)(mode) && createSeparateSMap && !(0, _nameTemplates.isI18nFile)(js)) {
+              if (js.includes('smap')) {
+                js = js.replace('smap/js/', `{{--js-smap}}js/`); //eslint-disable-line
+              } else {
+                js = js.replace('js/', `{{--js-smap}}js/`); //eslint-disable-line
+              }
+            }
+
+            return `${(0, _nameTemplates.isI18nFile)(js) ? this.i18nTemplate : this.jsTemplate}${js}`;
+          })
+        };
+        cb && cb(null, data);
+      });
+
+      compilation.hooks.runtimeRequirementInTree.for(_webpack.RuntimeGlobals.getChunkScriptFilename).tap(pluginName, (chunk, set) => {
+        if (typeof compilation.outputOptions.chunkFilename === 'string' && /\[(full)?hash(:\d+)?\]/.test(compilation.outputOptions.chunkFilename)) {
+          set.add(_webpack.RuntimeGlobals.getFullHash);
+        }
+
+        compilation.addRuntimeModule(chunk, // eslint-disable-next-line new-cap
+        new _webpackCustomJsUrlLoader.default('javascript', 'javascript', _webpack.RuntimeGlobals.getChunkScriptFilename, chunk => chunk.filenameTemplate || (chunk.canBeInitial() ? compilation.outputOptions.filename : compilation.outputOptions.chunkFilename), false, this.variableName));
+        return true;
+      });
+    });
+  }
+
+}
+
+var _default = CdnChangePlugin; // Cdn Change Plugin for runtime chunks???
+
+/**
+ * the filename of the script part of the chunk
+ */
+// exports.getChunkScriptFilename = "__webpack_require__.u";
+// /**
+//  * the filename of the css part of the chunk
+//  */
+// exports.getChunkCssFilename = "__webpack_require__.k";
+
+exports.default = _default;

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/CdnChangePlugin/webpackCustomJsUrlLoader.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _GetChunkFilenameRuntimeModule = _interopRequireDefault(require("webpack/lib/runtime/GetChunkFilenameRuntimeModule"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import { RuntimeGlobals, RuntimeModule, Template } from 'webpack';
+// const GetChunkFilenameRuntimeModule = require('webpack/lib/runtime/GetChunkFilenameRuntimeModule');
+// import GetChunkFilenameRuntimeModule from 'webpack/lib/runtime/GetChunkFilenameRuntimeModule';
+// const first = set => {
+//   const entry = set.values().next();
+//   return entry.done ? undefined : entry.value;
+// };
+class CustomizedGetChunkFilenameRuntimeModule extends _GetChunkFilenameRuntimeModule.default {
+  /**
+   * @param {string} contentType the   to use the content hash for
+   * @param {string} name kind of filename
+   * @param {string} global function name to be assigned
+   * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
+   * @param {boolean} allChunks when false, only async chunks are included
+   */
+  constructor(contentType, name, global, getFilenameForChunk, allChunks, variableName) {
+    super(contentType, name, global, getFilenameForChunk, allChunks);
+    this.contentType = contentType;
+    this.global = global;
+    this.getFilenameForChunk = getFilenameForChunk;
+    this.allChunks = allChunks;
+    this.dependentHash = true;
+    this.variableName = variableName;
+  }
+
+  generate() {
+    const sourceCode = super.generate().toString();
+    const replaceCode = sourceCode.replaceAll('"js-chunks/', `${this.variableName} + "js-chunks/`);
+    return replaceCode;
+  }
+
+}
+
+var _default = CustomizedGetChunkFilenameRuntimeModule;
+exports.default = _default;

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/CustomScriptLoadingPlugin.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CustomScriptLoadingStrategyPlugin = void 0;
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pluginName = 'CustomScriptLoadingStrategyPlugin';
+
+class CustomScriptLoadingStrategyPlugin {
+  constructor({
+    scriptLoadingStategey
+  } = {}) {
+    this.scriptLoadingStrategy = scriptLoadingStategey;
+    this.tagNamesToMatch = ['script'];
+  }
+
+  getFileNameFromTagSrc(src) {
+    const fileNameArr = src.split('/');
+    return fileNameArr[fileNameArr.length - 1];
+  }
+
+  addAttributestToTag(tag, attributes) {
+    tag.attributes = Object.assign({}, tag.attributes, attributes);
+  }
+
+  matchFileName(tag, fileName) {
+    return fileName.test(this.getFileNameFromTagSrc(tag.attributes.src));
+  }
+
+  blockingStrategy(tag) {
+    delete tag.attributes.defer;
+    delete tag.attributes.async;
+  }
+
+  deferStrategy(tag) {
+    delete tag.attributes.async;
+  }
+
+  asyncStrategy(tag) {
+    delete tag.attributes.defer;
+  }
+
+  moduleStrategy(tag) {
+    this.deferStrategy(tag);
+  }
+
+  matchStrategy(scriptLoadingStrategy, tag) {
+    if (scriptLoadingStrategy === 'blocking') {
+      this.blockingStrategy(tag);
+    }
+
+    if (scriptLoadingStrategy === 'defer') {
+      this.deferStrategy(tag);
+    }
+
+    if (scriptLoadingStrategy === 'async') {
+      this.asyncStrategy(tag);
+    }
+
+    if (scriptLoadingStrategy === 'module') {
+      this.moduleStrategy(tag);
+    }
+  }
+
+  matchAndApplyCustomLoadingStrategyToScripts(tags) {
+    Object.keys(this.scriptLoadingStrategy).forEach(scriptLoadingStrategy => {
+      const filesToMatch = this.scriptLoadingStrategy[scriptLoadingStrategy];
+      tags.forEach(tag => {
+        if (this.tagNamesToMatch.includes(tag.tagName) && tag.attributes.src) {
+          const isFileMatch = filesToMatch.some(fileName => this.matchFileName(tag, fileName));
+
+          if (isFileMatch) {
+            this.matchStrategy(scriptLoadingStrategy, tag);
+            this.addAttributestToTag(tag, {
+              [scriptLoadingStrategy]: true
+            });
+          }
+        } // filesToMatch.forEach(fileName => {
+        //   if (!this.matchFileName(tag, fileName)) {
+        //     return;
+        //   }
+        //   this.matchStrategy(scriptLoadingStrategy, tag);
+        //   this.addAttributestToTag(tag, fileName, {
+        //     [scriptLoadingStrategy]: true
+        //   });
+        // });
+
+      });
+    });
+  }
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      _htmlWebpackPlugin.default.getHooks(compilation).alterAssetTagGroups.tapAsync(pluginName, (data, callback) => {
+        const tags = [...data.bodyTags, ...data.headTags];
+        this.matchAndApplyCustomLoadingStrategyToScripts(tags);
+        callback(null, data);
+      });
+    });
+  }
+
+}
+
+exports.CustomScriptLoadingStrategyPlugin = CustomScriptLoadingStrategyPlugin;

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/EFCTemplatePlugin.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EFCTemplatePlugin = void 0;
+
+var _fs = require("fs");
+
+var _logger = require("../../../../logger");
+
+var _LocaleChunkAssetsStore = require("./I18nSplitPlugin/LocaleChunkAssetsStore");
+
+var _constants = require("../../../constants");
+
+var _getInitialAssetsFuncTemplate = require("./getInitialAssetsFuncTemplate");
+
+const INITIAL_ASSETS_TEMPLATE = '// <--getInitialAssets-->';
+const PUBLIC_PATH_TEMPLATE = '"<--publicPath-->"';
+const pluginName = 'EFCTemplatePlugin';
+
+class EFCTemplatePlugin {
+  constructor(options = {}) {
+    const {
+      i18nFileNameTemplate,
+      entryPointName,
+      outputFile,
+      version,
+      publicPath,
+      templateFilePath
+    } = options;
+    this.options = options;
+    this.templateFilePath = (0, _constants.joinWithAppPath)(templateFilePath);
+    this.i18nFileNameTemplate = i18nFileNameTemplate;
+    this.publicPath = publicPath; // NOTE: this logic may be needed for i18n splitted file name with contenthash cases
+    // this.i18nManifestFileName = options.i18nManifestFileName;
+    // IMPORTANT: here we merging options from package.json  and options via constructor
+    // So when debugging consider this as well
+    // this.options = Object.assign({}, efcOptions, options);
+
+    this.entryPointName = entryPointName || 'efc';
+    this.outputFile = outputFile.replace('[version]', version);
+  } // NOTE: this logic may be needed for i18n splitted file name with contenthash cases
+  // getI18nManifest(compilation) {
+  //   const i18nManifestFile =
+  //     compilation.assets[this.options.i18nManifestFileName];
+  //   if (i18nManifestFile) {
+  //     const manifest = JSON.parse(i18nManifestFile.source());
+  //     return manifest;
+  //   }
+  //   return {};
+  // }
+  // eslint-disable-next-line class-methods-use-this
+
+
+  templateReplacer(entryPoint, compilation) {
+    const {
+      enableRTLSplit
+    } = this.options; // const i18nManifest = this.getI18nManifest(compilation);
+
+    const initialAssetsFuncTemplate = (0, _getInitialAssetsFuncTemplate.getInitialAssetsFuncTemplate)({
+      entryPoint,
+      compilation,
+      enableRTLSplit,
+      i18nStore: this.store,
+      chunkSplitEnable: this.options.chunkSplitEnable,
+      i18nFileNameTemplate: this.i18nFileNameTemplate,
+      functionName: 'getInitialAssets'
+    });
+    const templateStr = (0, _fs.readFileSync)(this.templateFilePath).toString();
+    return templateStr.replace(INITIAL_ASSETS_TEMPLATE, initialAssetsFuncTemplate).replace(PUBLIC_PATH_TEMPLATE, this.publicPath);
+  }
+
+  apply(compiler) {
+    const {
+      RawSource
+    } = compiler.webpack.sources;
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Get store for cache
+      this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
+    });
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: compilation.PROCESS_ASSETS_STAGE_DERIVED
+      }, () => {
+        const {
+          entryPointName,
+          outputFile
+        } = this;
+        const entryPoint = compilation.entrypoints.get(entryPointName);
+
+        if (!entryPoint) {
+          return;
+        }
+
+        if (!(0, _fs.existsSync)(this.templateFilePath)) {
+          (0, _logger.errorLogger)(`EFC Template file not exists ${this.templateFilePath}`);
+          return;
+        }
+
+        const source = new RawSource(this.templateReplacer(entryPoint, compilation));
+        compilation.emitAsset(outputFile, source);
+        (0, _logger.messageLogger)('The EFC embedded code was created successfully..!!!');
+        (0, _logger.messageLogger)(`The EFC SDK File name ${outputFile}`);
+      });
+    });
+  }
+
+}
+
+exports.EFCTemplatePlugin = EFCTemplatePlugin;

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/ContributionGuide.md

@@ -0,0 +1,11 @@
+# I18n Split Plugin ContributionGuide
+we have modifyed mini-css-extract-plugin to sute our needs of i18n related extraction and downloading.
+So In future may be when we need to update mini-css-extract-plugin Kindly cross check with this I18n Plugin as well.
+
+Even not breaking change, may be just performacne update or feature update. addeding that to this plugin will be use full. Kindly consider it.
+
+## Thing we Ignored 
+ * we use webpack ast hook for adding I18nDependency. So we did not need `loader.js`
+ * we ignore order of import in single chunk since I18n going to be download as object.  
+      we did not need it.
+ * 

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/I18nFilesEmitPlugin.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.I18nFilesEmitPlugin = void 0;
+
+var _webpack = require("webpack");
+
+var _createHash = require("./createHash");
+
+var _pathCreator = require("./pathCreator");
+
+var _propertiesUtils = require("./utils/propertiesUtils");
+
+var _LocaleChunkAssetsStore = require("./LocaleChunkAssetsStore");
+
+/* eslint-disable no-restricted-syntax */
+const pluginName = 'I18nFilesEmitPlugin';
+const {
+  RawSource
+} = _webpack.sources;
+
+class I18nFilesEmitPlugin {
+  constructor(options) {
+    this.options = options; // this.options = {
+    //   locales: options.locales,
+    //   chunkFilename: options.chunkFilename,
+    //   filename: options.filename,
+    //   allI18nObject: options.allI18nObject,
+    //   jsonpFunc: options.jsonpFunc
+    // };
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Get store for cache
+      this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
+      const i18nStore = this.store;
+      compilation.hooks.beforeHash.tap(pluginName, () => {
+        i18nStore.clear();
+        this.createAndStoreFileContentForEveryChunkAndLocale(compilation);
+      });
+      compilation.hooks.chunkHash.tap(pluginName, (chunk, hash) => {
+        this.updateChunkHashForEveryLocale(chunk, hash);
+      });
+      compilation.hooks.contentHash.tap(pluginName, chunk => {
+        if (!i18nStore.isChunkHasI18n(chunk.id)) {
+          return;
+        }
+
+        this.emitI18nFileForEveryLocale(chunk, compilation);
+      });
+    });
+  }
+
+  createAndStoreFileContentForEveryChunkAndLocale(compilation) {
+    const {
+      chunks
+    } = compilation;
+    const {
+      locales
+    } = this.options;
+    const i18nStore = this.store;
+
+    for (const chunk of chunks) {
+      const i18nKeys = i18nStore.getI18nKeysForChunk(chunk);
+
+      if (!i18nKeys.length) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+
+      for (const locale of locales) {
+        const content = this.getI18nChunkFileContent(i18nKeys, locale);
+        i18nStore.storeData(chunk.id, locale, {
+          content
+        });
+      }
+    }
+  }
+
+  updateChunkHashForEveryLocale(chunk, hash) {
+    const {
+      locales
+    } = this.options;
+    const i18nStore = this.store;
+
+    if (i18nStore.isChunkHasI18n(chunk.id)) {
+      for (const loc of locales) {
+        const content = i18nStore.getContent(chunk.id, loc);
+        hash.update(content);
+      }
+    }
+  }
+
+  emitI18nFileForEveryLocale(chunk, compilation) {
+    const i18nStore = this.store;
+    const {
+      locales,
+      chunkFilename,
+      filename
+    } = this.options;
+    const fileNameTemplate = chunk.canBeInitial() ? filename : chunkFilename; // const { chunks } = compilation;
+
+    for (const locale of locales) {
+      const content = i18nStore.getContent(chunk.id, locale);
+      const contentHash = (0, _createHash.createHash)({
+        outputOptions: compilation.outputOptions,
+        content
+      });
+      const {
+        filename
+      } = I18nFilesEmitPlugin.createFilenameWithHash({
+        compilation,
+        contentHash,
+        fileNameTemplate,
+        chunk,
+        locale
+      });
+      i18nStore.storeData(chunk.id, locale, {
+        contentHash,
+        filename
+      });
+      compilation.emitAsset(filename, new RawSource(content));
+    }
+  }
+
+  static createFilenameWithHash({
+    compilation,
+    fileNameTemplate,
+    chunk,
+    locale,
+    contentHash
+  }) {
+    const fileName = fileNameTemplate.replaceAll('[locale]', locale);
+    const filename = (0, _pathCreator.pathCreator)(fileName, compilation, {
+      hash: compilation.hash,
+      locale,
+      chunkName: chunk.name,
+      chunkId: chunk.id,
+      chunkHash: chunk.hash,
+      contentHash
+    });
+    return {
+      contentHash,
+      filename
+    };
+  }
+
+  getI18nContentForkeys(i18nKeys, locale) {
+    const {
+      allI18nObject
+    } = this.options;
+    const data = {};
+
+    for (const key of i18nKeys) {
+      data[key] = allI18nObject[locale][key];
+    }
+
+    return data;
+  }
+
+  getI18nChunkFileContent(i18nKeys, loc) {
+    const {
+      jsonpFunc
+    } = this.options;
+    const data = this.getI18nContentForkeys(i18nKeys, loc);
+    return `${jsonpFunc}(${(0, _propertiesUtils.jsonToString)(data)})`;
+  }
+
+}
+
+exports.I18nFilesEmitPlugin = I18nFilesEmitPlugin;