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

package/lib/plugins/CleanupStatsPlugin.js

@@ -1,42 +1,28 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 
-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; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var CleanUpStatsPlugin = function () {
-  function CleanUpStatsPlugin() {
-    _classCallCheck(this, CleanUpStatsPlugin);
+class CleanUpStatsPlugin {
+  shouldPickStatChild(child) {
+    return child.name.indexOf('mini-css-extract-plugin') !== 0;
   }
 
-  _createClass(CleanUpStatsPlugin, [{
-    key: 'shouldPickStatChild',
-    value: function shouldPickStatChild(child) {
-      return child.name.indexOf('mini-css-extract-plugin') !== 0;
-    }
-  }, {
-    key: 'apply',
-    value: function apply(compiler) {
-      var _this = this;
-
-      compiler.hooks.done.tap('CleanUpStatsPlugin', function (stats) {
-        var children = stats.compilation.children;
-
-        if (Array.isArray(children)) {
-          // eslint-disable-next-line no-param-reassign
-          stats.compilation.children = children.filter(function (child) {
-            return _this.shouldPickStatChild(child);
-          });
-        }
-      });
-    }
-  }]);
+  apply(compiler) {
+    compiler.hooks.done.tap('CleanUpStatsPlugin', stats => {
+      const {
+        children
+      } = stats.compilation;
+
+      if (Array.isArray(children)) {
+        // eslint-disable-next-line no-param-reassign
+        stats.compilation.children = children.filter(child => this.shouldPickStatChild(child));
+      }
+    });
+  }
 
-  return CleanUpStatsPlugin;
-}();
+}
 
 exports.default = CleanUpStatsPlugin;

package/lib/plugins/CustomAttributePlugin.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CustomAttributePlugin = void 0;
+
+var _Template = _interopRequireDefault(require("webpack/lib/Template"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-use-before-define */
+class CustomAttributePlugin {
+  constructor(options) {
+    this.options = {
+      jsAttributes: options.jsAttributes || options.attributes || {},
+      cssAttributes: options.cssAttributes || options.attributes || {},
+      i18nAttributes: options.i18nAttributes || options.attributes || {}
+    };
+  }
+
+  addCustomAttributeToDynamicScriptTags(mainTemplate) {
+    const {
+      jsAttributes,
+      cssAttributes,
+      i18nAttributes
+    } = this.options; // NOTE: To add custom Attributes to js Script tags
+
+    mainTemplate.hooks.jsonpScript.tap('CustomAttributePlugin', source => {
+      const str = attributeSetTemplate(jsAttributes, 'script');
+      return _Template.default.asString([source, ...str]);
+    }); // NOTE: To add custom Attributes to css link tags
+
+    mainTemplate.hooks.requireEnsure.tap('CustomAttributePlugin', source => {
+      const str = attributeSetTemplate(cssAttributes, 'linkTag');
+      const replacedStr = source.replace('head.appendChild(linkTag);', `${str.join('')}head.appendChild(linkTag);`);
+      console.log({
+        s: source,
+        r: replacedStr
+      });
+      return replacedStr;
+    }); // NOTE: To add custom Attributes to i18n split js Script tags
+
+    mainTemplate.hooks.requireEnsure.tap('CustomAttributePlugin', source => {
+      const str = attributeSetTemplate(i18nAttributes, 'scriptTag');
+      const replacedStr = source.replace('document.body.appendChild(scriptTag);', `${str.join('')}document.body.appendChild(scriptTag);`);
+      console.log({
+        s: source,
+        r: replacedStr
+      });
+      return replacedStr;
+    });
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap({
+      name: 'CustomAttributePlugin',
+      stage: 1,
+      fn: compilation => {
+        this.addCustomAttributeToDynamicScriptTags(compilation.mainTemplate);
+      }
+    });
+  }
+
+}
+
+exports.CustomAttributePlugin = CustomAttributePlugin;
+
+function attributeSetTemplate(jsAttributes, variableName) {
+  let str = [];
+  Object.keys(jsAttributes).forEach(key => {
+    const val = jsAttributes[key];
+    str.push(`${variableName}.setAttribute(${JSON.stringify(key)}, ${JSON.stringify(val)});`);
+  });
+  console.log({
+    str
+  });
+  return str;
+}

package/lib/plugins/CustomAttributePlugin.md

@@ -0,0 +1,35 @@
+# CustomAttributePlugin
+ In this plugin we added all dynamic chunks tags (like js script tags , css script tags, i18n split script tags) to extra custom attribute
+
+## Options
+
+```json
+{
+  "name": "some",
+  "react-cli": {
+    "app": {
+      "customAttributes": {// this is the all options
+        "enable": false,
+        "attributes": null,
+        "jsAttributes": null,
+        "cssAttributes": null,
+        "i18nAttributes": null
+      }
+  }
+}
+```
+
+### enable   [Boolean]
+this decides is this plugin or feature needs to be enabled of not.
+
+
+### attributes   [Object] 
+It  was object of key value pairs Example Given Option {"data-app-name":"myapp"}  
+Then all dynamically (js script tags , css script tags, i18n split script tags) added tags via webpack 
+
+### jsAttributes   [Object] 
+same as [attributes] but only for js script tags
+### cssAttributes   [Object] 
+same as [attributes] but only for css script tags
+### i18nAttributes   [Object] 
+same as [attributes] but only for i18n split script tags

package/lib/plugins/EFCPlugin.js

@@ -0,0 +1,185 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _webpackSources = require("webpack-sources");
+
+var _utils = require("../utils");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _getI18nFileUrlPathTemplate = require("./I18nSplitPlugin/utils/getI18nFileUrlPathTemplate");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import { getShortI18nAssets } from './I18nSplitPlugin/utils/hashUtils';
+const cliOptions = (0, _utils.getOptions)();
+const {
+  app: {
+    publicPaths
+  },
+  i18n: {
+    chunkSplitEnable
+  },
+  efc: efcOptios
+} = cliOptions;
+const {
+  createSDkFile
+} = efcOptios;
+
+class EFCPlugin {
+  constructor(options = {}) {
+    this.isDevelopment = options.isDevelopment;
+    this.serverUrl = options.serverUrl;
+    this.i18nFileNameTemplate = options.i18nFileNameTemplate; // this.i18nManifestFileName = options.i18nManifestFileName;
+
+    this.options = Object.assign({}, options); // this.options.i18nManifestFileName = options.i18nManifestFileName;
+
+    this.options.entryPointName = options.entryPointName || 'efc';
+    this.options.outputFile = efcOptios.outputFile.replace('[version]', efcOptios.version);
+    this.options.nameScope = options.nameScope || 'EFComponents';
+    this.options.localeAttr = options.localeAttr || 'efc-locale';
+  } // NOTE: this logic may be needed for contenthash cases
+  // getI18nManifest(compilation) {
+  //   const i18nManifestFile =
+  //     compilation.assets[this.options.i18nManifestFileName];
+  //   if (i18nManifestFile) {
+  //     const manifest = JSON.parse(i18nManifestFile.source());
+  //     return manifest;
+  //   }
+  //   return {};
+  // }
+
+
+  getI18nAssetsStr(entryPoint, compilation) {
+    if (!chunkSplitEnable) {
+      let i18nAsstes = {};
+      let i18nFiles = Object.keys(compilation.assets).filter(assert => assert.indexOf(`i18n${_path.default.sep}`) !== -1); //hook for i18n url contains i18n/ may cause problem
+
+      i18nAsstes = i18nFiles.reduce((res, i18nFilePath) => {
+        let fileName = i18nFilePath.replace(`i18n${_path.default.sep}`, '');
+        let splittedFileName = fileName.split('.');
+        res[splittedFileName[0]] = i18nFilePath;
+        return res;
+      }, {});
+      return `[${JSON.stringify(i18nAsstes)}[lang]]`;
+    }
+
+    let initalI18nAssets = entryPoint.chunks.map(chunk => (0, _getI18nFileUrlPathTemplate.getI18nFileUrlPathTemplate)(compilation, chunk, this.i18nFileNameTemplate, '@locale@'));
+    return `${JSON.stringify(initalI18nAssets)}.map(urlpath => urlpath.replace(/@locale@/g, lang))`;
+  }
+
+  createFileContent(compilation) {
+    const {
+      entryPointName,
+      localeAttr,
+      nameScope,
+      cdnVariableName = null
+    } = this.options;
+    const {
+      serverUrl
+    } = this; // const i18nManifest = this.getI18nManifest(compilation);
+
+    const entryPoint = compilation.entrypoints.get(entryPointName); // const chunk = compilation.namedChunks.get(entryPointName);
+
+    const [jsPath, cssPath,,, i18nJsPath] = !this.isDevelopment ? publicPaths : [];
+    const initialFiles = entryPoint.getFiles();
+    const filteredInitialFiles = initialFiles.filter(file => /\.(css|js)$/.test(file)); // const i18nAssets = getShortI18nAssets(
+    //   entryPoint.chunks,
+    //   i18nManifest,
+    //   i18nJsPath
+    // );
+
+    const initalI18nAssets = this.getI18nAssetsStr(entryPoint, compilation, i18nJsPath);
+    return `(() => {
+  let langEle = document.querySelector("[${localeAttr}]");
+  let lang = langEle ? langEle.getAttribute('${localeAttr}') : 'en_US';
+  let prod = !${this.isDevelopment};
+  let cdnVariableName = "${cdnVariableName}";
+  let assetURLs = {
+    //hook
+    js: ${JSON.stringify(jsPath || serverUrl)},
+    css: ${JSON.stringify(cssPath || serverUrl)},
+    i18n: ${JSON.stringify(i18nJsPath || serverUrl)}
+  };
+
+  window.desk_urls={}
+  window.desk_urls.staticDomain = 'https:' + assetURLs.js + '/';
+  if (prod && cdnVariableName) {
+    window["${cdnVariableName}"] = 'https:' + assetURLs.css + '/';
+  }
+
+  let initalI18nAssets = ${initalI18nAssets}.map(urlpath => "${i18nJsPath}/"+ urlpath);
+  let initialAssets = initalI18nAssets.concat(${JSON.stringify(filteredInitialFiles)});
+
+  let loadAsset = (id, type, url) => {
+    return new Promise((res, rej) => {
+      let el = document.createElement(type);
+      // el.id = id;
+      el.onload = res;
+      el.error = rej;
+      switch(type) {
+        case 'script':
+        case 'i18n':
+          el.src = (type === 'i18n'? assetURLs.i18n : assetURLs.js)+'/'+url
+          el.defer = 'defer';
+          document.body.appendChild(el);
+          break;
+        case 'link':
+          el.href = assetURLs.css+'/'+url
+          el.rel = 'stylesheet';
+          document.head.appendChild(el);
+          break;
+      }
+    });
+  };
+
+  let memorizedPromise = null;
+  ${nameScope}.onload = (cb, err) => {
+    if(!memorizedPromise) {
+      memorizedPromise = Promise.all(
+        initialAssets.map(
+          (url, index) => loadAsset(
+            "${nameScope}-" + (url.endsWith("js") ? "js" : "css")  +"-"+index,
+            url.endsWith("js") ? url.endsWith(".i18n.js") ? "i18n" : 'script' : 'link',
+            url
+          )
+        )
+      ).then(() => ${nameScope}.onBasicLoad(cb));
+    }
+    return memorizedPromise;
+  };
+
+  })();
+`;
+  }
+
+  apply(compiler) {
+    if (!createSDkFile) {
+      return;
+    }
+
+    compiler.hooks.emit.tap('EFCPlugin', compilation => {
+      const {
+        entryPointName,
+        outputFile
+      } = this.options;
+      const entryPoint = compilation.entrypoints.get(entryPointName);
+
+      if (!entryPoint) {
+        return;
+      }
+
+      const source = new _webpackSources.RawSource(this.createFileContent(compilation));
+      compilation.assets[outputFile] = source; // eslint-disable-next-line no-console
+
+      console.log('The EFC embedded code was created successfully..!!!');
+    });
+  }
+
+}
+
+exports.default = EFCPlugin;

package/lib/plugins/I18NInjectIntoIndexPlugin.js

@@ -1,75 +1,141 @@
-'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 _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
 
-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 _utils = require("../utils");
 
-var _path = require('path');
+var _urlConcat = require("../utils/urlConcat");
 
-var _path2 = _interopRequireDefault(_path);
+var _path = _interopRequireDefault(require("path"));
 
-var _webpackSources = require('webpack-sources');
+var _webpackSources = require("webpack-sources");
+
+var _hashUtils = require("./I18nSplitPlugin/utils/hashUtils");
+
+var _getI18nFileUrlPathTemplate = require("./I18nSplitPlugin/utils/getI18nFileUrlPathTemplate");
 
 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"); } }
+let i18nObj = null;
+let options = (0, _utils.getOptions)();
 
-var i18nObj = null;
+function newAssign(target, data) {
+  return Object.assign({}, target, data);
+}
 
-var I18NInjectIntoIndexPlugin = function () {
-  function I18NInjectIntoIndexPlugin(options) {
-    _classCallCheck(this, I18NInjectIntoIndexPlugin);
+const {
+  i18n
+} = options;
 
-    this.isDevelopment = options.mode === 'dev' || options.mode === 'prod' || options.mode === 'dev-no-warn';
+class I18NInjectIntoIndexPlugin {
+  constructor(options) {
+    this.isDevelopment = options.isDevelopment;
+    this.i18nFileNameTemplate = options.i18nFileNameTemplate;
     this.publicPath = options.publicPath;
+    this.templateLabel = options.templateLabel || '{{--user-locale}}';
+    this.i18nManifestFileName = options.i18nManifestFileName;
+    this.entryPointName = options.mainChunkName;
+  }
+
+  getI18nFileUrlPath(chunk, compilation) {
+    let urlpath = (0, _getI18nFileUrlPathTemplate.getI18nFileUrlPathTemplate)(compilation, chunk, this.i18nFileNameTemplate, this.templateLabel);
+    return (0, _urlConcat.urlConcat)(this.publicPath, urlpath);
+  }
+
+  getI18nManifest(compilation) {
+    const i18nManifestFile = compilation.assets[this.i18nManifestFileName];
+
+    if (!i18nManifestFile) {
+      return {};
+    }
+
+    const manifest = JSON.parse(i18nManifestFile.source());
+    return manifest;
+  }
+
+  injectI18nURLsToHTML(compilation) {
+    _htmlWebpackPlugin.default.getHooks(compilation).beforeAssetTagGeneration.tapAsync('I18NInjectIntoIndexPlugin', (data, cb) => {
+      const {
+        assets
+      } = data; // Manipulate the content
+
+      const i18nManifest = this.getI18nManifest(compilation);
+      const entryPoint = compilation.entrypoints.get(this.entryPointName);
+      const i18nScriptURLs = entryPoint.chunks.filter(c => !!i18nManifest[c.id]).map(c => this.getI18nFileUrlPath(c, compilation)); // .map(url => getI18nScriptTagObj(url));
+      // .join('');
+      // Tell webpack to move on
+
+      cb(null, newAssign(data, {
+        assets: newAssign(assets, {
+          js: i18nScriptURLs.concat(assets.js)
+        })
+      }));
+    });
   }
 
-  _createClass(I18NInjectIntoIndexPlugin, [{
-    key: 'apply',
-    value: function apply(compiler) {
-      var _this = this;
-
-      compiler.hooks.emit.tap('I18NInjectIntoIndexPlugin', function (compilation) {
-        // let cdns = Object.keys(this.publicPaths);
-        if (i18nObj === null) {
-          var i18nFiles = Object.keys(compilation.assets).filter(function (assert) {
-            return assert.indexOf('i18n' + _path2.default.sep) !== -1;
-          });
-          //hook for i18n url contains i18n/ may cause problem
-          i18nObj = i18nFiles.reduce(function (res, next) {
-            var fileName = next.replace('i18n' + _path2.default.sep, '');
-            var splittedFileName = fileName.split('.');
-            if (_this.isDevelopment) {
-              res[splittedFileName[0]] = _this.publicPath + '/i18n/' + fileName;
-            } else {
-              res[splittedFileName[0]] = fileName;
-            }
-            return res;
-          }, {});
-        }
-
-        var _Object$keys$filter = Object.keys(compilation.assets).filter(function (filename) {
-          return (/\.html$/g.test(filename)
-          );
-        }),
-            _Object$keys$filter2 = _slicedToArray(_Object$keys$filter, 1),
-            indexFile = _Object$keys$filter2[0];
-
-        if (indexFile) {
-          var source = compilation.assets[indexFile].source();
-          compilation.assets[indexFile] = new _webpackSources.RawSource(source.replace(new RegExp('<!--I18nInfoToServer(.*)I18nInfoToServer-->', 'g'), function (match, arg) {
-            return match.replace(arg, JSON.stringify(i18nObj));
-          }));
-        }
+  withI18nSpitHandling(compiler) {
+    compiler.hooks.make.tap('I18NInjectIntoIndexPlugin', compilation => {
+      // let cdns = Object.keys(this.publicPaths);
+      // console.log('compilation.assets', Object.keys(compilation.assets).filter(a => a.includes('i18n')));
+      if (!(0, _hashUtils.hasContentHash)(this.i18nFileNameTemplate)) {
+        this.injectI18nURLsToHTML(compilation);
+        return;
+      }
+
+      _htmlWebpackPlugin.default.getHooks(compilation).beforeEmit.tapAsync('I18NInjectIntoIndexPlugin', (data, cb) => {
+        // Manipulate the content
+        const i18nManifest = this.getI18nManifest(compilation);
+        const entryPoint = compilation.entrypoints.get(this.entryPointName);
+        let i18nAssets = (0, _hashUtils.getShortI18nAssets)(entryPoint.chunks, i18nManifest, this.publicPath);
+        data.html = data.html.replace(new RegExp('<!--I18nInfoToServer(.*?)I18nInfoToServer-->', 'g'), (match, arg) => match.replace(arg, JSON.stringify(i18nAssets))); // Tell webpack to move on
+
+        cb(null, data);
       });
+    });
+  }
+
+  apply(compiler) {
+    if (i18n.chunkSplitEnable) {
+      this.withI18nSpitHandling(compiler);
+    } else {
+      this.withoutI18nSpitHandling(compiler);
     }
-  }]);
+  }
+
+  withoutI18nSpitHandling(compiler) {
+    compiler.hooks.emit.tap('I18NInjectIntoIndexPlugin', compilation => {
+      // let cdns = Object.keys(this.publicPaths);
+      if (i18nObj === null) {
+        let i18nFiles = Object.keys(compilation.assets).filter(assert => assert.indexOf(`i18n${_path.default.sep}`) !== -1); //hook for i18n url contains i18n/ may cause problem
+
+        i18nObj = i18nFiles.reduce((res, next) => {
+          let fileName = next.replace(`i18n${_path.default.sep}`, '');
+          let splittedFileName = fileName.split('.');
+          /* if (this.isDevelopment) {
+            res[splittedFileName[0]] = `${this.publicPath}/i18n/${fileName}`;
+          } else {
+            res[splittedFileName[0]] = fileName;
+          } */
+
+          res[splittedFileName[0]] = `${this.publicPath}/i18n/${fileName}`;
+          return res;
+        }, {});
+      }
+
+      let [indexFile] = Object.keys(compilation.assets).filter(filename => /\.html$/g.test(filename));
+
+      if (indexFile) {
+        let source = compilation.assets[indexFile].source();
+        compilation.assets[indexFile] = new _webpackSources.RawSource(source.replace(new RegExp('<!--I18nInfoToServer(.*)I18nInfoToServer-->', 'g'), (match, arg) => match.replace(arg, JSON.stringify(i18nObj))));
+      }
+    });
+  }
 
-  return I18NInjectIntoIndexPlugin;
-}();
+}
 
 exports.default = I18NInjectIntoIndexPlugin;

package/lib/plugins/I18nSplitPlugin/I18nDebugPlugin.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+const pluginName = 'I18nDebugPlugin'; // this plugin  only for debug  related purpose
+
+class I18nDebugPlugin {
+  constructor(jsResourceI18nKeys) {
+    this.jsResourceI18nKeys = jsResourceI18nKeys;
+    this.warnings = [];
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation, compilationParams) => {
+      // TEMP : only for debugging purpose
+      this.compilation1 = compilation;
+      this.compilationParams = compilationParams.normalModuleFactory;
+    });
+    compiler.hooks.normalModuleFactory.tap(pluginName, factory => {
+      if (!this.compilationParams || this.compilationParams.normalModuleFactory === factory) {
+        return;
+      } // console.log('skiped');
+
+
+      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));
+          i18nKeys.length && this.warnings.push({
+            message: 'skiped i18n keys',
+            reason: 'may be some child compiler',
+            fileName: module.resource,
+            i18nKeys
+          });
+        });
+      };
+
+      factory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
+      factory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler); // factory.hooks.parser.for('javascript/esm').tap(pluginName, handler);
+    });
+  }
+
+}
+
+exports.default = I18nDebugPlugin;

package/lib/plugins/I18nSplitPlugin/I18nDependency.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.I18nDependencyTemplate = exports.I18nDependency = void 0;
+
+var _webpack = require("webpack");
+
+// const webpack = require('webpack');
+class I18nDependency extends _webpack.Dependency {
+  constructor({
+    identifier,
+    i18nKeys
+  }, context, identifierIndex) {
+    super();
+    this.identifier = identifier;
+    this.identifierIndex = identifierIndex;
+    this.i18nKeys = i18nKeys;
+    this.context = context;
+  }
+
+  getResourceIdentifier() {
+    return `i18n-module-${this.identifier}-${this.identifierIndex}`;
+  }
+
+}
+
+exports.I18nDependency = I18nDependency;
+
+class I18nDependencyTemplate {
+  //eslint-disable-next-line no-empty-function
+  apply() {} // apply(dep, source) {
+  // if (typeof dep.range === "number") {
+  // source.insert(0, `/* comment by I18nSplitPlugin , i18n keys = ${JSON.stringify(dep.i18nKeys)} */`);
+  // 	return;
+  // }
+  // source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
+  // }
+
+
+}
+
+exports.I18nDependencyTemplate = I18nDependencyTemplate;