@heartlandone/vega 2.79.0 → 2.80.0

package/dist/collection/helpers/validator/test/rules/public-rules.test.js

@@ -1,80 +0,0 @@
-import { RequiredFieldRule, CheckBoxRequiredRule, DateRequiredRule, InputPhoneNumberRequiredRule, InputRangeRequiredRule, RichTextEditorRequiredRule, TimeRangeRequiredRule, ToggleSwitchRequiredRule, FileUploaderRequiredRule, TimeRequiredRule, } from '../../../../index';
-describe('public validation rules', () => {
-  test('required field rule should be extendable', () => {
-    const mockCanEvaluate = jest.fn();
-    const mockShouldShowError = jest.fn();
-    const mockEvaluate = jest.fn();
-    class CustomRequiredRule extends RequiredFieldRule {
-      constructor(fieldName) {
-        super();
-        this.fieldName = fieldName;
-      }
-      canEvaluate(input) {
-        return mockCanEvaluate(input);
-      }
-      shouldShowError(status) {
-        return mockShouldShowError(status);
-      }
-      evaluate(input) {
-        return mockEvaluate(input);
-      }
-    }
-    const customRequiredRule = new CustomRequiredRule('Name');
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('check box required rule should be extendable', () => {
-    class CustomRequiredRule extends CheckBoxRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule();
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('date required rule should be extendable', () => {
-    class CustomRequiredRule extends DateRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule({ mode: 'single' });
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('input phone number required rule should be extendable', () => {
-    class CustomRequiredRule extends InputPhoneNumberRequiredRule {
-    }
-    const mockPhoneNumberInputValueGetter = jest.fn();
-    const customRequiredRule = new CustomRequiredRule(mockPhoneNumberInputValueGetter);
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('input range required rule should be extendable', () => {
-    class CustomRequiredRule extends InputRangeRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule();
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('rich text editor required rule should be extendable', () => {
-    class CustomRequiredRule extends RichTextEditorRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule();
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('time range required rule should be extendable', () => {
-    class CustomRequiredRule extends TimeRangeRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule({ timeFormat: '24-hour' });
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('time required rule should be extendable', () => {
-    class CustomRequiredRule extends TimeRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule({ timeFormat: '24-hour' });
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('toggle switch required rule should be extendable', () => {
-    class CustomRequiredRule extends ToggleSwitchRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule();
-    expect(customRequiredRule).toBeDefined();
-  });
-  it('file uploader required rule should be extendable', () => {
-    class CustomRequiredRule extends FileUploaderRequiredRule {
-    }
-    const customRequiredRule = new CustomRequiredRule();
-    expect(customRequiredRule).toBeDefined();
-  });
-});

package/dist/collection/helpers/validator/test/rules/required-field-rule.test.js

@@ -1,126 +0,0 @@
-import { RequiredFieldRule } from '../../rules/required-field-rule';
-test('return result as expect if input can evaluate', () => {
-  const rule = new RequiredFieldRule();
-  const stringInput = rule.canEvaluate('string');
-  expect(stringInput).toEqual(true);
-  const numberInput = rule.canEvaluate(123);
-  expect(numberInput).toEqual(true);
-  const booleanInput = rule.canEvaluate(false);
-  expect(booleanInput).toEqual(true);
-  const arrayInput = rule.canEvaluate(['apple', 'banana']);
-  expect(arrayInput).toEqual(true);
-  const statusInput = rule.canEvaluate('string', {
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: true,
-  });
-  expect(statusInput).toEqual(true);
-});
-test('return result as expect if input can not evaluate', () => {
-  const rule = new RequiredFieldRule();
-  const stringInput = rule.canEvaluate({ name: 'test' });
-  expect(stringInput).toEqual(false);
-});
-test('throw error as expect if input can not evaluate', () => {
-  const rule = new RequiredFieldRule();
-  const props = { name: 'test' };
-  const testFunction = () => {
-    rule.evaluate(props);
-  };
-  expect(testFunction).toThrow();
-});
-test('return evaluate result as expect if input type is number', () => {
-  const rule = new RequiredFieldRule();
-  const stringInput = rule.evaluate(2);
-  expect(stringInput).toEqual({
-    isValid: true,
-    message: '',
-  });
-});
-test('return evaluate result as expect if input type is boolean', () => {
-  const rule = new RequiredFieldRule();
-  const stringInput = rule.evaluate(true);
-  expect(stringInput).toEqual({
-    isValid: true,
-    message: '',
-  });
-});
-test('return evaluate result as expect if input type is string and length greater than 0', () => {
-  const rule = new RequiredFieldRule();
-  const stringInput = rule.evaluate('hi');
-  expect(stringInput).toEqual({
-    isValid: true,
-    message: '',
-  });
-});
-test('return evaluate result as expect if input type is string and length less than 0', () => {
-  const rule = new RequiredFieldRule();
-  const stringInput = rule.evaluate('');
-  expect(stringInput).toEqual({
-    isValid: false,
-    message: 'This field is required',
-  });
-});
-test('return evaluate result as expect if input type is array and length greater than 0', () => {
-  const rule = new RequiredFieldRule();
-  const arrayInput = rule.evaluate(['apple', 'banana']);
-  expect(arrayInput).toEqual({
-    isValid: true,
-    message: '',
-  });
-});
-test('return evaluate result as expect if input type is array and length less than 0', () => {
-  const rule = new RequiredFieldRule();
-  const arrayInput = rule.evaluate([]);
-  expect(arrayInput).toEqual({
-    isValid: false,
-    message: 'This field is required',
-  });
-});
-test('throw error as expect if input type is array and input can not evaluate', () => {
-  const rule = new RequiredFieldRule();
-  const props = [{ name: 'test1' }, { name: 'test2' }];
-  const testFunction = () => {
-    rule.evaluate(props);
-  };
-  expect(testFunction).toThrow();
-});
-test('should not show error message if status is disabled or invisible', () => {
-  const rule = new RequiredFieldRule();
-  expect(rule.shouldShowError({
-    touched: true,
-    modified: true,
-    disabled: true,
-    visible: false,
-  })).toEqual(false);
-});
-test('should show error message if status is not disabled or invisible', () => {
-  const rule = new RequiredFieldRule();
-  expect(rule.shouldShowError({
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: true,
-  })).toEqual(true);
-});
-test('should not show error message if status is not touched or not modified', () => {
-  const rule = new RequiredFieldRule();
-  expect(rule.shouldShowError({
-    touched: false,
-    modified: false,
-    disabled: false,
-    visible: true,
-  })).toEqual(false);
-});
-test('return evaluate result as expect if input is empty', () => {
-  const rule = new RequiredFieldRule();
-  expect(rule.evaluate(null)).toEqual({
-    isValid: false,
-    message: 'This field is required',
-  });
-  expect(rule.evaluate(undefined)).toEqual({
-    isValid: false,
-    message: 'This field is required',
-  });
-});

package/dist/collection/helpers/validator/test/rules/rich-text-editor-required-rule.test.js

@@ -1,360 +0,0 @@
-import { RichTextEditorRequiredRule } from '../../rules/rich-text-editor-required-rule';
-import { VegaRTEContent } from '../../../../components/vega-rich-text-editor/dto/content-state';
-import { generateUUID } from '../../../../utils/misc';
-test('return result as expect if input can evaluate', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(rule.canEvaluate(undefined)).toEqual(true);
-  expect(rule.canEvaluate(null)).toEqual(true);
-  expect(rule.canEvaluate(VegaRTEContent.createEmptyContent())).toEqual(true);
-});
-test('return result as expect if input can not evaluate', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(rule.canEvaluate(123)).toEqual(false);
-  expect(rule.canEvaluate(false)).toEqual(false);
-  expect(rule.canEvaluate(['1', '2'], {
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: false,
-  })).toEqual(false);
-  expect(rule.canEvaluate(VegaRTEContent.createEmptyContent(), {
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: false,
-  })).toEqual(false);
-});
-test('return evaluate result as expect', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(rule.evaluate(null)).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(undefined)).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(VegaRTEContent.createEmptyContent())).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'text',
-          text: 'This is a paragraph',
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'text',
-          text: ' ',
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'text',
-          text: '',
-        },
-      ],
-    },
-    {
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'text',
-          text: '',
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'text',
-          text: '',
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'image',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'image',
-          // eslint-disable-next-line spellcheck/spell-checker
-          url: 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0OCIgaGVpZ2h0PSI0OCIgdmlld0JveD0iMCAwIDQ4IDQ4IiBmaWxsPSJub25lIj48cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTQ4IDI0QzQ4IDM3LjI1NDggMzcuMjU0OCA0OCAyNCA0OEMxMC43NDUyIDQ4IDAgMzcuMjU0OCAwIDI0QzAgMTAuNzQ1MiAxMC43NDUyIDAgMjQgMEMzNy4yNTQ4IDAgNDggMTAuNzQ1MiA0OCAyNFpNMTYuMDAxIDEzLjkxMjVWMzQuNzgyMkgxOS44OTY2VjI1LjY2OUgyNy42ODhWMzQuNzgyMkgzMS41ODM2VjEzLjkxMjVIMjcuNjg4VjIxLjcwMzhIMTkuODk2NlYxMy45MTI1SDE2LjAwMVoiIGZpbGw9IiM1OTYwNjMiLz48L3N2Zz4=',
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  // Bullet list
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'bullet-list',
-      blocks: [
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: 'This is a list-item 1.',
-            },
-          ],
-        },
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: 'This is a list-item 2.',
-            },
-          ],
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'bullet-list',
-      blocks: [
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: '',
-            },
-          ],
-          children: [
-            {
-              id: generateUUID(),
-              type: 'bullet-list',
-              blocks: [
-                {
-                  id: generateUUID(),
-                  type: 'list-item',
-                  nodes: [
-                    {
-                      id: generateUUID(),
-                      type: 'text',
-                      text: 'This is a list item 3-1.',
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'bullet-list',
-      blocks: [
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: '',
-            },
-          ],
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  // Number list
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'number-list',
-      blocks: [
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: 'This is a list-item 1.',
-            },
-          ],
-        },
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: 'This is a list-item 2.',
-            },
-          ],
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'number-list',
-      blocks: [
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: '',
-            },
-          ],
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-  expect(rule.evaluate(VegaRTEContent.fromJSON([
-    {
-      id: generateUUID(),
-      type: 'number-list',
-      blocks: [
-        {
-          id: generateUUID(),
-          type: 'list-item',
-          nodes: [
-            {
-              id: generateUUID(),
-              type: 'text',
-              text: '',
-            },
-          ],
-          children: [
-            {
-              id: generateUUID(),
-              type: 'number-list',
-              blocks: [
-                {
-                  id: generateUUID(),
-                  type: 'list-item',
-                  nodes: [
-                    {
-                      id: generateUUID(),
-                      type: 'text',
-                      text: 'This is a list item 3-1.',
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    },
-  ]))).toEqual({
-    isValid: true,
-    message: '',
-  });
-});
-test('should not show error message if status is disabled or invisible', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(rule.shouldShowError({
-    touched: true,
-    modified: true,
-    disabled: true,
-    visible: false,
-  })).toEqual(false);
-});
-test('should show error message if status is not disabled or invisible', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(rule.shouldShowError({
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: true,
-  })).toEqual(true);
-});
-test('should not show error message if status is not touched or not modified', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(rule.shouldShowError({
-    touched: false,
-    modified: false,
-    disabled: false,
-    visible: true,
-  })).toEqual(false);
-});
-test('throw error as expect if set a error value', () => {
-  const rule = new RichTextEditorRequiredRule();
-  expect(() => {
-    rule.evaluate('1');
-  }).toThrow('Invalid value 1 for rich text editor');
-});

package/dist/collection/helpers/validator/test/rules/time-range-required-rule.test.js

@@ -1,82 +0,0 @@
-import { TimeRangeRequiredRule } from '../../rules/time-range-required-rule';
-test('return result as expect if input can evaluate', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '24-hour' });
-  expect(rule.canEvaluate(['', ''])).toEqual(true);
-  expect(rule.canEvaluate(['01:03', '01:04'])).toEqual(true);
-  expect(rule.canEvaluate(undefined)).toEqual(true);
-  expect(rule.canEvaluate(null)).toEqual(true);
-  expect(rule.canEvaluate([' ', ' '])).toEqual(true);
-  expect(rule.canEvaluate(['01:03', '02:03'], {
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: true,
-  })).toEqual(true);
-});
-test('return result as expect if input can not evaluate', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '24-hour' });
-  expect(rule.canEvaluate(123)).toEqual(false);
-  expect(rule.canEvaluate(false)).toEqual(false);
-  expect(rule.canEvaluate(['01:04', '02:04'], {
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: false,
-  })).toEqual(false);
-});
-test('return evaluate result as expect with 24-hour timeFormat', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '24-hour' });
-  expect(rule.evaluate(null)).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(undefined)).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(['', ''])).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(['01:02 AM', '01:02 PM'])).toEqual({
-    isValid: false,
-    message: `This field is required`,
-  });
-  expect(rule.evaluate(['01:02', '02:02'])).toEqual({
-    isValid: true,
-    message: '',
-  });
-});
-test('should not show error message if status is disabled or invisible', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '12-hour' });
-  expect(rule.shouldShowError({
-    touched: true,
-    modified: true,
-    disabled: true,
-    visible: false,
-  })).toEqual(false);
-});
-test('should show error message if status is not disabled or invisible', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '12-hour' });
-  expect(rule.shouldShowError({
-    touched: true,
-    modified: true,
-    disabled: false,
-    visible: true,
-  })).toEqual(true);
-});
-test('should not show error message if status is not touched or not modified', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '12-hour' });
-  expect(rule.shouldShowError({
-    touched: false,
-    modified: false,
-    disabled: false,
-    visible: true,
-  })).toEqual(false);
-});
-test('throw error as expect if set a error value', () => {
-  const rule = new TimeRangeRequiredRule({ timeFormat: '12-hour' });
-  expect(() => {
-    rule.evaluate('12:00');
-  }).toThrow('Invalid time value 12:00 for range mode');
-});