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

package/lib/plugins/I18nSplitPlugin/I18nFilesEmitter.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _webpackSources = require("webpack-sources");
+
+var _utils = require("./utils");
+
+var _getI18nKeysFormModules = _interopRequireDefault(require("./utils/getI18nKeysFormModules"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * this plugin was creating the chunk specific i18n chunk's.
+ */
+// this plugin's kick  starter is apply method
+const pluginName = 'I18nFilesEmitter';
+const MODULE_TYPE = 'json/i18n';
+
+const i18ntype = locale => `${MODULE_TYPE}/${locale}`;
+
+class I18nFilesEmitter {
+  constructor({
+    allI18nObject,
+    i18nManifestFileName,
+    filenameTemplate,
+    locales,
+    jsonpFunc
+  }) {
+    this.locales = locales;
+    this.allI18nObject = allI18nObject;
+    this.filenameTemplate = filenameTemplate; // this.filenameTemplate =  "i18n-chunk/[locale]/[name].js"
+
+    this.jsonpFunc = jsonpFunc;
+    this.prevHashes = {};
+    this.i18nManifestFileName = i18nManifestFileName;
+  }
+
+  emitAsset(compilation, filename, source, info) {
+    // NOTE: info support  available since webpack v4.40.0 https://webpack.js.org/api/stats/#asset-objects
+    if (!compilation.emitAsset) {
+      compilation.assets[filename] = source;
+    } else {
+      compilation.emitAsset(filename, source, info);
+    }
+  } // this method for create object and assign value for i18nkeys
+
+
+  getI18nObjectByLocale(i18nKeys, locale) {
+    const data = {};
+    i18nKeys.forEach(key => {
+      data[key] = this.allI18nObject[locale][key];
+    });
+    return data;
+  }
+
+  getTemplateString(i18nKeys, locale) {
+    let i18nObject = this.getI18nObjectByLocale(i18nKeys, locale);
+    return `${this.jsonpFunc}(${(0, _utils.jsonToString)(i18nObject)});`; // return `${this.jsonpFunc}(JSON.parse(${JSON.stringify(jsonToString(i18nObject))}));`;
+  }
+
+  renderI18nLocaleChunk(chunk, locale, i18nKeys) {
+    // renderI18nLocaleChunk(chunk, locale, i18nKeys, compilation) {
+    const filenameTemplate = this.filenameTemplate.replace(/\[locale\]/g, locale);
+    const pathOptions = {
+      chunk,
+      contentHashType: i18ntype(locale)
+    };
+    return {
+      render: () => new _webpackSources.RawSource(this.getTemplateString(i18nKeys, locale)),
+      filenameTemplate,
+      pathOptions,
+      identifier: `${pluginName}.${chunk.id}.${locale}`,
+      hash: chunk.contentHash[i18ntype(locale)]
+    };
+  }
+
+  emitI18nFilesForChunk(chunk, compilation) {
+    const i18nKeys = (0, _getI18nKeysFormModules.default)(chunk.modulesIterable);
+    const manifestForChunk = {
+      assets: {},
+      hasI18n: false,
+      hasChanges: false
+    };
+
+    if (!i18nKeys.length) {
+      // why  it is not checked as 0
+      return manifestForChunk;
+    }
+
+    manifestForChunk.hasI18n = true; // const locales  = ['en_US'];
+
+    this.locales.forEach(locale => {
+      const result = this.renderI18nLocaleChunk(chunk, locale, i18nKeys, compilation);
+      const {
+        filenameTemplate,
+        pathOptions,
+        render,
+        identifier,
+        hash
+      } = result;
+      const filePath = compilation.getPath(filenameTemplate, pathOptions);
+      manifestForChunk.assets[locale] = filePath;
+
+      if (this.prevHashes[identifier] === hash) {
+        return;
+      }
+
+      manifestForChunk.hasChanges = true;
+      this.prevHashes[identifier] = hash;
+      this.emitAsset(compilation, filePath, render(), {
+        locale,
+        chunkId: chunk.id,
+        chunkName: chunk.name
+      }); // compilation.assets[filePath] = render();
+    });
+    return manifestForChunk;
+  }
+
+  emitI18nAssert(compilation) {
+    let manifest = {};
+    let needEmitManifest = false;
+    compilation.chunks.forEach(chunk => {
+      const manifestForChunk = this.emitI18nFilesForChunk(chunk, compilation);
+
+      if (manifestForChunk.hasI18n) {
+        manifest[chunk.id] = manifestForChunk.assets;
+        needEmitManifest = needEmitManifest || manifestForChunk.hasChanges;
+      }
+    });
+
+    if (needEmitManifest) {
+      const manifestSource = new _webpackSources.RawSource(JSON.stringify(manifest));
+      this.emitAsset(compilation, this.i18nManifestFileName, manifestSource, {
+        desc: 'this file is has chunks-locales-assets mapping'
+      });
+    }
+  }
+
+  apply(compiler) {
+    /*
+      compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+        compilation.mainTemplate.hooks.renderManifest.tap(
+          pluginName,
+          (result, { chunk }) => {
+            this.renderChunk(result, compilation, chunk);
+          }
+        );
+           compilation.chunkTemplate.hooks.renderManifest.tap(
+          pluginName,
+          (result, { chunk }) => {
+            this.renderChunk(result, compilation, chunk);
+          }
+        );
+      });
+      */
+    // this below hook was tapped for create asssets(file) for chunk specific i18nChunk Files
+    compiler.hooks.emit.tap(pluginName, compilation => {
+      this.emitI18nAssert(compilation);
+    });
+  }
+  /*
+    renderChunk(result, compilation, chunk) {
+      const i18nKeys = getI18nKeysFormModules(chunk.modulesIterable);
+      // TODO: need to discuss with vimal ji can we chose this place for add i18n locale files ????
+      // IDEA:  we chose this place for add i18n locale files ????
+      if (i18nKeys.length > 0) {
+        Object.keys(this.allI18nObject).forEach(locale => {
+          result.push(
+            this.renderI18nLocaleChunk(chunk, locale, i18nKeys, compilation)
+          );
+        });
+      }
+    }
+    */
+
+
+}
+
+exports.default = I18nFilesEmitter;

package/lib/plugins/I18nSplitPlugin/I18nKeysIdentifer.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+var _I18nDependency = require("./I18nDependency");
+
+var _NullFactory = _interopRequireDefault(require("webpack/lib/NullFactory"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pluginName = 'I18nKeysIdentifer';
+/**
+ * this plugin search the i18 keys and make it as I18nDependency.
+ * how it works?
+ *  this plugin get jsResourceI18nKeys in constructor.
+ *  we walk throught the js files AST
+ *      if any string literal in that AST is in jsResourceI18nKeys then  we consider that string as I18n key
+ *  after the walk of AST we get some I18n keys
+ *  then we make it as I18nDependency.
+ */
+
+class I18nKeysIdentifer {
+  constructor(jsResourceI18nKeys) {
+    this.jsResourceI18nKeys = jsResourceI18nKeys;
+  }
+
+  defineConfigarationForI18nDependency(compilation) {
+    compilation.dependencyFactories.set(_I18nDependency.I18nDependency, new _NullFactory.default());
+    compilation.dependencyTemplates.set(_I18nDependency.I18nDependency, new _I18nDependency.I18nDependencyTemplate());
+  }
+
+  addI18nDependency(module, i18nKeys) {
+    const identifier = `i18n ${module.resource}`;
+    const dep = new _I18nDependency.I18nDependency({
+      identifier,
+      i18nKeys
+    }, module.context, 0);
+    module.addDependency(dep); // console.log('module', i18nKeys, identifier);
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation, params) => {
+      // this below  hook was tapped for  we use I18nDependency
+      // so we must define module factory for I18nDependency
+      // and we must define how  it  import statement look like I18nDependencyTemplate
+      this.defineConfigarationForI18nDependency(compilation); // handler for parser
+
+      let handler = parser => {
+        parser.hooks.program.tap(pluginName, (ast, commmets) => {
+          const {
+            module
+          } = parser.state; //
+
+          if (!(module && /\.jsx?$/.test(module.resource))) {
+            return;
+          } // i18n grep proper contract regex
+
+
+          let i18nKeys = (0, _utils.collectI18nKeysfromAST)(ast, this.jsResourceI18nKeys);
+          i18nKeys = i18nKeys.concat( // i18n grep proper contract regex
+          (0, _utils.collectI18nKeysfromComments)(commmets, this.jsResourceI18nKeys));
+
+          if (i18nKeys.length) {
+            // console.log(
+            //   'i18nKeys.length',
+            //   module.resource,
+            //   i18nKeys.length < 5 ? i18nKeys : i18nKeys.length
+            // );
+            this.addI18nDependency(module, i18nKeys);
+          }
+        });
+      }; // this below  hook was tapped for collect I18n Key from files and add as Deppenensy
+
+
+      const factory = params.normalModuleFactory;
+      factory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
+      factory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler);
+    });
+  }
+
+}
+
+exports.default = I18nKeysIdentifer;
+
+I18nKeysIdentifer.isChunkHasI18n = function (chunk) {
+  for (const module of chunk.modulesIterable) {
+    for (const dep of module.dependencies) {
+      if (dep instanceof _I18nDependency.I18nDependency) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};

package/lib/plugins/I18nSplitPlugin/I18nSplit.md

@@ -0,0 +1,86 @@
+# I18n Split As Chunks Plugin
+
+generaly we have manage our all I18n keys and values as language specific i18n files and then we download all i18n in initial page load.
+
+### what is the problem with this?.
+the problem is i18n file keep get's grown it will affect the the inital page load and critial rendering path.
+So, We have decide to create a plugin for split i18n per chunk's of js vise.
+
+### what is i18n split?
+  it is like code split for i18n.
+  we will collect i18n from js chunk and we will create separate i18n chunk per js chunk,
+   with this we already load Js chunks are on demand and now we also download i18n also ondemand with this the initial and forthere actions.
+  when js download's we will download i18n with it.  
+
+###  How to we going to i18n split?
+  we will read the js chunk and collect I18n keys form it,
+  then we will create i18n chunk files with these used keys.
+
+### how do you collect i18n keys from js files?
+  we will traverse the js file's AST (static analysis) and find i18 keys,
+  we will concider all string which is in jsResource file as i18n keys.
+  and you can tell dynamic i18n key by js comments,
+  Like Below:- 
+  ```js
+  fetch("tickets?view=view1").then(data => {
+    // I18n support.ticketsEmpty
+    // I18n support.viewNotFount
+    // I18n support.permissionDenied
+    let text = getI18nValue(data.i18nkey);
+  })
+  ```
+
+### is there any posiblity for unwanted keys in some chunk?
+  Yes, there is two posiblity
+  1. js comment , if you write js comment but it is  not needed then it will be add into i18n chunk
+    `To Resolve` we currently do not have perfect idea for this, But we can check this  by chunk size limit.
+    `idea's will be welcome`
+  2. like we said "we will concider all string which is in jsResource file as i18n keys",
+     So if you use string not for i18n but it was in jsResource then it will be add into i18n chunk.
+     `To Resolve` this  problem we can use some  kinda prefix or something. 
+
+### how do we downlowd and give to app?
+  we have over write defualt webpack requireEnsure (every dynamic chunk requests are done by that function) function.
+  and we parlarly dowload i18n files. and we ask jsonFunction, to our plugin.
+So we send i18nkeys , when it was download,
+you must store all i18n keys, we give asycrnsly by that function download in that patticular.
+so you must store and update (like append or assign) everytime that function call.
+
+### how to use this feature?
+  to use this feature use have give the below oprtions
+  `package.json`
+  ```json
+  {
+    /// ...some things
+    "react-cli": {
+      //  ...some things
+      "i18n": {   
+        "chunkSplitEnable": true,
+        "jsResource": "./deskapp/properties/JSResources.properties",
+        "localeVarName": "window.userInfo.langCode",
+        "jsonpFunc": "window.loadI18nChunk",
+        "templateLabel": "{{--user-locale}}",// this is  for html template i18n file path locate template
+        "propertiesFolder": "./deskapp/properties"
+      },
+      //  ...some things
+    }
+  }
+  ```
+
+
+<!-- not need below -->
+<!-- 
+
+### is there any problems with static analysis?
+  Yes, 
+
+### how do we use dynamic i18n key?
+
+  and we will download i18n file with 
+
+  and when js chunk download's then we will download i18n as need.
+  we all know in our app we loading i18n as one single big file for each locale(language).
+  we are going to split i18n as per js chunk, and when js chunk download's then we will download i18n as need. 
+  
+  
+  -->

package/lib/plugins/I18nSplitPlugin/README.md

@@ -0,0 +1,25 @@
+# I18n Split As Chunks Plugin
+
+generaly we have manage our all I18n keys and values as language specific i18n files and then we download all i18n in initial page load.
+
+Ok, what is the problem with this?.
+the problem is i18n file keep get's grown it will affect the the inital page load and critial rendering path.
+So, We have decide to create a plugin for split i18n per chunk's of js vise, Which mean we diside to create for each js chunk has its own i18n chunks, with this we already load Js chunks are on demand and now we also download i18n also ondemand with this the initial and forthere actions.
+
+Ok, How to you do this thing?
+we have read the js chunk and collect I18n keys what are used in that chunk and we will create i18n chunk files with only used key.
+
+Ok, How do you collect that keys?
+we now have two expremental statrge to collect I18n keys.
+
+1. we read jsResource.properties (or all keys I18n file) then we walk this AST of js and we collect all string which is jsResource.properties.
+2. for dynamic we discide to use comment some thing like
+   `// I18n support.tickekt.email.notvalid`
+
+ok, how do you downlowd and give to app?
+we have over write defualt webpack require ensure function.
+So every dynamic chunk requset are done by that function.
+So we parlarly dowload i18n files. and we ask jsonFunction, to our plugin.
+So we send i18nkeys , when it was download,
+you must store all i18n keys, we give asycrnsly by that function download in that patticular.
+so you must store and update (like append or assign) everytime that function call.

package/lib/plugins/I18nSplitPlugin/index.js

@@ -0,0 +1,185 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+var _webpack = require("webpack");
+
+var _I18nKeysIdentifer = _interopRequireDefault(require("./I18nKeysIdentifer"));
+
+var _I18nFilesEmitter = _interopRequireDefault(require("./I18nFilesEmitter"));
+
+var _I18nDownlodLogic = _interopRequireDefault(require("./I18nDownlodLogic"));
+
+var _getI18nKeysFormModules = _interopRequireDefault(require("./utils/getI18nKeysFormModules"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// #region initial
+
+/**
+ * @TODO:
+ *  [?] add comment line options for properties file and get all keys form property file do right way to genarate them
+ *  [?] need to discuss with collectI18n Keys with js comment need to conform "what is the comment? "
+ */
+
+/**
+ * Notes: this plugin has done below works
+ *  1. collect I18n Keys from js files and make it as Depenencies
+ *  2. we create file(asset) for chunk specific i18nChunk Files
+ *  3. create hash for the specific i18nChunk Files
+ *  4. write logic to requireEnsure method for dowlod I18n chunk download dynamicaly
+ *  5. create manifest.json file which has the mapping of  chunk-locales-i18nChunkFile
+ *       for the external referrece.
+ * Hints :-
+ *   - file  means your machine files
+ *   - asset means that also  file but that will create by webpack after build
+ */
+// const getI18nLocales = require('./utils/getI18nLocales');
+// const { ConcatSource, SourceMapSource, OriginalSource } = sources;
+const {
+  createHash
+} = _webpack.util;
+const MODULE_TYPE = 'json/i18n';
+
+const i18ntype = locale => `${MODULE_TYPE}/${locale}`;
+
+const pluginName = 'i18n-plugin';
+/**
+ * @typedef I18nPluginOptions
+ * @property {String} filenameTemplate this was template for i18n chunk
+ * @property {String} jsResource this was path for jsResource i18n file
+ * @property {String} propertiesFolder this was path for propertiesFolder i18n file
+ * @property {Boolean} disableDefault this option for disable defulat value  for i18n keys, means if the language file does not have some key we don't give jsResource value
+ * @property {String} i18nManifestFileName this was ouput path for i18n manifest.
+ * @property {String} jsonpFunc this was function name, we will  call  that function everytime i18n chunk download.
+ * @property {String} localeVarName this was variable name, we will call that function everytime i18n chunk download.
+ * 
+ */
+
+class I18nPlugin {
+  constructor(options = {}) {
+    // initialize options
+    this.options = Object.assign({
+      filenameTemplate: 'i18n/[locale]/[name].i18n.js'
+    }, options);
+    const {
+      filenameTemplate,
+      publicPath,
+      localeVarName,
+      i18nManifestFileName,
+      disableDefault,
+      jsResource,
+      propertiesFolder,
+      jsonpFunc
+    } = this.options;
+    this.publicPath = publicPath; // gethere i18n keys and values
+
+    this.jsResourceI18nKeys = jsResource ? (0, _utils.getPropertiesAsJSON)(jsResource) : {};
+    this.allI18nObject = (0, _utils.getAllI18n)({
+      folderPath: propertiesFolder,
+      disableDefault,
+      jsResourceI18nKeys: this.jsResourceI18nKeys
+    }); // initialize base data's and plugis
+
+    this.locales = Object.keys(this.allI18nObject);
+    this.i18nKeysIdentifer = new _I18nKeysIdentifer.default(this.jsResourceI18nKeys);
+    this.i18nFilesEmitter = new _I18nFilesEmitter.default({
+      allI18nObject: this.allI18nObject,
+      locales: this.locales,
+      i18nManifestFileName,
+      filenameTemplate,
+      jsonpFunc
+    });
+    this.i18nDownlodLogic = new _I18nDownlodLogic.default({
+      filenameTemplate,
+      publicPath,
+      locales: this.locales,
+      localeVarName
+    });
+  }
+
+  maintainHashForAllI18nAssets(compilation) {
+    /**
+     * we write chunkHash logic inside of our plugin Because we only add Dependency not Module.
+     *  So we need to update chunkHash for our assets
+     *  and we not able tell with just Modules.
+     *  Because, if we add Module for the Depenentcy then that module must has some hash.
+     *  But our I18n Hash is no module specific it was chunk specific,
+     *  that's why we do the stuf in the chunkHash hook.
+     */
+    compilation.hooks.chunkHash.tap(pluginName, (chunk, chunkHash) => {
+      const {
+        outputOptions
+      } = compilation;
+      const {
+        hashFunction,
+        hashDigest,
+        hashDigestLength
+      } = outputOptions;
+      const i18nKeys = (0, _getI18nKeysFormModules.default)(chunk.modulesIterable);
+
+      if (!i18nKeys.length) {
+        return;
+      }
+
+      const {
+        contentHash
+      } = chunk; // contentHash = {
+      //   javascript: 'abcd2938',
+      //   'css/mini-extract': 'askdijasod'
+      // };
+
+      this.locales.forEach(locale => {
+        const contentHashStr = createHash(hashFunction).update(this.i18nFilesEmitter.getTemplateString(i18nKeys, locale)).digest(hashDigest);
+        contentHash[i18ntype(locale)] = contentHashStr.substring(0, hashDigestLength);
+        chunkHash.update(contentHashStr);
+      });
+    });
+  }
+
+  apply(compiler) {
+    this.i18nKeysIdentifer.apply(compiler);
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // this below  hook was tapped for hash for the specific i18nChunk Files and write logic to requireEnsure
+      this.maintainHashForAllI18nAssets(compilation); // const { mainTemplate } = compilation;
+      // this.addDownloadLogicOfI18nInMainTemplate(mainTemplate);
+    });
+    this.i18nFilesEmitter.apply(compiler);
+    this.i18nDownlodLogic.apply(compiler);
+  }
+
+}
+/*
+        // TODO:  need to reimplement this logic
+        // NOTE:  this logic for split all content hash per mani chunk
+        // like add chunk content hash to  main locale i18n file
+
+        // let isEntry = chunk.name === this.options.mainChunkName;
+        // if (chunk.name === 'main' && chunk.hasEntryModule()) {
+        if (isEntry) {
+          const hashSource = new ConcatSource();
+        const dummyChunk = new chunk.constructor();
+          hashSource.add('// it wil be I18N file hash');
+          const templateHooks = compilation.chunkTemplate.hooks;
+          let c = templateHooks.render.call(
+            templateHooks.module.call(
+              hashSource,
+              dummyChunk,
+              compilation.moduleTemplate.javascript,
+              compilation.dependencyTemplates
+            ),
+            dummyChunk,
+            compilation.moduleTemplate.javascript,
+            compilation.dependencyTemplates
+          );
+          console.log('entry, ', c, hashSource.toString());
+        }
+        */
+
+
+exports.default = I18nPlugin;

package/lib/plugins/I18nSplitPlugin/utils/collectI18nKeys.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectI18nKeysfromAST = collectI18nKeysfromAST;
+exports.collectI18nKeysfromComments = collectI18nKeysfromComments;
+
+const {
+  walk
+} = require('estree-walker');
+
+function collectI18nKeysfromAST(ast, allI18n) {
+  let i18nKeys = {};
+  walk(ast, {
+    enter: function (node) {
+      if (node.type === 'Literal') {
+        if ((node.raw[0] === '\'' || node.raw[0] === '"') && Object.hasOwnProperty.call(allI18n, node.value)) {
+          i18nKeys[node.value] = allI18n[node.value];
+        }
+      }
+    }
+  });
+  return Object.keys(i18nKeys);
+}
+
+const prefixI18nComment = 'I18N';
+const prefixI18nComment1 = 'dynamic-i18n-key';
+
+function getI18nKeysFromComment(comment) {
+  let commentString = comment.value.trim();
+  let i18nKeyStr;
+
+  if (commentString.startsWith(prefixI18nComment)) {
+    i18nKeyStr = commentString.slice(prefixI18nComment.length).trim();
+  } else if (commentString.startsWith(prefixI18nComment1)) {
+    i18nKeyStr = commentString.slice(prefixI18nComment1.length).trim();
+  }
+
+  if (!i18nKeyStr) {
+    return [];
+  }
+
+  const i18nKeys = i18nKeyStr.split(',');
+  return i18nKeys;
+} // export function fromComments(comments, allI18n) {
+
+
+function collectI18nKeysfromComments(comments, allI18n) {
+  // TODO: need to implement
+  let i18nKeys = {};
+
+  for (let comment of comments) {
+    let keys = getI18nKeysFromComment(comment);
+
+    for (let key of keys) {
+      if (key && allI18n[key]) {
+        i18nKeys[key] = allI18n[key];
+      }
+    }
+  }
+
+  return Object.keys(i18nKeys);
+}

package/lib/plugins/I18nSplitPlugin/utils/getI18nFileUrlPathTemplate.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getI18nFileUrlPathTemplate = getI18nFileUrlPathTemplate;
+
+function getI18nFileUrlPathTemplate(compilation, chunk, filenameTemplate, localeTemplate) {
+  let urlpath = compilation.getPath(filenameTemplate, {
+    chunk
+  });
+  return urlpath.replace('[locale]', localeTemplate);
+}

package/lib/plugins/I18nSplitPlugin/utils/getI18nKeysFormModules.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getI18nKeysFormModules;
+
+var _I18nDependency = require("../I18nDependency");
+
+function getI18nKeysFormModules(modules) {
+  const i18nTemObj = {};
+
+  for (let m of modules) {
+    for (let dep of m.dependencies) {
+      if (!(dep instanceof _I18nDependency.I18nDependency)) {
+        continue;
+      }
+
+      for (const key of dep.i18nKeys) {
+        i18nTemObj[key] = 1;
+      }
+    }
+  }
+
+  return Object.keys(i18nTemObj);
+}