@zohodesk/client_build_tool 0.0.1

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/iterateModulesInChunk.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.iterateModulesInChunk = iterateModulesInChunk;
+
+var _ConcatenatedModule = _interopRequireDefault(require("webpack/lib/optimize/ConcatenatedModule"));
+
+var _getChunkModules = require("./utils/getChunkModules");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function iterateModulesInChunk({
+  chunk,
+  cb,
+  compilation
+}) {
+  let canStopLoop = false;
+
+  function stopLoop() {
+    canStopLoop = true;
+  }
+
+  function iterateNestedModules(mod) {
+    if (mod.resource) {
+      cb({
+        module: mod,
+        stop: stopLoop
+      });
+      return canStopLoop;
+    }
+
+    if (mod instanceof _ConcatenatedModule.default) {
+      const {
+        modules
+      } = mod;
+      return Array.from(modules).some(mod => iterateNestedModules(mod));
+    }
+
+    return canStopLoop;
+  } // eslint-disable-next-line no-restricted-syntax
+
+
+  for (const mod of (0, _getChunkModules.getChunkModules)(chunk, compilation)) {
+    if (iterateNestedModules(mod)) {
+      return;
+    }
+  }
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/optionsHandler.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.optionsHandler = optionsHandler;
+
+var _constants = require("./constants");
+
+var _readI18nValues = require("./readI18nValues");
+
+/* eslint-disable no-use-before-define */
+function optionsHandler(options) {
+  const {
+    disableDefault,
+    jsResource,
+    propertiesFolder
+  } = options;
+  const {
+    jsResourceI18nKeys,
+    allI18nObject,
+    locales
+  } = (0, _readI18nValues.readI18nValues)({
+    jsResource,
+    propertiesFolder,
+    disableDefault
+  });
+  return {
+    filename: options.filename || _constants.DEFAULT_FILENAME,
+    chunkFilename: options.chunkFilename || chunkNameDecider(options.filename),
+    mainChunkName: options.mainChunkName,
+    templateLabel: options.templateLabel,
+    publicPath: options.publicPath,
+    disableDefault: options.disableDefault,
+    i18nManifestFileName: options.i18nManifestFileName,
+    jsonpFunc: options.jsonpFunc,
+    localeVarName: options.localeVarName,
+    jsResource: options.jsResource,
+    propertiesFolder: options.propertiesFolder,
+    jsResourceI18nKeys,
+    allI18nObject,
+    locales,
+    // template: (object, locale) => `window.loadI18n(${JSON.stringify(object)}, ${JSON.stringify(locale)})`,
+    runtime: true,
+    runtimeOptions: {
+      insert: options.insert,
+      scriptType: typeof options.scriptType === 'boolean' && options.scriptType === true || typeof options.scriptType === 'undefined' ? 'text/javascript' : options.scriptType,
+      attributes: options.attributes
+    }
+  };
+}
+
+function chunkNameDecider(filename) {
+  if (typeof filename !== 'function') {
+    const hasName = filename.includes('[name]');
+    const hasId = filename.includes('[id]');
+    const hasChunkHash = filename.includes('[chunkhash]');
+    const hasContentHash = filename.includes('[contenthash]');
+
+    if (hasChunkHash || hasContentHash || hasName || hasId) {
+      return filename;
+    }
+
+    return filename.replace(/(^|\/)([^/]*(?:\?|$))/, '$1[id].$2');
+  }
+
+  return _constants.DEFAULT_CHUNK_FILENAME;
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/pathCreator.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathCreator = pathCreator;
+
+var _constants = require("./constants");
+
+function pathCreator(filenameTemplate, compilation, data) {
+  return compilation.getAssetPath(filenameTemplate.replace(/\[locale\]/gi, data.locale), {
+    hash: data.hash,
+    chunk: {
+      id: data.chunkId,
+      hash: data.chunkHash,
+      contentHash: {
+        [_constants.MODULE_TYPE]: data.contentHash
+      },
+      name: data.chunkName
+    },
+    contentHashType: _constants.MODULE_TYPE
+  });
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/readI18nValues.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readI18nValues = readI18nValues;
+
+var _propertiesUtils = require("./utils/propertiesUtils");
+
+// gethere i18n keys and values
+function readI18nValues({
+  jsResource,
+  propertiesFolder,
+  disableDefault
+}) {
+  const jsResourceI18nKeys = jsResource ? (0, _propertiesUtils.getPropertiesAsJSON)(jsResource) : {};
+  const allI18nObject = (0, _propertiesUtils.getAllI18n)({
+    folderPath: propertiesFolder,
+    disableDefault,
+    jsResourceI18nKeys
+  }); // initialize base data's and plugis
+
+  const locales = Object.keys(allI18nObject);
+  return {
+    jsResourceI18nKeys,
+    allI18nObject,
+    locales
+  };
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/templateFileName.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.templateFileName = templateFileName;
+
+var _webpack = require("webpack");
+
+var _templateHashHelpers = require("./templateHashHelpers");
+
+function templateFileName({
+  compilation,
+  dynamicFilename,
+  localeVarName,
+  chunks,
+  contentHashes
+}) {
+  const MODULE_TYPE = 'text/mini-i18n';
+  const {
+    mapExpr,
+    mapExprWithLength
+  } = (0, _templateHashHelpers.templateHashHelpers)(chunks); // "i18n-chunk/[locale]/[name].[chunkhash].js"
+
+  const i18nURLPathTemplate = compilation.getPath(JSON.stringify(dynamicFilename).replace(/\[locale\]/gi, '"+ locale +"'), {
+    hash: `" + ${_webpack.RuntimeGlobals.getFullHash}() + "`,
+    hashWithLength: length => `" + ${_webpack.RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+    chunk: {
+      id: '" + chunkId + "',
+      hash: mapExpr(c => c.renderedHash),
+      hashWithLength: mapExprWithLength(c => c.renderedHash),
+      name: mapExpr(c => c.name || c.id),
+      contentHash: {
+        [MODULE_TYPE]: mapExpr(c => contentHashes[c.id])
+      },
+      contentHashWithLength: {
+        [MODULE_TYPE]: mapExprWithLength(c => contentHashes[c.id])
+      }
+    },
+    contentHashType: MODULE_TYPE
+  });
+  return _webpack.Template.asString([`${_webpack.RuntimeGlobals.require}.miniI18nF = function(chunkId){var locale = (${localeVarName});return (${i18nURLPathTemplate})}`]);
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/templateHashHelpers.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.templateHashHelpers = templateHashHelpers;
+
+/**
+ * this function will be used for chunk name, chunk hash, contentHash
+ * in these, sometime chunk name and chunk id same for some chunkss so below logic has little towek
+ * @param {Chunk} chunks
+ * @returns { mapExpr, mapExprWithLength }
+ */
+function templateHashHelpers(chunks) {
+  /**
+   * @param {function(Chunk): string | number} fn function from chunk to value
+   * @returns {string} code with static mapping of results of fn
+   */
+  const createMap = fn => {
+    const obj = {};
+    let useId = false;
+    let lastKey;
+    let entries = 0; // eslint-disable-next-line no-restricted-syntax
+
+    for (const c of chunks) {
+      const value = fn(c);
+
+      if (value === c.id) {
+        useId = true;
+      } else {
+        obj[c.id] = value;
+        lastKey = c.id;
+        entries++;
+      }
+    }
+
+    if (entries === 0) {
+      return 'chunkId';
+    }
+
+    if (entries === 1) {
+      return useId ? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(obj[lastKey])} : chunkId)` : JSON.stringify(obj[lastKey]);
+    }
+
+    return useId ? `(${JSON.stringify(obj)}[chunkId] || chunkId)` : `${JSON.stringify(obj)}[chunkId]`;
+  };
+  /**
+   * @param {function(Chunk): string | number} fn function from chunk to value
+   * @returns {string} code with static mapping of results of fn for including in quoted string
+   */
+
+
+  const mapExpr = fn => `" + ${createMap(fn)} + "`;
+  /**
+   * @param {function(Chunk): string | number} fn function from chunk to value
+   * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
+   */
+
+
+  const mapExprWithLength = fn => length => // console.log('called with lentch', length),
+  `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
+
+  return {
+    mapExpr,
+    mapExprWithLength
+  };
+}
+/**
+  function mapExpr(fn) {
+    const obj = {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const c of chunks) {
+      obj[c.id] = fn(c);
+    }
+    return `(${JSON.stringify(obj)})[chunkId]`;
+  }
+ */

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/collectI18nKeys.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectI18nKeysfromAST = collectI18nKeysfromAST;
+exports.collectI18nKeysfromComments = collectI18nKeysfromComments;
+
+var _estreeWalker = require("estree-walker");
+
+function collectI18nKeysfromAST(ast, allI18n) {
+  const i18nKeys = {};
+  (0, _estreeWalker.walk)(ast, {
+    enter(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) {
+  const 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
+  const i18nKeys = {};
+  /* eslint-disable no-restricted-syntax */
+
+  for (const comment of comments) {
+    const keys = getI18nKeysFromComment(comment);
+
+    for (const key of keys) {
+      if (key && allI18n[key]) {
+        i18nKeys[key] = allI18n[key];
+      }
+    }
+  }
+  /* eslint-enable no-restricted-syntax */
+
+
+  return Object.keys(i18nKeys);
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/getChunkModules.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getChunkModules = getChunkModules;
+
+function getChunkModules(chunk, compilation) {
+  const {
+    chunkGraph
+  } = compilation || {};
+  return typeof chunkGraph !== 'undefined' ? chunkGraph.getChunkModules(chunk) : chunk.modulesIterable;
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/hashUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.REGEXP_CONTENTHASH = void 0;
+exports.hasContentHash = hasContentHash;
+// export const REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/gi;
+// export const REGEXP_HASH = /\[hash(?::(\d+))?\]/gi;
+// export const REGEXP_NAME = /\[name\]/gi;
+// export const REGEXP_PLACEHOLDERS = /\[(name|id|chunkhash)\]/gi;
+// TODO: want to choose file type for i18n load
+const REGEXP_CONTENTHASH = /\[contenthash(?::(\d+))?\]/gi;
+exports.REGEXP_CONTENTHASH = REGEXP_CONTENTHASH;
+
+function hasContentHash(filenameTemplate) {
+  REGEXP_CONTENTHASH.lastIndex = 0;
+  return REGEXP_CONTENTHASH.test(filenameTemplate);
+}

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _collectI18nKeys = require("./collectI18nKeys");
+
+Object.keys(_collectI18nKeys).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _collectI18nKeys[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _collectI18nKeys[key];
+    }
+  });
+});
+
+var _propertiesUtils = require("./propertiesUtils");
+
+Object.keys(_propertiesUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _propertiesUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _propertiesUtils[key];
+    }
+  });
+});

package/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/utils/propertiesUtils.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllI18n = getAllI18n;
+exports.getPropertiesAsJSON = getPropertiesAsJSON;
+exports.jsonToString = jsonToString;
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+var _constants = require("../../../../../constants");
+
+function isComment(line) {
+  return line[0] === '#';
+}
+
+function getPropertiesAsJSON(filePath) {
+  try {
+    const data = (0, _fs.readFileSync)(filePath);
+    const source = data.toString();
+    const i18nObj = {};
+    source.split(/\r?\n\r?/).forEach(fline => {
+      const line = fline.trim();
+
+      if (!line || isComment(line)) {
+        return;
+      }
+
+      const ind = line.indexOf('=');
+      const key = line.slice(0, ind).replace(/\\ /g, ' ');
+      const value = line.slice(ind + 1);
+
+      if (key && value) {
+        i18nObj[key] = value;
+      }
+    }, {});
+    return i18nObj;
+  } catch (err) {
+    return {};
+  }
+} // TODO: need to make it as custom option and  dynamic
+
+
+function getLang(file) {
+  const underScoreIndex = file.indexOf('_');
+  let language = 'en_US';
+
+  if (underScoreIndex !== -1) {
+    language = file.substring(underScoreIndex + 1);
+    language = language.slice(0, language.indexOf('.'));
+  }
+
+  return language;
+}
+
+function getAllI18n({
+  folderPath,
+  disableDefault,
+  jsResourceI18nKeys,
+  exclude = /^[^_]+$/,
+  include = /\.properties$/
+}) {
+  try {
+    const files = (0, _fs.readdirSync)(folderPath, 'utf8');
+    const allLangI18n = {};
+    const context = (0, _constants.joinWithAppPath)(folderPath);
+    files.forEach(file => {
+      const filePath = (0, _path.join)(context, file);
+
+      if (exclude.test(filePath) || !include.test(filePath)) {
+        return;
+      }
+
+      const i18n = getPropertiesAsJSON(filePath);
+      allLangI18n[getLang(file)] = disableDefault ? i18n : { ...jsResourceI18nKeys,
+        ...i18n
+      };
+    });
+    return allLangI18n;
+  } catch (err) {
+    console.log(err);
+    return {};
+  }
+}
+
+function jsonToString(json, keySeperator) {
+  let str = '{';
+  const keys = Object.keys(json);
+  keys.forEach((key, i) => {
+    const value = json[key];
+
+    if (!value) {
+      return;
+    }
+
+    str += `"${keySeperator ? key.replace(/(\.|\\(\s+))/g, keySeperator) : key}":"${value.replace(/.?"/g, match => {
+      if (match[0] === '\\') {
+        return match;
+      }
+
+      if (match.length === 2) {
+        return `${match[0]}\\${match[1]}`;
+      }
+
+      return `\\${match}`;
+    }).replace(/(\r\n|\n|\r)/g, '')}"`;
+
+    if (i !== keys.length - 1) {
+      str += ',';
+    }
+  });
+  str += '}';
+  return str;
+}
+/**
+ * not useable due to special charector
+ * 
+      return `{${Object.keys(data).map(key =>  `"${key}": "${data[key]}"`).join(",")}}`
+      // return JSON.stringify(data);
+      let str = "{";
+      for (const key of Object.keys(data)) {
+        str+= `"${key}": "${data[key]}",`
+      }
+      str+="}";
+      return str;
+ */

