@zohodesk/react-cli 1.1.27 → 1.1.28

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/AssignmentOperator.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('The &&= Operator', () => {
+  const inputCode = `let x = 10;
+x &&= 5;`;
+  const outputCode = `let x = 10;
+x &&= 5;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('The ||= Operator', () => {
+  const inputCode = `let x = 10;
+x ||= 5;`;
+  const outputCode = `let x = 10;
+x ||= 5;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('The ??= Operator', () => {
+  const inputCode = `let x = 10;
+x ??= 5;`;
+  const outputCode = `let x = 10;
+x ??= 5;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/Dynamic-Import.test.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Dynamic import', () => {
+  const inputCode = `let a = 10;
+fileimport('/components/file.js').then(File => {
+  File.show()
+});
+let file= await import('/components/file.js');`;
+  const outputCode = `let a = 10;
+fileimport('/components/file.js').then(File => {
+  File.show();
+});
+let file = await import('/components/file.js');`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/NullishOperator.test.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('The Nullish Coalescing Operator (??)', () => {
+  const inputCode = `let name = null;
+let text = "missing";
+let result = name ?? text; `;
+  const outputCode = `let name = null;
+let text = "missing";
+let result = name ?? text;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/bigInt.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('BigInt', () => {
+  const inputCode = `let x = 1234567890123456789012345n;
+let y = BigInt(1234567890123456789012345)`;
+  const outputCode = `let x = 1234567890123456789012345n;
+let y = BigInt(1234567890123456789012345);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/chainOperator.test.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('The Nullish Coalescing Operator (??)', () => {
+  const inputCode = `const car = {type:"Fiat", model:"500", color:"white"};
+let name = car?.name;`;
+  const outputCode = `const car = {
+  type: "Fiat",
+  model: "500",
+  color: "white"
+};
+let name = car?.name;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/export-namespace-from.test.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('export namespace', () => {
+  const inputCode = 'export * as ns from "mod";';
+  const outputCode = `import * as _ns from "mod";
+export { _ns as ns };`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/promiseAllSettledMathod.test.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('promise.allSettled()', () => {
+  const inputCode = `const promise1 = Promise.resolve(3);
+const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
+const promises = [promise1, promise2];
+Promise.allSettled(promises).then((results) => results.forEach((result) => console.log(result.status)));`;
+  const outputCode = `const promise1 = Promise.resolve(3);
+const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
+const promises = [promise1, promise2];
+Promise.allSettled(promises).then(results => results.forEach(result => console.log(result.status)));`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2020/stringMatchMethod.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string.matchAll method', () => {
+  const inputCode = `const iterator = text.matchAll("Cats");
+const iterator1 = text.matchAll(/Cats/g);`;
+  const outputCode = `const iterator = text.matchAll("Cats");
+const iterator1 = text.matchAll(/Cats/g);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2021/NumericSeparator.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('decimal literals', () => {
+  const inputCode = `const num1 = 1_000_000_000;
+const num2 = 1000000000;`;
+  const outputCode = `const num1 = 1_000_000_000;
+const num2 = 1000000000;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('binary literals', () => {
+  const inputCode = 'let message = 0xa0_b0_c0;';
+  const outputCode = 'let message = 0xa0_b0_c0;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('hex literals', () => {
+  const inputCode = 'const num1 = 0b1010_0001_1000_0101;';
+  const outputCode = 'const num1 = 0b1010_0001_1000_0101;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2021/logicalOperatorAssignments.test.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('nullish operator', () => {
+  const inputCode = `a ??= b;
+obj.a.b ??= c;`;
+  const outputCode = `a ??= b;
+obj.a.b ??= c;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('logical operators', () => {
+  const inputCode = `a ||= b;
+obj.a.b ||= c;
+
+a &&= b;
+obj.a.b &&= c;`;
+  const outputCode = `a ||= b;
+obj.a.b ||= c;
+a &&= b;
+obj.a.b &&= c;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2021/promiseAny.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('promise.any method', () => {
+  const inputCode = `const promise1 = new Promise(resolve => setTimeout(resolve, 100, 'quick'));
+const promise2 = new Promise(resolve => setTimeout(resolve, 500, 'slow'));
+const promises = [promise1, promise2];Promise.any(promises).then(value => console.log(value));`;
+  const outputCode = `const promise1 = new Promise(resolve => setTimeout(resolve, 100, 'quick'));
+const promise2 = new Promise(resolve => setTimeout(resolve, 500, 'slow'));
+const promises = [promise1, promise2];
+Promise.any(promises).then(value => console.log(value));`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2021/stringReplaceMethod.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string.replaceAll method', () => {
+  const inputCode = `let text = "I love cats. Cats are very easy to love. Cats are very popular."
+text = text.replaceAll("Cats","Dogs");
+text = text.replaceAll(/cats/g,"dogs");
+`;
+  const outputCode = `let text = "I love cats. Cats are very easy to love. Cats are very popular.";
+text = text.replaceAll("Cats", "Dogs");
+text = text.replaceAll(/cats/g, "dogs");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/Array-atMethod.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('array.at method', () => {
+  const inputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+let fruit = fruits.at(2);`;
+  const outputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+let fruit = fruits.at(2);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/ObjectKeyCheck.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('check for private fields', () => {
+  const inputCode = `class user{
+  #id ='12567890';
+  static userId(obj) {
+    if(!(#id in obj)) {
+      return 'Empty user';
+    }
+    return 'User ID: $\{ obj.#id}';
+  }
+}`;
+  const outputCode = `class user {
+  #id = '12567890';
+  static userId(obj) {
+    if (!(#id in obj)) {
+      return 'Empty user';
+    }
+    return 'User ID: $\{ obj.#id}';
+  }
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/ObjecthasOwnMethod.test.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object.hasOwn', () => {
+  const inputCode = `const uesr = {
+    name  :'john',
+    age : 20,
+}
+console.log(Object.hasOwn(uesr,'name'));`;
+  const outputCode = `const uesr = {
+  name: 'john',
+  age: 20
+};
+console.log(Object.hasOwn(uesr, 'name'));`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/RegexMatchIndices.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('regex match indices', () => {
+  const inputCode = `const regex = RegExp('foo', 'dg');
+const str = 'foobar,foobaz';
+const matches=[...str.matchAll(regex)];
+const firstMatch = match?.[0];
+const indices = firstMatcxh.indices?.[0];
+`;
+  const outputCode = `const regex = RegExp('foo', 'dg');
+const str = 'foobar,foobaz';
+const matches = [...str.matchAll(regex)];
+const firstMatch = match?.[0];
+const indices = firstMatcxh.indices?.[0];`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/String-atMethod.test.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string.at method', () => {
+  const inputCode = `const name = "W3Schools";
+let letter = name.at(2);
+let letter2 = name[1]`;
+  const outputCode = `const name = "W3Schools";
+let letter = name.at(2);
+let letter2 = name[1];`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/error.Cause.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('error.cause method', () => {
+  const inputCode = `try{
+  await fetch(item);
+}catch (error){
+  throw new Error("An error occured while fetching item",{
+    cause:error,
+  });
+}`;
+  const outputCode = `try {
+  await fetch(item);
+} catch (error) {
+  throw new Error("An error occured while fetching item", {
+    cause: error
+  });
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/keysCheckinPrivateFields.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Ergonomic Brand checks for Private Fields', () => {
+  const inputCode = `class User {
+    #id = "123";
+    static userId(obj){
+        if(!(#id in obj)){
+            return 'Empty user';
+        }
+        return obj.#id;
+    }
+}`;
+  const outputCode = `class User {
+  #id = "123";
+  static userId(obj) {
+    if (!(#id in obj)) {
+      return 'Empty user';
+    }
+    return obj.#id;
+  }
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/privateMethodsAndFields.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('private methods aand fields', () => {
+  const inputCode = `class Student {
+  name="john";
+  #password = "1234567890";
+  set #setPassword(hash){
+    this.#password = hash; 
+  }
+}`;
+  const outputCode = `class Student {
+  name = "john";
+  #password = "1234567890";
+  set #setPassword(hash) {
+    this.#password = hash;
+  }
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/staticFieldsAndMethod.test.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('static fields and methods', () => {
+  const inputCode = `class MyMath{
+    static PI = 3.14159;
+    static #E = 2.7899;
+    static #calc(){
+        return 10;
+    }
+}`;
+  const outputCode = `class MyMath {
+  static PI = 3.14159;
+  static #E = 2.7899;
+  static #calc() {
+    return 10;
+  }
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('static Block', () => {
+  const inputCode = `class Dictionary {
+    static words = [
+        {
+            type:'animal',
+            value:'cat'
+        }
+    ];
+    static animals = [];
+    static {
+        this.words.forEach(word=>{
+           if(word.type === 'animal'){
+              this.animals.push(word.value)
+           }
+        })
+    }
+}`;
+  const outputCode = `class Dictionary {
+  static words = [{
+    type: 'animal',
+    value: 'cat'
+  }];
+  static animals = [];
+  static #_ = this.words.forEach(word => {
+    if (word.type === 'animal') {
+      this.animals.push(word.value);
+    }
+  });
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/topLevelAwait.test.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Await import', () => {
+  const inputCode = 'const schema = await buildSchema();';
+  const outputCode = 'const schema = await buildSchema();';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2022/weakRef.test.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('weak ref', () => {
+  const inputCode = `let obj = { name: "Magiko" }
+const myRef = new WeakRef(obj) 
+myRef.deref()`;
+  const outputCode = `let obj = {
+  name: "Magiko"
+};
+const myRef = new WeakRef(obj);
+myRef.deref();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/utilities.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const babel = require('@babel/core');
+
+const options = {
+  presets: [[require.resolve('@babel/preset-env'), {
+    modules: false,
+    useBuiltIns: 'usage',
+    corejs: 3,
+    targets: {
+      browsers: [// 'chrome 111',
+      // 'edge 111',
+      // 'firefox 111',
+      // 'safari 16.2',
+      'chrome 104', 'edge 104', 'firefox 104', 'safari 15.5']
+    }
+  }], require.resolve('@babel/preset-react')]
+};
+
+function convertCode(code) {
+  const result = babel.transformSync(code, options);
+  return result.code;
+}
+
+module.exports = {
+  options,
+  convertCode
+};

package/packages/client_build_tool/lib/shared/babel/addDefaultPlugins.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDefaultPlugins = addDefaultPlugins;
+
+function addDefaultPlugins(plugin, pluginName) {
+  if (plugin.enable) {
+    return [require.resolve(pluginName), plugin.options];
+  }
+
+  ;
+  return null;
+}

package/packages/client_build_tool/lib/shared/babel/babelWebConfig.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.babelWebConfig = babelWebConfig;
+
+var _helperCompilationTargets = _interopRequireDefault(require("@babel/helper-compilation-targets"));
+
+var _logger = require("../../logger");
+
+var _getBabelPlugin = require("./getBabelPlugin");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-use-before-define */
+const supportedBrowserVersions = ['last 3 Chrome versions', 'last 3 Firefox versions', 'last 3 Edge versions', 'last 3 Safari versions'];
+
+function customBabelPlugins(babelPlugins) {
+  return babelPlugins.map(p => p).filter(Boolean);
+}
+
+function babelWebConfig(options, mode) {
+  const {
+    plugins: babelPlugins,
+    browserList
+  } = options.babelCustomizations;
+  const {
+    enable: typeScriptEnable
+  } = options.typeScript;
+  return {
+    presets: typeScriptEnable ? [getBabelPresetEnvConfig(browserList, mode), require.resolve('@babel/preset-react'), require.resolve('@babel/preset-typescript')] : [getBabelPresetEnvConfig(browserList, mode), require.resolve('@babel/preset-react')],
+    plugins: customBabelPlugins(babelPlugins).concat((0, _getBabelPlugin.getBabelPlugin)(options)).filter(Boolean)
+  };
+}
+
+function getBabelPresetEnvConfig(browserList, mode) {
+  if (mode === 'lib') {
+    return require.resolve('@babel/preset-env');
+  }
+
+  const browsers = browserList || supportedBrowserVersions;
+  (0, _logger.verboseLogger)('getTargets', (0, _helperCompilationTargets.default)({
+    browsers
+  }));
+  return [require.resolve('@babel/preset-env'), {
+    modules: false,
+    useBuiltIns: 'usage',
+    corejs: 3,
+    targets: {
+      browsers
+    }
+  }];
+}

package/packages/client_build_tool/lib/shared/babel/babel_plugins/removeAttributesPlugin.js

@@ -0,0 +1,23 @@
+"use strict";
+
+module.exports = () => ({
+  visitor: {
+    Program(path, state) {
+      let properties = state.opts.properties || [];
+
+      if (properties.length === 0) {
+        properties = properties.concat(state.opts.attributeNames);
+      }
+
+      path.traverse({
+        JSXIdentifier(path2) {
+          if (properties.indexOf(path2.node.name.toLowerCase()) > -1) {
+            path2.parentPath.remove();
+          }
+        }
+
+      });
+    }
+
+  }
+});

package/packages/client_build_tool/lib/shared/babel/getBabelPlugin.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBabelPlugin = getBabelPlugin;
+
+var _modeUtils = require("../bundler/webpack/common/modeUtils");
+
+var _addDefaultPlugins = require("./addDefaultPlugins");
+
+const babelPluginMapping = {
+  removeAttribute: './babel_plugins/removeAttributesPlugin',
+  removePropTypes: 'babel-plugin-transform-react-remove-prop-types',
+  devConsoleExclude: 'babel-plugin-transform-remove-console'
+};
+const babelPluginOrder = ['removeAttribute', 'removePropTypes', 'devConsoleExclude'];
+
+function getBabelPlugin(options) {
+  const {
+    mode
+  } = options;
+  let customPlugins = [];
+  const {
+    babelCustomizations
+  } = options;
+
+  if ((0, _modeUtils.isProductionMode)(mode)) {
+    const configCreator = _addDefaultPlugins.addDefaultPlugins;
+    const plugins = babelPluginOrder.map(p => configCreator(babelCustomizations[p], babelPluginMapping[p]));
+    customPlugins = plugins;
+  }
+
+  return customPlugins.filter(Boolean);
+}
+
+;