@commercetools-frontend/experimental-components 0.0.2 → 0.0.3

package/src/utils/validation/validation.js

@@ -1,169 +0,0 @@
-import { defineMessages } from 'react-intl';
-import { deepEqual } from 'fast-equals';
-
-export const messages = defineMessages({
-  unique: {
-    id: 'Validation.unique',
-    description: 'An error message to show if the field must be unique',
-    defaultMessage:
-      'The value you have entered already exists in this list of ' +
-      'values. Please add only unique values to this list.',
-  },
-  required: {
-    id: 'Validation.required',
-    description: 'An error message to show if the field is required',
-    defaultMessage: 'Please fill in this required field.',
-  },
-  numeric: {
-    id: 'Validation.numeric',
-    description: 'An error message to show if the field must be numeric',
-    defaultMessage:
-      'Please enter only numbers (0 - 9) and decimal ' +
-      'separators in this field.',
-  },
-  integer: {
-    id: 'Validation.integer',
-    description: 'An error message to show if the field must be integer',
-    defaultMessage: 'Please enter only numbers (0 - 9) in this field.',
-  },
-  email: {
-    id: 'Validation.email',
-    description:
-      'An error message to show if the field must be a ' +
-      'valid email address',
-    defaultMessage: 'Please enter a valid email address.',
-  },
-  notFound: {
-    id: 'Validation.notFound',
-    description: 'An error message to show a resource id was not found',
-    defaultMessage: 'The resource was not found',
-  },
-  invalid: {
-    id: 'Validation.invalid',
-    description: 'An error message to show the id is invalid',
-    defaultMessage: 'The resource id is invalid',
-  },
-});
-
-/**
-* This takes in an array of values or objects and returns an array of values
-* that are duplicated in the original array. If the properties param is
-* specified then only those fields of any objects are compared
-*
-* @param values         Array of values to check
-* @param properties     Array of strings containing names of
-*                         object properties to check
-* @param ignoredValues  Array of values to ignore, defaults to empty string,
-                          null and undefined
-* @return               Array of strings or objects that are
-*                         duplicated in original values
-*/
-export function unique(
-  values,
-  properties,
-  ignoredValues = ['', null, undefined]
-) {
-  const duplicateValues = [];
-  let realValues;
-
-  // Strip out ignored values
-  realValues = values.filter((value) => !ignoredValues.includes(value));
-
-  if (!realValues.length) return [];
-
-  if (properties)
-    realValues = realValues.map((value) =>
-      properties.reduce((prev, curr) => {
-        const currentValue = value[curr] || '';
-        return `${prev}:${currentValue}`;
-      }, '')
-    );
-  else realValues = values.slice(0);
-
-  // TODO: checking for dupes like this is slow, find a better way
-  realValues.sort().reduce((prev, curr) => {
-    if (curr === null) return curr;
-
-    if (curr !== '' && prev === curr && duplicateValues.indexOf(curr) === -1)
-      duplicateValues.push(curr);
-
-    return curr;
-  });
-
-  if (properties)
-    return duplicateValues.map((value) => {
-      const parts = value.split(':').slice(1);
-
-      return properties.reduce((prev, curr, index) => {
-        // eslint-disable-next-line no-param-reassign
-        prev[curr] = parts[index];
-        return prev;
-      }, {});
-    });
-
-  return duplicateValues;
-}
-
-/**
- * This function does a dumb deepComparison of each item to produce
- * a list of duplicates. Its probably pretty slow an inefficient, if we have
- * perf issue with it then I've documented a slightly more efficient version of
- * it below
- * @param  Array<Object> items An array of objects to get the duplicate within
- * @return Array<Object> returns an array of objects with all duplicated values
- */
-export function uniqueObjects(items) {
-  const emptyValues = [undefined, null, ''];
-  const itemsWorkingSet =
-    items && items.length
-      ? items.slice().filter((x) => !emptyValues.includes(x))
-      : [];
-  const duplicateValues = itemsWorkingSet.reduce((acc, item, index) => {
-    if (item === null) return acc;
-
-    const isDuplicate = itemsWorkingSet
-      .slice(index + 1) // get sub-array after this index
-      .reduce((duplicateAcc, comparisonItem, comparisonIndex) => {
-        if (comparisonItem === null) return duplicateAcc;
-
-        // check if its a dupe
-        const comparisonIsDuplicate = deepEqual(item, comparisonItem);
-
-        // if and item is a duplicate, we set item in the original array to
-        // null. This means we don't have to compare it again, we can just
-        // skip it
-        if (comparisonIsDuplicate)
-          itemsWorkingSet[comparisonIndex + index + 1] = null;
-
-        return duplicateAcc || comparisonIsDuplicate;
-      }, false);
-
-    if (isDuplicate) acc.push(item);
-
-    return acc;
-  }, []);
-
-  return duplicateValues;
-}
-
-/**
- * A MAYBE BETTER WAY...
-
- INPUT: [ { en: 'hi' }, { en: 'hi', de: 'hallo' }, { de: 'hallo', en: 'hi' } ]
-
-
- STEP 1. collect object by concatenating their keys to produce this:
-
- _NB_ you will need to sort the keys when comparing them!
-
- STEP 1 OUTPUT: { en: [ 0 ], "de:en": [ 1, 2 ] }
-
-
- STEP 2. Drop anything from this key map that only has a length of 1:
-
- STEP 2 OUTPUT: { "de:en": [ 1, 2 ] }
-
-
- STEP 3. Compare everything in the sub-arrays as normal
-
- */