package/lib/shared/bundler/webpack/custom_plugins/InitialHtmlPlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InitialHtmlPlugin = void 0;
+
+var _htmlWebpackPlugin = _interopRequireDefault(require("html-webpack-plugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class InitialHtmlPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    const {
+      filename,
+      template,
+      minify,
+      inject,
+      mainChunkName
+    } = this.options;
+    new _htmlWebpackPlugin.default({
+      filename,
+      template,
+      minify,
+      chunks: [mainChunkName],
+      inject,
+      scriptLoading: 'defer'
+    }).apply(compiler);
+    compiler.hooks.thisCompilation.tap('InitialHtmlPlugin', compilation => {
+      _htmlWebpackPlugin.default.getHooks(compilation).alterAssetTagGroups.tapAsync('MyPlugin', (data, cb) => {
+        const headTags = [];
+        const bodyTags = [];
+        data.headTags.forEach(tag => {
+          if (tag.tagName === 'link') {
+            headTags.push(tag);
+          } else {
+            bodyTags.push(tag);
+          }
+        });
+        cb(null, { ...data,
+          headTags,
+          bodyTags
+        });
+      });
+    });
+  }
+
+}
+
+exports.InitialHtmlPlugin = InitialHtmlPlugin;

package/lib/shared/bundler/webpack/custom_plugins/ManifestJsonPlugin/addFilesNamesToManifestJson.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addFilesNamesToManifestJson = addFilesNamesToManifestJson;
+
+var _removeHashFromFileName = require("./removeHashFromFileName");
+
+function addFilesNamesToManifestJson({
+  manifestJson,
+  option,
+  assets,
+  hashDigestLength
+}) {
+  const json = manifestJson;
+  Object.keys(assets).forEach(filename => {
+    if (option.test(filename)) {
+      const filenameNameWithoutHash = (0, _removeHashFromFileName.removeHashFromFileName)(filename, hashDigestLength);
+      json[filenameNameWithoutHash] = filename;
+    }
+  });
+  return json;
+}

