@zohodesk/react-cli 1.1.19-exp.11 → 1.1.19-exp.13

package/packages/client_build_tool/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/packages/client_build_tool/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/packages/client_build_tool/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/packages/client_build_tool/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/packages/client_build_tool/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/packages/client_build_tool/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/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/terser/__test__/classesAndObject.test.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const terser = require('terser');
+
+test('normal object', () => {
+  const code = `
+    const student = {
+    name: 'Sheldon',
+    score: 100,
+    grade: 'A',
+    }
+    console.log(student)
+    delete student.score
+    student.grade = 'F'
+    console.log(student)
+    student = {}
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('const student={name:"Sheldon",score:100,grade:"A"};console.log(student),delete student.score,student.grade="F",console.log(student),student={};');
+  });
+});
+test('Assignment shorthand syntax takes extra space', () => {
+  const code = `
+    const person = {
+    name: 'Tom',
+    age: '22',
+    };
+    const {name, age} = person;
+    console.log(name); // 'Tom'
+    console.log(age);  // '22'
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('const person={name:"Tom",age:"22"},{name:name,age:age}=person;console.log(name),console.log(age);');
+  });
+});
+test('minimize the name of parameter inside the class object', () => {
+  const code = `
+    class Dog {
+    constructor(name) {
+        this._name = name;
+    }
+    introduce() {
+        console.log('This is ' + this._name + ' !');
+    }
+    static bark() {
+        console.log('Woof!');
+    }
+    }
+    const myDog = new Dog('Buster');
+    myDog.introduce();
+    Dog.bark();
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('class Dog{constructor(o){this._name=o}introduce(){console.log("This is "+this._name+" !")}static bark(){console.log("Woof!")}}const myDog=new Dog("Buster");myDog.introduce(),Dog.bark();');
+  });
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/terser/__test__/conditionalOperation.test.js

@@ -0,0 +1,154 @@
+"use strict";
+
+/* eslint-disable max-lines */
+const terser = require('terser');
+
+describe('if condition', () => {
+  it('remove unused if condition with true value', () => {
+    const code = `
+
+          if (true) {
+             console.log('Mail sent to recipient');
+          }
+        `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('console.log("Mail sent to recipient");');
+    });
+  });
+  it('remove unused if condition with false value', () => {
+    const code = `
+          if (false) {
+             console.log('Mail sent to recipient');
+          }
+        `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('0;');
+    });
+  });
+  it('remove unused if statements when using a let or var type variable', () => {
+    const code = `
+          let isMailSent = true;
+
+          if (isMailSent) {
+             console.log('Mail sent to recipient');
+          }
+        `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('let isMailSent=!0;isMailSent&&console.log("Mail sent to recipient");');
+    });
+  });
+  it('remove unused if statements using a const variable', () => {
+    const code = `
+          const isMailSent = true;
+
+          if (isMailSent) {
+             console.log('Mail sent to recipient');
+          }
+        `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('const isMailSent=!0;console.log("Mail sent to recipient");');
+    });
+  });
+  it('if and else statement', () => {
+    const code = `
+          let isMailSent = true;
+
+          if (isMailSent) {
+             console.log('Mail sent to recipient');
+          }else{
+            console.log(3)
+          }
+          `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('let isMailSent=!0;isMailSent?console.log("Mail sent to recipient"):console.log(3);');
+    });
+  });
+  it('if and else statement returns same value', () => {
+    const code = `
+          let isMailSent = true;
+
+          if (isMailSent) {
+             console.log('Mail sent to recipient');
+          }else{
+            console.log('Mail sent to recipient');
+          }
+          `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('let isMailSent=!0;console.log("Mail sent to recipient");');
+    });
+  });
+  it('using else if statement return same value', () => {
+    const code = `
+          let isMailSent = true;
+
+          if (isMailSent) {
+             console.log('Mail sent to recipient');
+          }else if(!isMailSent){
+            console.log('Mail sent to recipient');
+          }
+          `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('let isMailSent=!0;isMailSent?console.log("Mail sent to recipient"):isMailSent||console.log("Mail sent to recipient");');
+    });
+  });
+  it('using else if statement return different value', () => {
+    const code = `
+          let isMailSent = true;
+          if (isMailSent) {
+             console.log('Mail sent to recipient');
+          }else if(isMailSent == 1){
+            console.log('Mail not sent to recipient');
+          }
+          `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('let isMailSent=!0;isMailSent?console.log("Mail sent to recipient"):1==isMailSent&&console.log("Mail not sent to recipient");');
+    });
+  });
+  it('skips the false content', () => {
+    const code = `
+        const size = 4;
+        if (size > 100) {
+          console.log('Big');
+        } else if (size > 20) {
+          console.log('Medium');
+        } else if (size > 4) {
+          console.log('Small');
+        } else {
+          console.log('Tiny');
+        }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('const size=4;console.log("Tiny");');
+    });
+  });
+});
+test('nullish operator', () => {
+  const code = `
+     const a = undefined;
+     console.log(undefined??"hi")
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('const a=void 0;console.log("hi");');
+  });
+});
+describe('switch Case', () => {
+  it('first value matched but runs for all', () => {
+    const code = `
+        const food = 'oyster';
+
+        switch (food) {
+         case 'oyster':
+             console.log('The taste of the sea');
+             break;
+         case 'pizza':
+             console.log('A delicious pie');
+             break;
+         default:
+             console.log('Enjoy your meal');
+}
+        `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('const food="oyster";switch(food){case"oyster":console.log("The taste of the sea");break;case"pizza":console.log("A delicious pie");break;default:console.log("Enjoy your meal")}');
+    });
+  });
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/terser/__test__/function.test.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const terser = require('terser');
+
+test('arrow function reducing the arguments name', () => {
+  const code = `
+     const sum = (param1, param2) => {
+        return param1 + param2;
+     };
+     console.log(sum(2, 5));
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('const sum=(o,s)=>o+s;console.log(sum(2,5));');
+  });
+});
+test('arrow function with console', () => {
+  const code = `
+    const printHello = () => {
+        console.log('hi')
+       return ('hello');
+    };
+    printHello();
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('const printHello=()=>(console.log("hi"),"hello");console.log("hi");');
+  });
+});
+test('remove unused or unwanted codes inside function', () => {
+  const code = `
+    function a(){
+       let x = 3;
+       let a = 1;
+       //this is a function
+       let result = (a == 1) ? true : false
+       result = (x == 1) ? true : false;
+    }
+    `;
+  return terser.minify(code).then(minify => {
+    expect(minify.code).toBe('function a(){let n=!0;n=!1}');
+  });
+});
+describe('function', () => {
+  it('Minify a simple function', () => {
+    const code = `
+      function sum(num1, num2) {
+        return num1 + num2;
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(n,u){return n+u}');
+    });
+  });
+  it('Minify a function with  a variable declaration', () => {
+    const code = `
+      function sum(num1, num2) {
+        var result = num1 + num2;
+        return result;
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(n,u){return n+u}');
+    });
+  });
+  it('Minify a function with a if condition', () => {
+    const code = `
+       function sum(num1, num2) {
+        if (num1 > num2) {
+          return num1;
+        } else {
+          return num2;
+        }
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(n,u){return n>u?n:u}');
+    });
+  });
+  it('Minify a function with return statement', () => {
+    const code = `
+      function sum(num1, num2) {
+        var result = num1 + num2;
+        return result;
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(n,u){return n+u}');
+    });
+  });
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/I18nSplitPlugin/terser/__test__/function2.test.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const terser = require('terser');
+
+describe('function', () => {
+  it('Minify a function with console.log', () => {
+    const code = `
+      function sum(num1, num2) {
+        var result = num1 + num2;
+        console.log(result)
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(o,n){var c=o+n;console.log(c)}');
+    });
+  });
+  it('Minify a function with return and console.log', () => {
+    const code = `
+      function sum(num1, num2) {
+        var result = num1 + num2;
+        console.log(result);
+        return result;
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(n,o){var r=n+o;return console.log(r),r}');
+    });
+  });
+  it('remove unused (dead codes) and unwanted variables inside the function', () => {
+    const code = `
+      function sum(num1, num2) {
+        var result = num1 + num2;
+        const functName = 'addition';
+        var i = 0;
+        return result;
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(n,u){return n+u}');
+    });
+  });
+  it('Minify a function with a for loop', () => {
+    const code = `
+      function sum(num1, num2) {
+        for (var i = 0; i < num1; i++) {
+            console.log(i)
+        }
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(o,n){for(var c=0;c<o;c++)console.log(c)}');
+    });
+  });
+  it('Minify a function with a if condition inside a for loop', () => {
+    const code = `
+      function sum(num1, num2) {
+        for (var i = 0; i < num1; i++) {
+          if(i > 0){
+            console.log(i)
+          }
+          else{
+            console.log(0);
+          }
+        }
+      }
+    `;
+    return terser.minify(code).then(minify => {
+      expect(minify.code).toBe('function sum(o,l){for(var n=0;n<o;n++)n>0?console.log(n):console.log(0)}');
+    });
+  });
+});