424d2f6965
## Description
This PR upgrades Prettier to v2 + enforces TypeScript’s [`import
type`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#type-only-imports-and-export)
syntax where applicable. It’s submitted as a separate PR so we can merge
it easily.
As a part of this PR, we reformat the codebase heavily:
- add `import type` everywhere where it’s required, and
- re-format the code to account for Prettier 2’s breaking changes:
https://prettier.io/blog/2020/03/21/2.0.0.html#breaking-changes
This PR is submitted against `release` to make sure all new code by team
members will adhere to new formatting standards, and we’ll have fewer
conflicts when merging `bundle-optimizations` into `release`. (I’ll
merge `release` back into `bundle-optimizations` once this PR is
merged.)
### Why is this needed?
This PR is needed because, for the Lodash optimization from
7cbb12af88,
we need to use `import type`. Otherwise, `babel-plugin-lodash` complains
that `LoDashStatic` is not a lodash function.
However, just using `import type` in the current codebase will give you
this:
<img width="962" alt="Screenshot 2023-03-08 at 17 45 59"
src="https://user-images.githubusercontent.com/2953267/223775744-407afa0c-e8b9-44a1-90f9-b879348da57f.png">
That’s because Prettier 1 can’t parse `import type` at all. To parse it,
we need to upgrade to Prettier 2.
### Why enforce `import type`?
Apart from just enabling `import type` support, this PR enforces
specifying `import type` everywhere it’s needed. (Developers will get
immediate TypeScript and ESLint errors when they forget to do so.)
I’m doing this because I believe `import type` improves DX and makes
refactorings easier.
Let’s say you had a few imports like below. Can you tell which of these
imports will increase the bundle size? (Tip: it’s not all of them!)
```ts
// app/client/src/workers/Linting/utils.ts
import { Position } from "codemirror";
import { LintError as JSHintError, LintOptions } from "jshint";
import { get, isEmpty, isNumber, keys, last, set } from "lodash";
```
It’s pretty hard, right?
What about now?
```ts
// app/client/src/workers/Linting/utils.ts
import type { Position } from "codemirror";
import type { LintError as JSHintError, LintOptions } from "jshint";
import { get, isEmpty, isNumber, keys, last, set } from "lodash";
```
Now, it’s clear that only `lodash` will be bundled.
This helps developers to see which imports are problematic, but it
_also_ helps with refactorings. Now, if you want to see where
`codemirror` is bundled, you can just grep for `import \{.*\} from
"codemirror"` – and you won’t get any type-only imports.
This also helps (some) bundlers. Upon transpiling, TypeScript erases
type-only imports completely. In some environment (not ours), this makes
the bundle smaller, as the bundler doesn’t need to bundle type-only
imports anymore.
## Type of change
- Chore (housekeeping or task changes that don't impact user perception)
## How Has This Been Tested?
This was tested to not break the build.
### Test Plan
> Add Testsmith test cases links that relate to this PR
### Issues raised during DP testing
> Link issues raised during DP testing for better visiblity and tracking
(copy link from comments dropped on this PR)
## Checklist:
### Dev activity
- [x] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my own code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [ ] New and existing unit tests pass locally with my changes
- [ ] PR is being merged under a feature flag
### QA activity:
- [ ] Test plan has been approved by relevant developers
- [ ] Test plan has been peer reviewed by QA
- [ ] Cypress test cases have been added and approved by either SDET or
manual QA
- [ ] Organized project review call with relevant stakeholders after
Round 1/2 of QA
- [ ] Added Test Plan Approved label after reveiwing all Cypress test
---------
Co-authored-by: Satish Gandham <hello@satishgandham.com>
Co-authored-by: Satish Gandham <satish.iitg@gmail.com>
931 lines
26 KiB
TypeScript
931 lines
26 KiB
TypeScript
import type { Schema, SchemaItem } from "./constants";
|
|
import {
|
|
ARRAY_ITEM_KEY,
|
|
DataType,
|
|
FieldType,
|
|
ROOT_SCHEMA_KEY,
|
|
} from "./constants";
|
|
import {
|
|
convertSchemaItemToFormData,
|
|
countFields,
|
|
mergeAllObjectsInAnArray,
|
|
schemaItemDefaultValue,
|
|
validateOptions,
|
|
} from "./helper";
|
|
|
|
describe(".schemaItemDefaultValue", () => {
|
|
it("returns array default value when sub array fields don't have default value", () => {
|
|
const schemaItem = {
|
|
accessor: "education",
|
|
identifier: "education",
|
|
originalIdentifier: "education",
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
isVisible: true,
|
|
defaultValue: [
|
|
{
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
],
|
|
children: {
|
|
__array_item__: {
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
defaultValue: undefined,
|
|
isVisible: true,
|
|
children: {
|
|
college: {
|
|
label: "College",
|
|
children: {},
|
|
isVisible: true,
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "college",
|
|
identifier: "college",
|
|
originalIdentifier: "college",
|
|
},
|
|
graduationDate: {
|
|
children: {},
|
|
isVisible: true,
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.DATEPICKER,
|
|
accessor: "graduationDate",
|
|
identifier: "graduationDate",
|
|
originalIdentifier: "graduationDate",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as unknown as SchemaItem;
|
|
|
|
const expectedDefaultValue = [
|
|
{
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
];
|
|
|
|
const result = schemaItemDefaultValue(schemaItem, "identifier");
|
|
|
|
expect(result).toEqual(expectedDefaultValue);
|
|
});
|
|
|
|
it("returns array default value when sub array fields don't have default value with accessor keys", () => {
|
|
const schemaItem = {
|
|
accessor: "education 1",
|
|
identifier: "education",
|
|
originalIdentifier: "education",
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
isVisible: true,
|
|
defaultValue: [
|
|
{
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
],
|
|
children: {
|
|
__array_item__: {
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
defaultValue: undefined,
|
|
isVisible: true,
|
|
children: {
|
|
college: {
|
|
label: "College",
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "graduating college",
|
|
identifier: "college",
|
|
originalIdentifier: "college",
|
|
isVisible: true,
|
|
},
|
|
graduationDate: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.DATEPICKER,
|
|
accessor: "graduation date",
|
|
identifier: "graduationDate",
|
|
originalIdentifier: "graduationDate",
|
|
isVisible: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as unknown as SchemaItem;
|
|
|
|
const expectedDefaultValue = [
|
|
{
|
|
"graduating college": "String field",
|
|
"graduation date": "10/12/2021",
|
|
},
|
|
];
|
|
|
|
const result = schemaItemDefaultValue(schemaItem, "accessor");
|
|
|
|
expect(result).toEqual(expectedDefaultValue);
|
|
});
|
|
|
|
it("returns merged default value when sub array fields have default value", () => {
|
|
const schemaItem = {
|
|
name: "education",
|
|
accessor: "education",
|
|
identifier: "education",
|
|
originalIdentifier: "education",
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
isVisible: true,
|
|
defaultValue: [
|
|
{
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
],
|
|
children: {
|
|
__array_item__: {
|
|
accessor: ARRAY_ITEM_KEY,
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
defaultValue: {
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
isVisible: true,
|
|
children: {
|
|
college: {
|
|
label: "College",
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: "Some college name",
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "college",
|
|
identifier: "college",
|
|
originalIdentifier: "college",
|
|
isVisible: true,
|
|
},
|
|
graduationDate: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.DATEPICKER,
|
|
accessor: "graduationDate",
|
|
identifier: "graduationDate",
|
|
originalIdentifier: "graduationDate",
|
|
isVisible: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as unknown as SchemaItem;
|
|
|
|
const expectedDefaultValue = [
|
|
{
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
];
|
|
|
|
const result = schemaItemDefaultValue(schemaItem, "identifier");
|
|
|
|
expect(result).toEqual(expectedDefaultValue);
|
|
});
|
|
|
|
it("returns merged default value when array field has default value more than one item", () => {
|
|
const schemaItem = {
|
|
name: "education",
|
|
accessor: "education",
|
|
identifier: "education",
|
|
originalIdentifier: "education",
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
defaultValue: [
|
|
{
|
|
college: "String field 1",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
{
|
|
college: "String field 2",
|
|
graduationDate: "30/12/2021",
|
|
},
|
|
],
|
|
children: {
|
|
__array_item__: {
|
|
accessor: ARRAY_ITEM_KEY,
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
isVisible: true,
|
|
defaultValue: {
|
|
college: "String field",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
children: {
|
|
college: {
|
|
label: "College",
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: "Some college name",
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "college",
|
|
identifier: "college",
|
|
originalIdentifier: "college",
|
|
isVisible: true,
|
|
},
|
|
graduationDate: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.DATEPICKER,
|
|
accessor: "graduationDate",
|
|
identifier: "graduationDate",
|
|
originalIdentifier: "graduationDate",
|
|
isVisible: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as unknown as SchemaItem;
|
|
|
|
const expectedDefaultValue = [
|
|
{
|
|
college: "String field 1",
|
|
graduationDate: "10/12/2021",
|
|
},
|
|
{
|
|
college: "String field 2",
|
|
graduationDate: "30/12/2021",
|
|
},
|
|
];
|
|
|
|
const result = schemaItemDefaultValue(schemaItem, "identifier");
|
|
|
|
expect(result).toEqual(expectedDefaultValue);
|
|
});
|
|
|
|
it("returns only sub array fields default value, when array level default value is empty", () => {
|
|
const schemaItem = {
|
|
accessor: "education",
|
|
identifier: "education",
|
|
originalIdentifier: "education",
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
defaultValue: undefined,
|
|
children: {
|
|
__array_item__: {
|
|
accessor: ARRAY_ITEM_KEY,
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
defaultValue: undefined,
|
|
children: {
|
|
college: {
|
|
label: "College",
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: "Some college name",
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "college",
|
|
identifier: "college",
|
|
originalIdentifier: "college",
|
|
},
|
|
graduationDate: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: "10/10/2001",
|
|
fieldType: FieldType.DATEPICKER,
|
|
accessor: "graduationDate",
|
|
identifier: "graduationDate",
|
|
originalIdentifier: "graduationDate",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as unknown as SchemaItem;
|
|
|
|
const expectedDefaultValue = [
|
|
{
|
|
college: "Some college name",
|
|
graduationDate: "10/10/2001",
|
|
},
|
|
];
|
|
|
|
const result = schemaItemDefaultValue(schemaItem, "identifier");
|
|
|
|
expect(result).toEqual(expectedDefaultValue);
|
|
});
|
|
|
|
it("returns valid default value when non compliant keys in default value is present", () => {
|
|
const schemaItem = {
|
|
accessor: "education",
|
|
identifier: "education",
|
|
originalIdentifier: "education",
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
defaultValue: [
|
|
{
|
|
"graduating college": "Some college name",
|
|
"graduation date": "10/10/2001",
|
|
},
|
|
],
|
|
children: {
|
|
__array_item__: {
|
|
accessor: ARRAY_ITEM_KEY,
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
defaultValue: undefined,
|
|
isVisible: true,
|
|
children: {
|
|
graduating_college: {
|
|
label: "College",
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "college",
|
|
identifier: "graduating_college",
|
|
originalIdentifier: "graduating college",
|
|
isVisible: true,
|
|
},
|
|
graduation_date: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
defaultValue: undefined,
|
|
fieldType: FieldType.DATEPICKER,
|
|
accessor: "newDate",
|
|
identifier: "graduation_date",
|
|
originalIdentifier: "graduation date",
|
|
isVisible: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
} as unknown as SchemaItem;
|
|
|
|
const expectedDefaultValue = [
|
|
{
|
|
college: "Some college name",
|
|
newDate: "10/10/2001",
|
|
},
|
|
];
|
|
|
|
const result = schemaItemDefaultValue(schemaItem, "identifier");
|
|
|
|
expect(result).toEqual(expectedDefaultValue);
|
|
});
|
|
});
|
|
|
|
describe(".validateOptions", () => {
|
|
it("returns values passed for valid values", () => {
|
|
const inputAndExpectedOutput = [
|
|
[[""], true],
|
|
[[0], true],
|
|
[[true], true],
|
|
[[false], true],
|
|
[[{}, ""], false],
|
|
[[{}, null], false],
|
|
[[{}, undefined], false],
|
|
[[{}, NaN], false],
|
|
[["test", null], false],
|
|
[["test", undefined], false],
|
|
[["test", NaN], false],
|
|
[["", null], false],
|
|
[["", undefined], false],
|
|
[["", NaN], false],
|
|
[[0, null], false],
|
|
[[0, undefined], false],
|
|
[[0, NaN], false],
|
|
[[1, null], false],
|
|
[[1, undefined], false],
|
|
[[1, NaN], false],
|
|
[[{ label: "", value: "" }], true],
|
|
[[{ label: "", value: "" }, { label: "" }], false],
|
|
[{ label: "", value: "" }, false],
|
|
["label", false],
|
|
[1, false],
|
|
[null, false],
|
|
[undefined, false],
|
|
[NaN, false],
|
|
[["one", "two"], true],
|
|
[[1, 2], true],
|
|
];
|
|
|
|
inputAndExpectedOutput.forEach(([input, expectedOutput]) => {
|
|
const result = validateOptions(input);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe(".mergeAllObjectsInAnArray", () => {
|
|
it("returns merged array", () => {
|
|
const input = [
|
|
{
|
|
number: 10,
|
|
text: "text",
|
|
obj: {
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: ["a", "b"],
|
|
obj: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
number1: 10,
|
|
text2: "text",
|
|
obj: {
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: ["a", "b"],
|
|
obj1: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
const expectedOutput = {
|
|
number: 10,
|
|
text: "text",
|
|
number1: 10,
|
|
text2: "text",
|
|
obj: {
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: ["a", "b"],
|
|
obj: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
obj1: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const result = mergeAllObjectsInAnArray(input);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
});
|
|
|
|
describe(".countFields", () => {
|
|
it("return number of fields in an object", () => {
|
|
const inputAndExpectedOutput = [
|
|
{ input: { foo: { bar: 10 } }, expectedOutput: 2 },
|
|
{ input: { foo: { bar: 10 }, arr: ["1", "2", "3"] }, expectedOutput: 3 },
|
|
{
|
|
input: {
|
|
foo: { bar: 10 },
|
|
arr: ["1", "2", "3"],
|
|
arr1: [{ a: 10 }, { c: 10, d: { e: 20, k: ["a", "b"] } }],
|
|
},
|
|
expectedOutput: 14,
|
|
},
|
|
{
|
|
input: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
obj: {
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: ["a", "b"],
|
|
obj: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
arr2: ["1", "2"],
|
|
arr1: [
|
|
{
|
|
number: 10,
|
|
text: "text",
|
|
obj: {
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: ["a", "b"],
|
|
obj: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
number1: 10,
|
|
text2: "text",
|
|
obj: {
|
|
arr: {
|
|
number: 10,
|
|
text: "text",
|
|
arr: ["a", "b"],
|
|
obj1: {
|
|
a: 10,
|
|
c: 20,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
expectedOutput: 45,
|
|
},
|
|
];
|
|
|
|
inputAndExpectedOutput.forEach(({ expectedOutput, input }) => {
|
|
const result = countFields(input);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe(".convertSchemaItemToFormData", () => {
|
|
const schema = {
|
|
__root_schema__: {
|
|
children: {
|
|
customField1: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "gender",
|
|
identifier: "customField1",
|
|
originalIdentifier: "customField1",
|
|
isVisible: true,
|
|
},
|
|
customField2: {
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "age",
|
|
identifier: "customField2",
|
|
originalIdentifier: "customField2",
|
|
isVisible: false,
|
|
},
|
|
hiddenNonASCII: {
|
|
isVisible: false,
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "हिन्दि",
|
|
identifier: "hiddenNonASCII",
|
|
originalIdentifier: "हिन्दि",
|
|
},
|
|
hiddenSmiley: {
|
|
isVisible: false,
|
|
children: {},
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "😀",
|
|
identifier: "hiddenSmiley",
|
|
originalIdentifier: "😀",
|
|
},
|
|
array: {
|
|
children: {
|
|
__array_item__: {
|
|
children: {
|
|
name: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "firstName",
|
|
identifier: "name",
|
|
originalIdentifier: "name",
|
|
isVisible: true,
|
|
},
|
|
date: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "graduationDate",
|
|
identifier: "date",
|
|
originalIdentifier: "date",
|
|
isVisible: false,
|
|
},
|
|
},
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
accessor: ARRAY_ITEM_KEY,
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
isVisible: true,
|
|
},
|
|
},
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
accessor: "students",
|
|
identifier: "array",
|
|
originalIdentifier: "array",
|
|
isVisible: true,
|
|
},
|
|
hiddenArray: {
|
|
children: {
|
|
__array_item__: {
|
|
children: {
|
|
name: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "firstName",
|
|
identifier: "name",
|
|
originalIdentifier: "name",
|
|
isVisible: true,
|
|
},
|
|
},
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
accessor: ARRAY_ITEM_KEY,
|
|
identifier: ARRAY_ITEM_KEY,
|
|
originalIdentifier: ARRAY_ITEM_KEY,
|
|
isVisible: true,
|
|
},
|
|
},
|
|
dataType: DataType.ARRAY,
|
|
fieldType: FieldType.ARRAY,
|
|
accessor: "testHiddenArray",
|
|
identifier: "hiddenArray",
|
|
originalIdentifier: "hiddenArray",
|
|
isVisible: false,
|
|
},
|
|
visibleObject: {
|
|
children: {
|
|
name: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "firstName",
|
|
identifier: "name",
|
|
originalIdentifier: "name",
|
|
isVisible: true,
|
|
},
|
|
date: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "graduationDate",
|
|
identifier: "date",
|
|
originalIdentifier: "date",
|
|
isVisible: false,
|
|
},
|
|
},
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
accessor: "testVisibleObject",
|
|
identifier: "visibleObject",
|
|
originalIdentifier: "visibleObject",
|
|
isVisible: true,
|
|
},
|
|
hiddenObject: {
|
|
children: {
|
|
name: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "firstName",
|
|
identifier: "name",
|
|
originalIdentifier: "name",
|
|
isVisible: true,
|
|
},
|
|
date: {
|
|
dataType: DataType.STRING,
|
|
fieldType: FieldType.TEXT_INPUT,
|
|
accessor: "graduationDate",
|
|
identifier: "date",
|
|
originalIdentifier: "date",
|
|
isVisible: false,
|
|
},
|
|
},
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
accessor: "testHiddenObject",
|
|
identifier: "hiddenObject",
|
|
originalIdentifier: "hiddenObject",
|
|
isVisible: false,
|
|
},
|
|
},
|
|
dataType: DataType.OBJECT,
|
|
fieldType: FieldType.OBJECT,
|
|
accessor: "",
|
|
identifier: "",
|
|
originalIdentifier: "",
|
|
isVisible: true,
|
|
},
|
|
} as unknown as Schema;
|
|
|
|
it("replaces data with accessor keys to identifier keys", () => {
|
|
const formData = {
|
|
gender: "male",
|
|
age: "20",
|
|
students: [
|
|
{ firstName: "test1", graduationDate: "10/12/2010" },
|
|
{ firstName: "test2", graduationDate: "14/02/2010" },
|
|
],
|
|
testHiddenArray: [{ firstName: "test1" }, { firstName: "test2" }],
|
|
testVisibleObject: { firstName: "test1", graduationDate: "10/12/2010" },
|
|
testHiddenObject: { firstName: "test1", graduationDate: "10/12/2010" },
|
|
};
|
|
|
|
const expectedOutput = {
|
|
customField1: "male",
|
|
array: [{ name: "test1" }, { name: "test2" }],
|
|
visibleObject: { name: "test1" },
|
|
};
|
|
|
|
const result = convertSchemaItemToFormData(
|
|
schema[ROOT_SCHEMA_KEY],
|
|
formData,
|
|
{ fromId: "accessor", toId: "identifier" },
|
|
);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
|
|
it("replaces data with identifier keys to accessor keys", () => {
|
|
const formData = {
|
|
customField1: "male",
|
|
customField2: "demo",
|
|
array: [{ name: "test1" }, { name: "test2" }],
|
|
hiddenArray: [{ name: "test1" }, { name: "test2" }],
|
|
visibleObject: { name: "test1", date: "10/12/2010" },
|
|
hiddenObject: { name: "test1", date: "10/12/2010" },
|
|
};
|
|
|
|
const expectedOutput = {
|
|
gender: "male",
|
|
students: [{ firstName: "test1" }, { firstName: "test2" }],
|
|
testVisibleObject: { firstName: "test1" },
|
|
};
|
|
|
|
const result = convertSchemaItemToFormData(
|
|
schema[ROOT_SCHEMA_KEY],
|
|
formData,
|
|
{ fromId: "identifier", toId: "accessor" },
|
|
);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
|
|
it("replaces data with identifier keys to accessor keys when keys are missing", () => {
|
|
const formData = {
|
|
customField1: "male",
|
|
customField2: "demo1",
|
|
customField3: "demo2",
|
|
hiddenArray: [{ name: "test1" }, { name: "test2" }],
|
|
visibleObject: { name: "test1", date: "10/12/2010" },
|
|
hiddenObject: { name: "test1", date: "10/12/2010" },
|
|
};
|
|
|
|
const expectedOutput = {
|
|
gender: "male",
|
|
testVisibleObject: { firstName: "test1" },
|
|
};
|
|
|
|
const result = convertSchemaItemToFormData(
|
|
schema[ROOT_SCHEMA_KEY],
|
|
formData,
|
|
{ fromId: "identifier", toId: "accessor" },
|
|
);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
|
|
it("replaces data with identifier keys to accessor keys when keys are undefined", () => {
|
|
const formData = {
|
|
customField1: "male",
|
|
customField2: "demo",
|
|
array: [{ name: "test1" }, { name: undefined }],
|
|
hiddenArray: [{ name: "test1" }, { name: "test2" }],
|
|
visibleObject: { name: "test1", date: "10/12/2010" },
|
|
hiddenObject: { name: "test1", date: "10/12/2010" },
|
|
};
|
|
|
|
const expectedOutput = {
|
|
gender: "male",
|
|
students: [{ firstName: "test1" }, { firstName: undefined }],
|
|
testVisibleObject: { firstName: "test1" },
|
|
};
|
|
|
|
const result = convertSchemaItemToFormData(
|
|
schema[ROOT_SCHEMA_KEY],
|
|
formData,
|
|
{ fromId: "identifier", toId: "accessor" },
|
|
);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
|
|
it("set hidden form field value to available source field value when useSourceData is set to true", () => {
|
|
const formData = {
|
|
customField1: "male",
|
|
customField2: "demo",
|
|
array: [{ name: "test1" }, { name: null, date: "10/12/2010" }],
|
|
hiddenArray: [{ name: "test1" }, { name: "test2" }],
|
|
visibleObject: { name: "test1", date: "10/12/2010" },
|
|
hiddenObject: { name: "test1", date: "10/12/2010" },
|
|
};
|
|
|
|
const sourceData = {
|
|
customField1: "soruceMale",
|
|
customField2: "sourceDemo",
|
|
array: [
|
|
{ name: "sourceTest1" },
|
|
{ name: "sourceTest2", date: "11/11/1111" },
|
|
],
|
|
hiddenArray: [{ name: "sourceTest1" }, { name: "sourceTest2" }],
|
|
hiddenObject: { name: "sourceTest1" },
|
|
};
|
|
|
|
const expectedOutput = {
|
|
gender: "male",
|
|
age: "sourceDemo",
|
|
students: [
|
|
{ firstName: "test1" },
|
|
{ firstName: null, graduationDate: "11/11/1111" },
|
|
],
|
|
testHiddenArray: [
|
|
{ firstName: "sourceTest1" },
|
|
{ firstName: "sourceTest2" },
|
|
],
|
|
testVisibleObject: { firstName: "test1" },
|
|
testHiddenObject: { firstName: "sourceTest1" },
|
|
};
|
|
|
|
const result = convertSchemaItemToFormData(
|
|
schema[ROOT_SCHEMA_KEY],
|
|
formData,
|
|
{
|
|
fromId: "identifier",
|
|
toId: "accessor",
|
|
sourceData: sourceData,
|
|
useSourceData: true,
|
|
},
|
|
);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
|
|
it("return expected result for non-ASCII source value when field is hidden and useSourceData is set to true", () => {
|
|
const formData = {
|
|
customField1: "male",
|
|
array: [{ name: "test1" }, { name: null, date: "10/12/2010" }],
|
|
hiddenNonASCII: "test",
|
|
hiddenSmiley: "test 2",
|
|
visibleObject: { name: "test1", date: "10/12/2010" },
|
|
};
|
|
|
|
const sourceData = {
|
|
हिन्दि: "हिन्दि",
|
|
"😀": "😀",
|
|
};
|
|
|
|
const expectedOutput = {
|
|
gender: "male",
|
|
students: [{ firstName: "test1" }, { firstName: null }],
|
|
हिन्दि: "हिन्दि",
|
|
"😀": "😀",
|
|
testVisibleObject: { firstName: "test1" },
|
|
};
|
|
|
|
const result = convertSchemaItemToFormData(
|
|
schema[ROOT_SCHEMA_KEY],
|
|
formData,
|
|
{
|
|
fromId: "identifier",
|
|
toId: "accessor",
|
|
sourceData: sourceData,
|
|
useSourceData: true,
|
|
},
|
|
);
|
|
|
|
expect(result).toEqual(expectedOutput);
|
|
});
|
|
});
|