package/lib/shared/bundler/webpack/custom_plugins/ManifestJsonPlugin/createInitialEntries.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInitialEntriesForManifestJson = createInitialEntriesForManifestJson;
+
+var _removeHashFromFileName = require("./removeHashFromFileName");
+
+function createInitialEntriesForManifestJson(initialFileNames, hashLength) {
+  const initialEntries = {};
+  initialFileNames.forEach(fileName => {
+    const filenameNameWithoutHash = (0, _removeHashFromFileName.removeHashFromFileName)(fileName, hashLength);
+    initialEntries[filenameNameWithoutHash] = fileName;
+  });
+  return initialEntries;
+}

package/lib/shared/bundler/webpack/custom_plugins/ManifestJsonPlugin/createManifestJson.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createManifestJson = createManifestJson;
+
+var _findInitialFileNames = require("./findInitialFileNames");
+
+var _addFilesNamesToManifestJson = require("./addFilesNamesToManifestJson");
+
+var _createInitialEntries = require("./createInitialEntries");
+
+function createManifestJson({
+  option,
+  hashDigestLength,
+  compilation,
+  assets
+}) {
+  const manifestJson = {};
+
+  if (option.needInitialEntries) {
+    const initialFileNames = (0, _findInitialFileNames.findInitialFileNames)(compilation);
+    const initialEntries = (0, _createInitialEntries.createInitialEntriesForManifestJson)(initialFileNames, hashDigestLength);
+    manifestJson.initialEntries = initialEntries;
+  }
+
+  const outputJson = (0, _addFilesNamesToManifestJson.addFilesNamesToManifestJson)({
+    manifestJson,
+    option,
+    assets,
+    hashDigestLength
+  });
+  return outputJson;
+}