package/src/utils/validation/validation.spec.js

@@ -1,99 +0,0 @@
-import { unique, uniqueObjects } from './validation';
-
-describe('unique', () => {
-  let data;
-  describe('when there are duplicated values', () => {
-    beforeEach(() => {
-      data = [
-        { id: 1, value: 'value1' },
-        { id: 2, value: 'value2' },
-        { id: 3, value: 'value3' },
-        { id: 4, value: 'value2' },
-        { id: 3, value: 'value5' },
-        { id: 1, value: 'value1' },
-      ];
-    });
-    it('should find the duplicate values in an array by id', () => {
-      const duplicatedValues = unique(data, ['id']);
-      expect(duplicatedValues).toEqual([{ id: '1' }, { id: '3' }]);
-    });
-    it('should find the duplicate values in an array by value', () => {
-      const duplicatedValues = unique(data, ['value']);
-      expect(duplicatedValues).toEqual([
-        { value: 'value1' },
-        { value: 'value2' },
-      ]);
-    });
-
-    it('should find the duplicate values in an array by id and value', () => {
-      const duplicatedValues = unique(data, ['id', 'value']);
-      expect(duplicatedValues).toEqual([{ id: '1', value: 'value1' }]);
-    });
-  });
-});
-
-describe('uniqueObjects', () => {
-  let testArray;
-  describe('when there are duplicated values', () => {
-    beforeEach(() => {
-      testArray = [
-        { en: 'hi' },
-        { en: 'hi', de: 'hallo' },
-        { de: 'hallo' },
-        { es: 'hola' },
-        { en: 'hi', de: 'hallo' },
-      ];
-    });
-    it('should return one duplicate value', () => {
-      expect(uniqueObjects(testArray)).toEqual([{ en: 'hi', de: 'hallo' }]);
-    });
-  });
-  describe('when there are multiple duplicated values', () => {
-    beforeEach(() => {
-      testArray = [
-        { en: 'hi', de: 'hallo' },
-        { en: 'hi' },
-        { en: 'hi', de: 'hallo' },
-        { de: 'hallo' },
-        { es: 'hola' },
-        { en: 'hi', de: 'hallo' },
-        { de: 'hallo' },
-      ];
-    });
-    it('should return multiple duplicate values', () => {
-      expect(uniqueObjects(testArray)).toEqual([
-        { en: 'hi', de: 'hallo' },
-        { de: 'hallo' },
-      ]);
-    });
-  });
-  describe('when there are no duplicates', () => {
-    beforeEach(() => {
-      testArray = [
-        { en: 'hi' },
-        { en: 'hi', de: 'hallo' },
-        { de: 'hallo' },
-        { es: 'hola' },
-      ];
-    });
-    it('should return an empty list', () => {
-      expect(uniqueObjects(testArray)).toEqual([]);
-    });
-  });
-  describe('when `items` is `undefined`', () => {
-    beforeEach(() => {
-      testArray = undefined;
-    });
-    it('should return an empty list', () => {
-      expect(uniqueObjects(testArray)).toEqual([]);
-    });
-  });
-  describe('when `items` is `null`', () => {
-    beforeEach(() => {
-      testArray = undefined;
-    });
-    it('should return an empty list', () => {
-      expect(uniqueObjects(testArray)).toEqual([]);
-    });
-  });
-});

package/src/utils/validation/without-empty-errors-by-field.js

@@ -1,5 +0,0 @@
-import omitEmpty from 'omit-empty-es';
-
-const withoutEmptyErrorsByField = (errorsByField) => omitEmpty(errorsByField);
-
-export default withoutEmptyErrorsByField;

package/src/utils/validation/without-empty-errors-by-field.spec.js

