@commercetools-frontend/experimental-components 0.0.2 → 0.0.3

package/src/utils/type-definitions/type-definitions.spec.js

@@ -1,547 +0,0 @@
-import * as typeDefinitions from './type-definitions';
-
-const createCustomType = () => ({
-  id: '88380bbf-1b4d-4315-9afb-c9a5e1aeca15',
-  version: 1,
-  key: 'category-type-attribute-a8673923',
-  name: {
-    en: 'category-type',
-  },
-  description: {
-    en: 'category-description',
-  },
-  resourceTypeIds: ['category'],
-  fieldDefinitions: [
-    {
-      name: 'Boolean',
-      label: {
-        en: 'boolean bfc0ef4e',
-      },
-      required: false,
-      type: {
-        name: 'Boolean',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'String',
-      label: {
-        en: 'string 67313237',
-      },
-      required: true,
-      type: {
-        name: 'String',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'LocalizedString',
-      label: {
-        en: 'localizedstring c3d441a2',
-      },
-      required: true,
-      type: {
-        name: 'LocalizedString',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'Enum',
-      label: {
-        en: 'enum 29960d0d',
-      },
-      required: false,
-      type: {
-        name: 'Enum',
-        values: [
-          {
-            key: 'enum_value',
-            label: 'enum_label',
-          },
-        ],
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'LocalizedEnum',
-      label: {
-        en: 'localizedenum 32ac5837',
-      },
-      required: true,
-      type: {
-        name: 'LocalizedEnum',
-        values: [
-          {
-            key: 'enum_label_localized',
-            label: {
-              en: 'enum_label_localized',
-            },
-          },
-        ],
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'Number',
-      label: {
-        en: 'number fe84c50d',
-      },
-      required: true,
-      type: {
-        name: 'Number',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'Money',
-      label: {
-        en: 'money 25fb249b',
-      },
-      required: false,
-      type: {
-        name: 'Money',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'Date',
-      label: {
-        en: 'date 599eabc4',
-      },
-      required: true,
-      type: {
-        name: 'Date',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'Time',
-      label: {
-        en: 'time 6deb133b',
-      },
-      required: true,
-      type: {
-        name: 'Time',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'DateTime',
-      label: {
-        en: 'datetime 2df06d9b',
-      },
-      required: false,
-      type: {
-        name: 'DateTime',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'Reference',
-      label: {
-        en: 'reference d9877068',
-      },
-      required: true,
-      type: {
-        name: 'Reference',
-        referenceTypeId: 'category',
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'BooleanSet',
-      label: {
-        en: 'Boolean SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Boolean',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'StringSet',
-      label: {
-        en: 'String SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'String',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'LocalizedStringSet',
-      label: {
-        en: 'LocalizedString SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'LocalizedString',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'EnumSet',
-      label: {
-        en: 'Enum SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Enum',
-          values: [
-            {
-              key: 'enum_value',
-              label: 'enum_label',
-            },
-          ],
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'LocalizedEnumSet',
-      label: {
-        en: 'LocalizedEnum SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'LocalizedEnum',
-          values: [
-            {
-              key: 'enum_label_localized',
-              label: {
-                en: 'enum_label_localized',
-              },
-            },
-          ],
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'NumberSet',
-      label: {
-        en: 'Number SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Number',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'MoneySet',
-      label: {
-        en: 'Money SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Money',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'DateSet',
-      label: {
-        en: 'Date SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Date',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'TimeSet',
-      label: {
-        en: 'Time SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Time',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'DateTimeSet',
-      label: {
-        en: 'DateTime SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'DateTime',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-    {
-      name: 'ReferenceSet',
-      label: {
-        en: 'Reference SET',
-      },
-      required: false,
-      type: {
-        name: 'Set',
-        elementType: {
-          name: 'Reference',
-          referenceTypeId: 'category',
-        },
-      },
-      inputHint: 'SingleLine',
-    },
-  ],
-  createdAt: '2016-06-08T10:20:08.908Z',
-  lastModifiedAt: '2016-06-08T10:20:08.908Z',
-});
-
-const createAttributeValue = ({ type, index }) => {
-  switch (type) {
-    case 'money':
-      return {
-        centAmount: Math.floor(Math.random() * 101),
-        currencyCode: 'EUR',
-      };
-    case 'lenum':
-      return {
-        key: `lenum-${index}`,
-        label: {
-          en: 'lenum',
-        },
-      };
-    case 'enum':
-      return {
-        key: `enum-${index}`,
-        label: 'enum',
-      };
-    case 'number':
-      return Math.floor(Math.random() * 101);
-    case 'ltext':
-      return {
-        en: 'text',
-      };
-    case 'reference':
-      return {
-        id: `reference-${index}`,
-        typeId: 'reference',
-      };
-    case 'date-time':
-      return '2017-01-16T14:00:34.177Z';
-    case 'time':
-      return '14:00';
-    case 'date':
-      return '2017-01-16';
-    default:
-      return 'text';
-  }
-};
-
-const createAttribute = ({ type, isSet }) => ({
-  name: `attribute-${type}`,
-  value: isSet
-    ? Array.from({ length: 10 }).map((_, index) =>
-        createAttributeValue({ type, index })
-      )
-    : createAttributeValue({ type, index: 0 }),
-});
-
-describe('mapping type definitions', () => {
-  describe('getting the type name of type', () => {
-    it('returns the element type name if there is an element type', () => {
-      const type = {
-        name: 'set',
-        elementType: { name: 'enum' },
-      };
-
-      expect(typeDefinitions.getTypeNameOfType(type)).toBe('enum');
-    });
-
-    it('returns the type name if there no element type', () => {
-      const type = { name: 'enum' };
-
-      expect(typeDefinitions.getTypeNameOfType(type)).toBe('enum');
-    });
-  });
-
-  describe('get type of an attribute', () => {
-    it('should return money as attribute-type', () => {
-      const attributeMoney = createAttribute({ type: 'money' });
-      expect(typeDefinitions.getAttributeValueType(attributeMoney.value)).toBe(
-        'money'
-      );
-
-      const attributeMoneySet = createAttribute({
-        type: 'money',
-        isSet: true,
-      });
-
-      expect(
-        typeDefinitions.getAttributeValueType(attributeMoneySet.value)
-      ).toBe('money');
-    });
-
-    it('should return ltext as attribute-type', () => {
-      const attributeLocalizedText = createAttribute({ type: 'ltext' });
-      expect(
-        typeDefinitions.getAttributeValueType(attributeLocalizedText.value)
-      ).toBe('ltext');
-
-      const attributeLocalizedTextSet = createAttribute({
-        type: 'ltext',
-        isSet: true,
-      });
-
-      expect(
-        typeDefinitions.getAttributeValueType(attributeLocalizedTextSet.value)
-      ).toBe('ltext');
-    });
-
-    it('should return text as attribute-type', () => {
-      const attributeText = createAttribute({ type: 'text' });
-      expect(typeDefinitions.getAttributeValueType(attributeText.value)).toBe(
-        'text'
-      );
-
-      const attributeTextSet = createAttribute({ type: 'text', isSet: true });
-      expect(
-        typeDefinitions.getAttributeValueType(attributeTextSet.value)
-      ).toBe('text');
-    });
-
-    it('should return date as attribute-type', () => {
-      const attributeDate = createAttribute({ type: 'date' });
-      expect(typeDefinitions.getAttributeValueType(attributeDate.value)).toBe(
-        'date'
-      );
-
-      const attributeDateSet = createAttribute({ type: 'date', isSet: true });
-      expect(
-        typeDefinitions.getAttributeValueType(attributeDateSet.value)
-      ).toBe('date');
-    });
-
-    it('should return datetime as attribute-type', () => {
-      const attributeDateTime = createAttribute({ type: 'date-time' });
-      expect(
-        typeDefinitions.getAttributeValueType(attributeDateTime.value)
-      ).toBe('date-time');
-
-      const attributeDateTimeSet = createAttribute({
-        type: 'date-time',
-        isSet: true,
-      });
-
-      expect(
-        typeDefinitions.getAttributeValueType(attributeDateTimeSet.value)
-      ).toBe('date-time');
-    });
-
-    it('should return time as attribute-type', () => {
-      const attributeTime = createAttribute({ type: 'time' });
-      expect(typeDefinitions.getAttributeValueType(attributeTime.value)).toBe(
-        'time'
-      );
-
-      const attributeTimeSet = createAttribute({ type: 'time', isSet: true });
-      expect(
-        typeDefinitions.getAttributeValueType(attributeTimeSet.value)
-      ).toBe('time');
-    });
-
-    it('should return reference as attribute-input', () => {
-      const attributeReference = createAttribute({ type: 'reference' });
-      expect(
-        typeDefinitions.getAttributeValueType(attributeReference.value)
-      ).toBe('reference');
-
-      const attributeReferenceSet = createAttribute({
-        type: 'reference',
-        isSet: true,
-      });
-
-      expect(
-        typeDefinitions.getAttributeValueType(attributeReferenceSet.value)
-      ).toBe('reference');
-    });
-
-    it('should return enum as attribute-input', () => {
-      const attributeEnum = createAttribute({ type: 'enum' });
-      expect(typeDefinitions.getAttributeValueType(attributeEnum.value)).toBe(
-        'enum'
-      );
-    });
-  });
-});
-
-describe('omitSetsOfSets', () => {
-  let result;
-  let type;
-  let fieldDefinitions;
-  describe('when there are sets of sets', () => {
-    beforeEach(() => {
-      type = createCustomType();
-      fieldDefinitions = [
-        ...type.fieldDefinitions,
-        {
-          name: 'nested-sets-definition',
-          required: false,
-          label: { en: 'nested-sets-definition' },
-          type: {
-            name: 'Set',
-            elementType: {
-              name: 'Set',
-              elementType: { name: 'String' },
-            },
-          },
-        },
-      ];
-      result = typeDefinitions.omitSetsOfSets(fieldDefinitions);
-    });
-    it('should return fieldDefinitions without sets of sets definitions', () => {
-      expect(result).toEqual(
-        expect.not.arrayContaining([
-          expect.objectContaining({
-            name: 'nested-sets-definition',
-          }),
-        ])
-      );
-    });
-  });
-  describe('when there are no nested sets', () => {
-    beforeEach(() => {
-      type = createCustomType();
-      fieldDefinitions = type.fieldDefinitions;
-      result = typeDefinitions.omitSetsOfSets(fieldDefinitions);
-    });
-    it('should return fieldDefinitions with all the definitions', () => {
-      expect(result).toEqual(type.fieldDefinitions);
-    });
-  });
-});

package/src/utils/update-status-in-list/index.js

@@ -1 +0,0 @@
-export { default } from './update-status-in-list';

package/src/utils/update-status-in-list/update-status-in-list.js

@@ -1,16 +0,0 @@
-export default function updateStatusInList(mergeData) {
-  return (state, { payload }) => {
-    const {
-      currentQueryResult: { results },
-    } = state;
-    const index = results.findIndex((p) => p.id === payload.id);
-    results[index] = mergeData(payload, results[index]);
-    results[index].checked = false;
-    return {
-      currentQueryResult: {
-        ...state.currentQueryResult,
-        results,
-      },
-    };
-  };
-}

package/src/utils/validation/get-indexes-of-invalid-values.js

@@ -1,16 +0,0 @@
-import { deepEqual } from 'fast-equals';
-
-export default function getIndexesOfInvalidValues(values, invalidValues = []) {
-  if (invalidValues.length === 0) return [];
-
-  const getInvalidIndexes = (acc, value, index) => {
-    const isValid = !invalidValues.some((invalidValue) =>
-      deepEqual(value, invalidValue)
-    );
-    if (!isValid) acc.push(index);
-
-    return acc;
-  };
-
-  return values.reduce(getInvalidIndexes, []);
-}

package/src/utils/validation/get-indexes-of-invalid-values.spec.js

@@ -1,31 +0,0 @@
-import getIndexesOfInvalidValues from './get-indexes-of-invalid-values';
-
-describe('getIndexesOfInvalidValues', () => {
-  let values = ['a', 'b', ' c'];
-  let invalidValues;
-  describe('when there are invalid values', () => {
-    beforeEach(() => {
-      invalidValues = ['a'];
-    });
-    it('should return a list of invalid indexes', () => {
-      expect(getIndexesOfInvalidValues(values, invalidValues)).toEqual([0]);
-    });
-  });
-  describe('when there are duplicate invalid values', () => {
-    beforeEach(() => {
-      invalidValues = ['a', 'a'];
-    });
-    it('should return a list of single invalid indexes', () => {
-      expect(getIndexesOfInvalidValues(values, invalidValues)).toEqual([0]);
-    });
-  });
-  describe('when there are duplicate values', () => {
-    beforeEach(() => {
-      values = ['a', 'a'];
-      invalidValues = ['a'];
-    });
-    it('should return a list of single multiple indexes', () => {
-      expect(getIndexesOfInvalidValues(values, invalidValues)).toEqual([0, 1]);
-    });
-  });
-});

package/src/utils/validation/index.js

@@ -1,3 +0,0 @@
-export * from './validation';
-export { default as getIndexesOfInvalidValues } from './get-indexes-of-invalid-values';
-export { default as withoutEmptyErrorsByField } from './without-empty-errors-by-field';