@zohodesk/react-cli 1.1.27 → 1.1.28-exp.1

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

@@ -0,0 +1,18 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('default values as params', () => {
+  const inputCode = `function myFunction(x, y = 10) {
+  return x + y;
+}
+myFunction(5);`;
+  const outputCode = `function myFunction(x) {
+  let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+  return x + y;
+}
+myFunction(5);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,82 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('computed-properties', () => {
+  const inputCode = `var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar",
+};`;
+  const outputCode = `var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar"
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('unicode', () => {
+  const inputCode = `var string = "foo💩bar";
+var match = string.match(/foo(.)bar/u);`;
+  const outputCode = `var string = "foo💩bar";
+var match = string.match(/foo(.)bar/u);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('destructuring', () => {
+  const inputCode = `let { x, y } = obj;
+let [a, b, ...rest] = arr;`;
+  const outputCode = `let {
+  x,
+  y
+} = obj;
+let [a, b, ...rest] = arr;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('duplicate-keys', () => {
+  const inputCode = `var x = { a: 5, a: 6};
+var y = {
+  get a() {},
+  set a(x) {},
+  a: 3,
+};`;
+  const outputCode = `var x = {
+  a: 5,
+  a: 6
+};
+var y = {
+  get a() {},
+  set a(x) {},
+  a: 3
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('instance of', () => {
+  const inputCode = 'foo instanceof Bar;';
+  const outputCode = 'foo instanceof Bar;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('function name', () => {
+  const inputCode = 'let number = x => x;';
+  const outputCode = 'let number = x => x;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('template literals', () => {
+  // eslint-disable-next-line no-template-curly-in-string
+  const inputCode = '`foo${bar}`'; // eslint-disable-next-line no-template-curly-in-string
+
+  const outputCode = '`foo${bar}`;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('shorthand properties', () => {
+  const inputCode = 'var o = { a, b, c };';
+  const outputCode = `var o = {
+  a,
+  b,
+  c
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('for of loop', () => {
+  const inputCode = `const cars = ["BMW", "Volvo", "Mini"];
+let text = "";
+
+for (let x of cars) {
+  text += x + " ";
+}`;
+  const outputCode = `const cars = ["BMW", "Volvo", "Mini"];
+let text = "";
+for (let x of cars) {
+  text += x + " ";
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,22 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Promises', () => {
+  const inputCode = `const myPromise = new Promise(function(myResolve, myReject) {
+  myResolve();
+  myReject(); 
+});
+myPromise.then(
+  function(value) { /* code if successful */ },
+  function(error) { /* code if some error */ }
+);`;
+  const outputCode = `const myPromise = new Promise(function (myResolve, myReject) {
+  myResolve();
+  myReject();
+});
+myPromise.then(function (value) {/* code if successful */}, function (error) {/* code if some error */});`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('spread Ooperator', () => {
+  const inputCode = `const q1 = ["Jan", "Feb", "Mar"];
+const q2 = ["Apr", "May", "Jun"];
+const q3 = ["Jul", "Aug", "Sep"];
+const q4 = ["Oct", "Nov", "May"];
+
+const year = [...q1, ...q2, ...q3, ...q4];`;
+  const outputCode = `const q1 = ["Jan", "Feb", "Mar"];
+const q2 = ["Apr", "May", "Jun"];
+const q3 = ["Jul", "Aug", "Sep"];
+const q4 = ["Oct", "Nov", "May"];
+const year = [...q1, ...q2, ...q3, ...q4];`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Function Rest Parameter', () => {
+  const inputCode = `function sum(...args) {
+  let sum = 0;
+  for (let arg of args) sum += arg;
+  return sum;
+}
+let x = sum(4, 9, 16, 25, 29, 100, 66, 77);`;
+  const outputCode = `function sum() {
+  let sum = 0;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  for (let arg of args) sum += arg;
+  return sum;
+}
+let x = sum(4, 9, 16, 25, 29, 100, 66, 77);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,67 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string.includes() method', () => {
+  const inputCode = `let text = "Hello world, welcome to the universe.";
+text.includes("world")`;
+  const outputCode = `let text = "Hello world, welcome to the universe.";
+text.includes("world");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('string.startsWith() method', () => {
+  const inputCode = `let text = "Hello world, welcome to the universe.";
+text.startsWith("Hello")`;
+  const outputCode = `let text = "Hello world, welcome to the universe.";
+text.startsWith("Hello");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('string.endsWith() method', () => {
+  const inputCode = `var text = "John Doe";
+text.endsWith("Doe")`;
+  const outputCode = `var text = "John Doe";
+text.endsWith("Doe");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array.from method', () => {
+  const inputCode = 'Array.from("ABCDEFG")  ';
+  const outputCode = 'Array.from("ABCDEFG");';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array.keys method', () => {
+  const inputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+const keys = fruits.keys();`;
+  const outputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+const keys = fruits.keys();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array. finf method', () => {
+  const inputCode = ` const numbers = [4, 9, 16, 25, 29];
+let first = numbers.find(myFunction);
+
+function myFunction(value, index, array) {
+  return value > 18;
+}`;
+  const outputCode = `const numbers = [4, 9, 16, 25, 29];
+let first = numbers.find(myFunction);
+function myFunction(value, index, array) {
+  return value > 18;
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array.findIndex() method', () => {
+  const inputCode = `const numbers = [4, 9, 16, 25, 29];
+let first = numbers.findIndex(myFunction);
+
+function myFunction(value, index, array) {
+  return value > 18;
+} `;
+  const outputCode = `const numbers = [4, 9, 16, 25, 29];
+let first = numbers.findIndex(myFunction);
+function myFunction(value, index, array) {
+  return value > 18;
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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