@@ -1,74 +0,0 @@
-import withoutEmptyErrorsByField from './without-empty-errors-by-field';
-
-describe('withoutEmptyErrorsByField', () => {
-  describe('with empty errors', () => {
-    const errorsByField = {
-      fieldA: {
-        required: true,
-      },
-      fieldB: {},
-    };
-
-    it('should remove fields without errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField).fieldB).not.toBeDefined();
-    });
-
-    it('should keep fields with errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField).fieldA).toBeDefined();
-    });
-
-    it('should not change fields with errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField)).toHaveProperty(
-        'fieldA',
-        errorsByField.fieldA
-      );
-    });
-  });
-
-  describe('without empty errors', () => {
-    const errorsByField = {
-      fieldA: {
-        required: true,
-      },
-    };
-    it('should keep fields with errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField).fieldA).toBeDefined();
-    });
-
-    it('should not change fields with errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField)).toHaveProperty(
-        'fieldA',
-        errorsByField.fieldA
-      );
-    });
-  });
-
-  describe('with nested errors', () => {
-    const errorsByField = {
-      fieldA: {
-        fieldB: {
-          required: true,
-        },
-      },
-      fieldC: { fieldD: {} },
-    };
-
-    it('should remove fields without errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField).fieldC).not.toBeDefined();
-    });
-
-    it('should keep fields with errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField).fieldA).toBeDefined();
-      expect(
-        withoutEmptyErrorsByField(errorsByField).fieldA.fieldB
-      ).toBeDefined();
-    });
-
-    it('should not change fields with errors', () => {
-      expect(withoutEmptyErrorsByField(errorsByField)).toHaveProperty(
-        'fieldA',
-        errorsByField.fieldA
-      );
-    });
-  });
-});

package/src/utils/with-pending-requests/index.js

@@ -1 +0,0 @@
-export { default } from './with-pending-requests';

package/src/utils/with-pending-requests/with-pending-requests.jsx

@@ -1,21 +0,0 @@
-import { wrapDisplayName, usePendingRequests } from '../../internal-index';
-
-function withPendingRequests(propName = 'pendingRequests') {
-  return (Component) => {
-    const WrappedComponent = (props) => {
-      const pendingRequests = usePendingRequests();
-      const pendingProp = {
-        [propName]: pendingRequests,
-      };
-      return <Component {...props} {...pendingProp} />;
-    };
-    WrappedComponent.displayName = wrapDisplayName(
-      Component,
-      'withPendingRequests'
-    );
-
-    return WrappedComponent;
-  };
-}
-
-export default withPendingRequests;

package/src/utils/with-pending-requests/with-pending-requests.spec.js

@@ -1,62 +0,0 @@
-import {
-  act,
-  renderApp,
-} from '@commercetools-frontend/application-shell/test-utils';
-import withPendingRequests from './with-pending-requests';
-
-function render(propName = 'pendingRequests', renderOptions) {
-  let exposedPendingRequests = {};
-
-  // eslint-disable-next-line react/prop-types
-  function TestComponent(props) {
-    const { [propName]: pendingRequests } = props;
-    exposedPendingRequests = pendingRequests;
-    return null;
-  }
-
-  const EnhancedComponent = withPendingRequests(propName)(TestComponent);
-  const rendered = renderApp(<EnhancedComponent />, {
-    ...renderOptions,
-  });
-
-  return {
-    rendered,
-    pendingRequests: exposedPendingRequests,
-  };
-}
-
-it('should not be able to update the state after the component was unmounted', () => {
-  // the use case here is when increment/decrement is being invoked after an
-  // async request is done. This may happen when the component was already
-  // unmounted. In this case the state should not be updated because it's not
-  // possible to do so on an unmounted component
-
-  const { pendingRequests, rendered } = render();
-
-  rendered.unmount();
-
-  // increment pending requests.
-  act(() => pendingRequests.increment());
-
-  // state should not have been updated, otherwise a warning will be thrown
-  // "Can't perform a React state update on an unmounted component."
-  expect(pendingRequests.isLoading).toBeFalse();
-});
-
-it('should inject the api as pendingRequests prop when propName was not provided', () => {
-  const { pendingRequests } = render();
-  expect(pendingRequests).toStrictEqual({
-    isLoading: expect.toBeBoolean(),
-    increment: expect.toBeFunction(),
-    decrement: expect.toBeFunction(),
-  });
-});
-
-it('should inject the api as propName prop when propName was provided', () => {
-  const { pendingRequests } = render('customPendingRequests');
-  expect(pendingRequests).toStrictEqual({
-    isLoading: expect.toBeBoolean(),
-    increment: expect.toBeFunction(),
-    decrement: expect.toBeFunction(),
-  });
-});