@zohodesk/react-cli 1.1.16-exp.3 → 1.1.16-exp.4

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/variables.test.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('keyword var', () => {
+  const inputCode = 'var name = "sam"';
+  const outputCode = 'var name = "sam";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('keyword let', () => {
+  const inputCode = 'let name = "sam"';
+  const outputCode = 'let name = "sam";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('keyword const', () => {
+  const inputCode = 'const name = "sam"';
+  const outputCode = 'const name = "sam";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2016/array-includes.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Exponentation operator', () => {
+  const inputCode = `let array =[1,2,4];
+console.log(array.includes(2));`;
+  const outputCode = `let array = [1, 2, 4];
+console.log(array.includes(2));`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2016/exponentationOperator.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Exponentation operator', () => {
+  const inputCode = `let x = 5;
+let z = x ** 2;`;
+  const outputCode = `let x = 5;
+let z = x ** 2;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Exponentation assignment operator', () => {
+  const inputCode = `let x = 5;
+x **=2;`;
+  const outputCode = `let x = 5;
+x **= 2;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2017/asyncAndawait.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('async function', () => {
+  const inputCode = `async function myDisplay() {
+  let myPromise = new Promise(function(myResolve, myReject) {
+    setTimeout(function() { myResolve("I love You !!"); }, 3000);
+  });
+  document.getElementById("demo").innerHTML = await myPromise;
+}`;
+  const outputCode = `async function myDisplay() {
+  let myPromise = new Promise(function (myResolve, myReject) {
+    setTimeout(function () {
+      myResolve("I love You !!");
+    }, 3000);
+  });
+  document.getElementById("demo").innerHTML = await myPromise;
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2017/object-entries.test.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object.entries() method', () => {
+  const inputCode = `const person = {
+  firstName : "John",
+  lastName : "Doe",
+  age : 50,
+  eyeColor : "blue"
+};
+
+let text = Object.entries(person);`;
+  const outputCode = `const person = {
+  firstName: "John",
+  lastName: "Doe",
+  age: 50,
+  eyeColor: "blue"
+};
+let text = Object.entries(person);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2017/object-getOwnproperties.test.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object.getOwnPropertyDescriptors() method', () => {
+  const inputCode = `const obj = {
+  foo: 'bar',
+  get baz() {
+    return this.foo;
+  }
+};
+
+const descriptors = Object.getOwnPropertyDescriptors(obj);`;
+  const outputCode = `const obj = {
+  foo: 'bar',
+  get baz() {
+    return this.foo;
+  }
+};
+const descriptors = Object.getOwnPropertyDescriptors(obj);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2017/object-values.test.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object.values() method', () => {
+  const inputCode = `const person = {
+  firstName : "John",
+  lastName : "Doe",
+  age : 50,
+  eyeColor : "blue"
+};
+
+let text = Object.values(person);`;
+  const outputCode = `const person = {
+  firstName: "John",
+  lastName: "Doe",
+  age: 50,
+  eyeColor: "blue"
+};
+let text = Object.values(person);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2017/stringMethods.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string padStart() method', () => {
+  const inputCode = `let text = "5";
+text = text.padStart(4,0);`;
+  const outputCode = `let text = "5";
+text = text.padStart(4, 0);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('string padEnd() method', () => {
+  const inputCode = `let text = "5";
+text = text.padEnd(4,0);`;
+  const outputCode = `let text = "5";
+text = text.padEnd(4, 0);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2018/asynchronous-iterator.test.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('asynchronous iterator', () => {
+  const inputCode = `async function process(array) {
+  for await (let i of array) {
+    doSomething(i);
+  }
+}`;
+  const outputCode = `async function process(array) {
+  for await (let i of array) {
+    doSomething(i);
+  }
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2018/object-rest-spread.test.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object rest spread operator', () => {
+  const inputCode = `let object = {
+  a: '01', b: '02'
+};
+let newObject = {
+  c: '03',
+  ...object
+};`;
+  const outputCode = `let object = {
+  a: '01',
+  b: '02'
+};
+let newObject = {
+  c: '03',
+  ...object
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2018/promise-finally.test.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('promise.finally', () => {
+  const inputCode = `function doSomething() {
+  doSomething1()
+  .then(doSomething2)
+  .catch(err => {
+    console.log(err);
+  })
+  .finally(() => {
+     console.log("completed");
+  });
+}`;
+  const outputCode = `function doSomething() {
+  doSomething1().then(doSomething2).catch(err => {
+    console.log(err);
+  }).finally(() => {
+    console.log("completed");
+  });
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2018/regularExpressions.test.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('regex exec method', () => {
+  const inputCode = `const str = "The quick brown fox jumps over the lazy dog.";
+const regex = /quick (\\w+) fox/;
+
+const result = regex.exec(str);`;
+  const outputCode = `const str = "The quick brown fox jumps over the lazy dog.";
+const regex = /quick (\\w+) fox/;
+const result = regex.exec(str);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('unicode escape', () => {
+  const inputCode = `const reGreekSymbol = /\\p{Script=Greek}/u;
+reGreekSymbol.test('π');`;
+  const outputCode = `const reGreekSymbol = /\\p{Script=Greek}/u;
+reGreekSymbol.test('π');`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('dot in regex', () => {
+  const inputCode = '/./su;';
+  const outputCode = '/./su;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('named-capturing-groups-regex', () => {
+  const inputCode = `var re = /(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})/;
+console.log(re.exec("1999-02-29").groups.year);`;
+  const outputCode = `var re = /(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})/;
+console.log(re.exec("1999-02-29").groups.year);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2019/Json.stringify.test.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('JSON.stringify() method', () => {
+  const inputCode = `const obj = {
+  name: "John",
+  age: 30,
+  city: "New York"
+};
+const jsonString = JSON.stringify(obj);`;
+  const outputCode = `const obj = {
+  name: "John",
+  age: 30,
+  city: "New York"
+};
+const jsonString = JSON.stringify(obj);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2019/arrayMethods.test.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('array.flat()', () => {
+  const inputCode = `const myArr = [[1,2],[3,4],[5,6]];
+const newArr = myArr.flat();`;
+  const outputCode = `const myArr = [[1, 2], [3, 4], [5, 6]];
+const newArr = myArr.flat();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('array.flatMap()', () => {
+  const inputCode = `const myArr = [1, 2, 3, 4, 5, 6];
+    const newArr = myArr.flatMap((x) => x * 2); `;
+  const outputCode = `const myArr = [1, 2, 3, 4, 5, 6];
+const newArr = myArr.flatMap(x => x * 2);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('array.sort()', () => {
+  const inputCode = `const numbers=[1,2,3,4,5,6];
+numbers.sort((a,b)=>{
+    return a-b;
+})`;
+  const outputCode = `const numbers = [1, 2, 3, 4, 5, 6];
+numbers.sort((a, b) => {
+  return a - b;
+});`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2019/object-fromEntriesMethod.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object.fromEntries() method', () => {
+  const inputCode = `const fruits = [["apples", 300],["pears", 900],["bananas", 500]];
+const myObj = Object.fromEntries(fruits);`;
+  const outputCode = `const fruits = [["apples", 300], ["pears", 900], ["bananas", 500]];
+const myObj = Object.fromEntries(fruits);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2019/optionalCatchBinding.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('optional-catch-binding', () => {
+  const inputCode = `try {
+  throw 0;
+} catch {
+  doSomethingWhichDoesNotCareAboutTheValueThrown();
+} finally {
+  doSomeCleanup();
+}`;
+  const outputCode = `try {
+  throw 0;
+} catch {
+  doSomethingWhichDoesNotCareAboutTheValueThrown();
+} finally {
+  doSomeCleanup();
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2019/revisedFunctionToString.test.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('convert function to string', () => {
+  const inputCode = `function myFunction(p1, p2) {
+  return p1 * p2;
+}
+let a = myFunction.toString();`;
+  const outputCode = `function myFunction(p1, p2) {
+  return p1 * p2;
+}
+let a = myFunction.toString();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2019/trim-startAndend-method.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string.trimStart() Method', () => {
+  const inputCode = `let text1 = "     Hello World!     ";
+let text2 = text1.trimStart();`;
+  const outputCode = `let text1 = "     Hello World!     ";
+let text2 = text1.trimStart();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('string.trimEnd() Method', () => {
+  const inputCode = `let text1 = "     Hello World!     ";
+let text2 = text1.trimEnd();`;
+  const outputCode = `let text1 = "     Hello World!     ";
+let text2 = text1.trimEnd();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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);
+});